feat(kitrun): render the OAuth credential file with sentinels

A Kit's credential@1 oauth.credentialFile was never rendered: Assemble set
SBX_CRED_<SVC>_MODE=oauth but no file was written, so the harness CLI started
logged out and never reached the token endpoint the egress proxy intercepts.

Render it at launch, for each bound OAuth-managed service that declares one:
the Kit's structure with its access/refresh sentinels, and the stored token
set's expiry for {{.ExpiresAt}}. The renderer's only input about a token set
is that expiry -- the tokens never cross into kit, so a real token cannot be
written (docs/prds/external-agent-harness.md, Verification).

Expiry renders as epoch milliseconds, the unit both in-spec OAuth credential
files use (Claude Code's expiresAt, OpenCode's expires). A placeholder archie
does not render, or a token placeholder with no declared sentinel, refuses the
launch rather than leaving a literal or an empty value in the file.

kitrun reads the store only for a service the run credential carries, and
fails closed when a rendered credential file has no captured token set.
This commit is contained in:
sam committed 2026-09-30 07:36:57 +10:00
1 parent 13b583cdca
commit 215c14a664
6 files changed
+581 -2

No files matched your search

+1 -1
View File
@@ -81,7 +81,7 @@ func (b *boot) setupKitLauncher(ctx context.Context) {
b.kitLauncher = &kitrun.Launcher{
Pool: pool, Fetch: fetcher, Proxy: proxy, Networks: networks,
AgentBinary: agentBinary, CAFile: egress.CACertPath(caDir),
Config: b.cfgHolder, Secrets: b.secrets, Grants: grants,
Config: b.cfgHolder, Secrets: b.secrets, Grants: grants, OAuth: oauthStore,
}
log.Info("kit harness runs enabled", "proxy", ln.Addr().String())
}
@@ -0,0 +1,156 @@
package kit
import (
"encoding/json"
"fmt"
"strings"
"time"
"github.com/BurntSushi/toml"
"github.com/docker/sandbox-kit-spec/v3/spec"
)
// Credential-file placeholders, the vocabulary the Kit spec's
// credentialFile.structure declares. A leaf may reference the token
// sentinels as a whole value or inside a larger string; ExpiresAt is a
// number and so may only be the whole value.
const (
accessPlaceholder = "{{.AccessToken}}"
refreshPlaceholder = "{{.RefreshToken}}"
expiresPlaceholder = "{{.ExpiresAt}}"
// credentialFileMode is owner-only: the file holds sentinels, but the
// path is still a credential the agent alone should read.
credentialFileMode = "0600"
)
// renderCredentialFile renders c's oauth.credentialFile: the declared
// structure with the Kit's sentinels substituted for the token placeholders
// and the stored token set's expiry for {{.ExpiresAt}}, encoded in the
// declared format. expires is the only fact about the stored token set the
// renderer receives, so a real token cannot reach the file
// (docs/prds/external-agent-harness.md, "Verification: the credential file
// holds only sentinels").
func renderCredentialFile(c spec.CredentialCapability, expires time.Time) (string, error) {
cf := c.OAuth.CredentialFile
var sentinels spec.Sentinels
if c.OAuth.Sentinels != nil {
sentinels = *c.OAuth.Sentinels
}
expiresAt := int64(0)
if !expires.IsZero() {
// Both in-spec OAuth credential files (Claude Code's credentials.json
// and OpenCode's auth.json) carry the epoch in milliseconds.
expiresAt = expires.UnixMilli()
}
structure, err := substitutePlaceholders(cf.Structure, sentinels, expiresAt)
if err != nil {
return "", fmt.Errorf("credential %q credential file: %w", c.Service, err)
}
encoded, err := encodeCredentialFile(cf.Format, structure)
if err != nil {
return "", fmt.Errorf("credential %q credential file: %w", c.Service, err)
}
return encoded, nil
}
// substitutePlaceholders replaces every leaf that references a placeholder
// with the typed value the target encoding expects, and refuses a placeholder
// archie does not render rather than leaving it standing in the file.
func substitutePlaceholders(v any, sentinels spec.Sentinels, expiresAt int64) (any, error) {
switch t := v.(type) {
case map[string]any:
out := make(map[string]any, len(t))
for k, e := range t {
sub, err := substitutePlaceholders(e, sentinels, expiresAt)
if err != nil {
return nil, fmt.Errorf("%s: %w", k, err)
}
out[k] = sub
}
return out, nil
case []any:
out := make([]any, len(t))
for i, e := range t {
sub, err := substitutePlaceholders(e, sentinels, expiresAt)
if err != nil {
return nil, fmt.Errorf("[%d]: %w", i, err)
}
out[i] = sub
}
return out, nil
case string:
return substituteString(t, sentinels, expiresAt)
default:
return v, nil
}
}
func substituteString(s string, sentinels spec.Sentinels, expiresAt int64) (any, error) {
switch s {
case accessPlaceholder:
if sentinels.AccessToken == "" {
return nil, fmt.Errorf("no access-token sentinel is declared for this credential")
}
return sentinels.AccessToken, nil
case refreshPlaceholder:
if sentinels.RefreshToken == "" {
return nil, fmt.Errorf("no refresh-token sentinel is declared for this credential")
}
return sentinels.RefreshToken, nil
case expiresPlaceholder:
return expiresAt, nil
}
// A token sentinel may ride inside a larger string, e.g. "Bearer ...".
out := s
if strings.Contains(out, accessPlaceholder) {
if sentinels.AccessToken == "" {
return nil, fmt.Errorf("no access-token sentinel is declared for this credential")
}
out = strings.ReplaceAll(out, accessPlaceholder, sentinels.AccessToken)
}
if strings.Contains(out, refreshPlaceholder) {
if sentinels.RefreshToken == "" {
return nil, fmt.Errorf("no refresh-token sentinel is declared for this credential")
}
out = strings.ReplaceAll(out, refreshPlaceholder, sentinels.RefreshToken)
}
if at := firstPlaceholder(out); at != "" {
return nil, fmt.Errorf("placeholder %s is not rendered by archie", at)
}
return out, nil
}
// firstPlaceholder reports the first {{...}} occurrence in s, or "".
func firstPlaceholder(s string) string {
start := strings.Index(s, "{{")
if start < 0 {
return ""
}
end := strings.Index(s[start:], "}}")
if end < 0 {
return s[start:]
}
return s[start : start+end+2]
}
// encodeCredentialFile writes the substituted structure in the Kit's declared
// format: json unless it names toml.
func encodeCredentialFile(format string, structure any) (string, error) {
switch format {
case "", "json":
b, err := json.Marshal(structure)
if err != nil {
return "", err
}
return string(b), nil
case "toml":
var buf strings.Builder
if err := toml.NewEncoder(&buf).Encode(structure); err != nil {
return "", err
}
return buf.String(), nil
default:
return "", fmt.Errorf("unknown format %q", format)
}
}
@@ -0,0 +1,217 @@
package kit
import (
"encoding/json"
"strings"
"testing"
"time"
"github.com/BurntSushi/toml"
"github.com/docker/sandbox-kit-spec/v3/spec"
)
// oauthCredentialFileKit is a Kit declaring a proxy-managed OAuth credential
// whose harness reads its tokens from a credential file, as the published
// Claude Code Kit does (the spec's own example).
const oauthCredentialFileKit = sessions + `
- type: com.docker.sandbox/credential@1
config:
service: claude-code
phase: runtime
oauth:
tokenEndpoint: {host: platform.claude.com, path: /v1/oauth/token}
sentinels:
accessToken: sk-ant-oat01-proxy-managed
refreshToken: sk-ant-ort01-proxy-managed
credentialFile:
path: /home/agent/.claude/.credentials.json
structure:
claudeAiOauth:
accessToken: "{{.AccessToken}}"
refreshToken: "{{.RefreshToken}}"
expiresAt: "{{.ExpiresAt}}"`
func credentialFilePlan(t *testing.T) *Plan {
t.Helper()
p, err := Admit(descriptor(t, spec.KindWorkload, oauthCredentialFileKit))
if err != nil {
t.Fatalf("admit: %v", err)
}
return p
}
func findFile(files []spec.File, path string) (spec.File, bool) {
for _, f := range files {
if f.Path == path {
return f, true
}
}
return spec.File{}, false
}
// TestAssembleRendersTheOAuthCredentialFile is the sentinel rule: a bound
// OAuth credential whose Kit declares a credentialFile gets that file written
// at the declared path, holding the Kit's sentinels and never a real token.
func TestAssembleRendersTheOAuthCredentialFile(t *testing.T) {
l, err := Assemble(credentialFilePlan(t), image, LaunchParams{
Execution: "exec-42", ProxyToken: "tok", CAPath: "/etc/archie/ca.pem",
Bound: []string{"claude-code"},
})
if err != nil {
t.Fatal(err)
}
f, ok := findFile(l.Files, "/home/agent/.claude/.credentials.json")
if !ok {
t.Fatalf("no credential file at the declared path; files = %v", l.Files)
}
if f.Mode != "0600" {
t.Errorf("credential file mode = %q, want 0600", f.Mode)
}
if strings.Contains(f.Content, "{{") {
t.Errorf("credential file still holds a placeholder: %s", f.Content)
}
var doc struct {
ClaudeAiOauth struct {
AccessToken string `json:"accessToken"`
RefreshToken string `json:"refreshToken"`
ExpiresAt float64 `json:"expiresAt"`
} `json:"claudeAiOauth"`
}
if err := json.Unmarshal([]byte(f.Content), &doc); err != nil {
t.Fatalf("credential file is not JSON: %v\n%s", err, f.Content)
}
if doc.ClaudeAiOauth.AccessToken != "sk-ant-oat01-proxy-managed" {
t.Errorf("accessToken = %q, want the Kit's access-token sentinel", doc.ClaudeAiOauth.AccessToken)
}
if doc.ClaudeAiOauth.RefreshToken != "sk-ant-ort01-proxy-managed" {
t.Errorf("refreshToken = %q, want the Kit's refresh-token sentinel", doc.ClaudeAiOauth.RefreshToken)
}
if doc.ClaudeAiOauth.ExpiresAt != 0 {
t.Errorf("expiresAt = %v, want 0 with no stored token set", doc.ClaudeAiOauth.ExpiresAt)
}
}
// TestAssembleRendersTheStoredExpiry proves the credential file carries the
// stored token set's expiry -- the value the CLI checks before it decides to
// refresh -- and that it is a number, not a quoted placeholder.
func TestAssembleRendersTheStoredExpiry(t *testing.T) {
expires := time.UnixMilli(1700000000123)
l, err := Assemble(credentialFilePlan(t), image, LaunchParams{
Execution: "exec-42", ProxyToken: "tok", CAPath: "/etc/archie/ca.pem",
Bound: []string{"claude-code"}, OAuthExpiries: map[string]time.Time{"claude-code": expires},
})
if err != nil {
t.Fatal(err)
}
f, ok := findFile(l.Files, "/home/agent/.claude/.credentials.json")
if !ok {
t.Fatalf("no credential file at the declared path; files = %v", l.Files)
}
var doc struct {
ClaudeAiOauth struct {
ExpiresAt int64 `json:"expiresAt"`
} `json:"claudeAiOauth"`
}
if err := json.Unmarshal([]byte(f.Content), &doc); err != nil {
t.Fatalf("credential file is not JSON: %v\n%s", err, f.Content)
}
if doc.ClaudeAiOauth.ExpiresAt != expires.UnixMilli() {
t.Errorf("expiresAt = %d, want the stored expiry %d", doc.ClaudeAiOauth.ExpiresAt, expires.UnixMilli())
}
}
// TestAssembleRendersATOMLCredentialFile covers the non-default encoding the
// spec provides for agents that read TOML credentials files.
func TestAssembleRendersATOMLCredentialFile(t *testing.T) {
const tomlKit = sessions + `
- type: com.docker.sandbox/credential@1
config:
service: example
phase: runtime
oauth:
tokenEndpoint: {host: auth.example.com}
sentinels: {accessToken: sentinel-access, refreshToken: sentinel-refresh}
credentialFile:
path: /home/agent/credentials.toml
format: toml
structure:
api_url: "https://api.example.com"
tokens:
access_token: "{{.AccessToken}}"
refresh_token: "{{.RefreshToken}}"`
p, err := Admit(descriptor(t, spec.KindWorkload, tomlKit))
if err != nil {
t.Fatalf("admit: %v", err)
}
l, err := Assemble(p, image, LaunchParams{Execution: "exec-42", Bound: []string{"example"}})
if err != nil {
t.Fatal(err)
}
f, ok := findFile(l.Files, "/home/agent/credentials.toml")
if !ok {
t.Fatalf("no credential file at the declared path; files = %v", l.Files)
}
var doc struct {
APIURL string `toml:"api_url"`
Tokens struct {
AccessToken string `toml:"access_token"`
RefreshToken string `toml:"refresh_token"`
} `toml:"tokens"`
}
if _, err := toml.Decode(f.Content, &doc); err != nil {
t.Fatalf("credential file is not TOML: %v\n%s", err, f.Content)
}
if doc.Tokens.AccessToken != "sentinel-access" || doc.Tokens.RefreshToken != "sentinel-refresh" {
t.Errorf("tokens = %+v, want the sentinels", doc.Tokens)
}
}
// TestAssembleRefusesAPlaceholderItCannotRender: a placeholder archie does
// not supply must refuse the launch rather than leave the literal standing in
// the file, which the CLI would read as a credential.
func TestAssembleRefusesAPlaceholderItCannotRender(t *testing.T) {
const scopesKit = sessions + `
- type: com.docker.sandbox/credential@1
config:
service: example
phase: runtime
oauth:
tokenEndpoint: {host: auth.example.com}
sentinels: {accessToken: sentinel-access}
credentialFile:
path: /home/agent/credentials.json
structure:
scopes: "{{.Scopes}}"`
p, err := Admit(descriptor(t, spec.KindWorkload, scopesKit))
if err != nil {
t.Fatalf("admit: %v", err)
}
_, err = Assemble(p, image, LaunchParams{Execution: "exec-42", Bound: []string{"example"}})
if err == nil || !strings.Contains(err.Error(), "{{.Scopes}}") {
t.Fatalf("Assemble = %v, want a refusal naming {{.Scopes}}", err)
}
}
// TestAssembleRefusesAMissingSentinel: a token placeholder with no declared
// sentinel cannot be hidden, so the file must not be written at all.
func TestAssembleRefusesAMissingSentinel(t *testing.T) {
const noSentinelKit = sessions + `
- type: com.docker.sandbox/credential@1
config:
service: example
phase: runtime
oauth:
tokenEndpoint: {host: auth.example.com}
credentialFile:
path: /home/agent/credentials.json
structure:
access_token: "{{.AccessToken}}"`
p, err := Admit(descriptor(t, spec.KindWorkload, noSentinelKit))
if err != nil {
t.Fatalf("admit: %v", err)
}
_, err = Assemble(p, image, LaunchParams{Execution: "exec-42", Bound: []string{"example"}})
if err == nil || !strings.Contains(err.Error(), "access-token sentinel") {
t.Fatalf("Assemble = %v, want a refusal naming the missing access-token sentinel", err)
}
}
+30
View File
@@ -8,6 +8,7 @@ import (
"regexp"
"slices"
"strings"
"time"
"github.com/docker/sandbox-kit-spec/v3/spec"
@@ -51,6 +52,11 @@ type LaunchParams struct {
CAPath string
// Bound lists the credential services the run credential carries.
Bound []string
// OAuthExpiries is the stored token set's expiry for each bound OAuth
// credential whose Kit renders a credentialFile, keyed by service. It is
// the only fact about a token set the renderer receives: the tokens
// themselves never cross into kit, so a real token cannot be written.
OAuthExpiries map[string]time.Time
}
// Hook is one lifecycle hook, ready to exec in the container.
@@ -128,6 +134,11 @@ func Assemble(p *Plan, img ImageConfig, params LaunchParams) (Launch, error) {
}
l.Files = lifecycle.Files
}
credential, err := credentialFiles(creds, params.Bound, params.OAuthExpiries)
if err != nil {
return Launch{}, err
}
l.Files = append(l.Files, credential...)
for _, v := range volumes {
l.Volumes = append(l.Volumes, Volume{Name: volumeName(params.Execution, v.Path), Path: v.Path})
}
@@ -137,6 +148,25 @@ func Assemble(p *Plan, img ImageConfig, params LaunchParams) (Launch, error) {
return l, nil
}
// credentialFiles renders the credential file of every bound OAuth credential
// whose Kit declares one: the path and structure the Kit names, with the
// stored token set's expiry. A service the run credential does not carry
// produces no file.
func credentialFiles(creds []spec.CredentialCapability, bound []string, expiries map[string]time.Time) ([]spec.File, error) {
var files []spec.File
for _, c := range creds {
if c.OAuth == nil || c.OAuth.CredentialFile == nil || !slices.Contains(bound, c.Service) {
continue
}
content, err := renderCredentialFile(c, expiries[c.Service])
if err != nil {
return nil, err
}
files = append(files, spec.File{Path: c.OAuth.CredentialFile.Path, Content: content, Mode: credentialFileMode})
}
return files, nil
}
// contextFiles materializes agent-context@1: the workload's profile file
// beside the workspace, never in it, carrying an index of each Kit's body.
// A staged body is pointed at where the image holds it; an inline one is
@@ -0,0 +1,134 @@
package kitrun
import (
"context"
"errors"
"strings"
"testing"
"time"
"github.com/docker/sandbox-kit-spec/v3/spec"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/infrastructure/kit"
)
type fakeOAuthSecrets struct {
secret harnesssecret.Secret
err error
}
func (f fakeOAuthSecrets) GetHarnessSecret(context.Context, string, string) (harnesssecret.Secret, error) {
if f.err != nil {
return harnesssecret.Secret{}, f.err
}
return f.secret, nil
}
const credentialFileKit = `
schemaVersion: "3"
kind: workload
capabilities:
- type: com.docker.sandbox/agent-sessions@1
config: {prompt: [-p, "{{.Prompt}}"]}
- type: com.docker.sandbox/credential@1
config:
service: claude-code
phase: runtime
oauth:
tokenEndpoint: {host: platform.claude.com, path: /v1/oauth/token}
sentinels:
accessToken: sk-ant-oat01-proxy-managed
refreshToken: sk-ant-ort01-proxy-managed
credentialFile:
path: /home/agent/.claude/.credentials.json
structure:
claudeAiOauth:
accessToken: "{{.AccessToken}}"
refreshToken: "{{.RefreshToken}}"
expiresAt: "{{.ExpiresAt}}"
`
func credentialFilePlan(t *testing.T) *kit.Plan {
t.Helper()
d, err := spec.Decode([]byte(credentialFileKit))
if err != nil {
t.Fatalf("fixture does not decode: %v", err)
}
p, err := kit.Admit(d)
if err != nil {
t.Fatalf("admit: %v", err)
}
return p
}
func planCredentials(t *testing.T, p *kit.Plan) []spec.CredentialCapability {
t.Helper()
creds, err := spec.CredentialsOf(p.Capabilities)
if err != nil {
t.Fatalf("credentials of plan: %v", err)
}
return creds
}
// TestCredentialFileNeverCarriesARealToken is the sentinel rule end to end:
// the store holds real tokens, kitrun reads the set only for its expiry, and
// the assembled credential file holds the Kit's sentinels instead. The store's
// real values must not appear anywhere in the rendered file.
func TestCredentialFileNeverCarriesARealToken(t *testing.T) {
expires := time.UnixMilli(1700000000123)
l := &Launcher{OAuth: fakeOAuthSecrets{secret: harnesssecret.Secret{
Org: "acme", Service: "claude-code",
AccessToken: "real-access-token", RefreshToken: "real-refresh-token",
ExpiresAt: expires,
}}}
p := credentialFilePlan(t)
bound := []string{"claude-code"}
expiries, err := l.oauthExpiries(context.Background(), "acme", planCredentials(t, p), bound)
if err != nil {
t.Fatal(err)
}
if got := expiries["claude-code"]; got != expires {
t.Fatalf("oauthExpiries[claude-code] = %v, want the stored expiry %v", got, expires)
}
launch, err := kit.Assemble(p, kit.ImageConfig{User: "agent"}, kit.LaunchParams{
Execution: "exec-1", Bound: bound, OAuthExpiries: expiries,
})
if err != nil {
t.Fatal(err)
}
var content string
for _, f := range launch.Files {
if f.Path == "/home/agent/.claude/.credentials.json" {
content = f.Content
}
}
if content == "" {
t.Fatalf("no credential file rendered; files = %v", launch.Files)
}
if strings.Contains(content, "real-access-token") || strings.Contains(content, "real-refresh-token") {
t.Fatalf("credential file carries a real token: %s", content)
}
if !strings.Contains(content, "sk-ant-oat01-proxy-managed") || !strings.Contains(content, "sk-ant-ort01-proxy-managed") {
t.Fatalf("credential file does not hold the sentinels: %s", content)
}
}
// TestOAuthExpiriesFailsClosed: a Kit that renders a credential file cannot be
// launched without the stored token set its expiry comes from.
func TestOAuthExpiriesFailsClosed(t *testing.T) {
p := credentialFilePlan(t)
creds := planCredentials(t, p)
bound := []string{"claude-code"}
ctx := context.Background()
if _, err := (&Launcher{}).oauthExpiries(ctx, "acme", creds, bound); err == nil {
t.Fatal("oauthExpiries with no store = nil error, want a refusal")
}
l := &Launcher{OAuth: fakeOAuthSecrets{err: errors.New("no captured token")}}
if _, err := l.oauthExpiries(ctx, "acme", creds, bound); err == nil {
t.Fatal("oauthExpiries with no stored token = nil error, want a refusal")
}
}
+43 -1
View File
@@ -10,6 +10,7 @@ import (
"maps"
"slices"
"sync"
"time"
"github.com/docker/sandbox-kit-spec/v3/fetch"
"github.com/docker/sandbox-kit-spec/v3/spec"
@@ -17,6 +18,7 @@ import (
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/container"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/infrastructure/egress"
"github.com/samcharles93/archie-core/internal/infrastructure/kit"
"github.com/samcharles93/archie-core/internal/skill"
@@ -37,6 +39,15 @@ type Grants interface {
RevokeGrant(run string)
}
// OAuthSecrets reads an org's stored OAuth token set for a bound service, so a
// Kit's credential file can render that set's expiry. It is the store's read
// half only: kitrun never writes a token set, and nothing but the expiry
// leaves oauthExpiries, so a real token cannot reach the credential file
// (docs/prds/external-agent-harness.md, "Verification").
type OAuthSecrets interface {
GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error)
}
const (
agentPath = "/opt/archie/archie-agent"
caPath = "/opt/archie/ca.pem"
@@ -64,6 +75,11 @@ type Launcher struct {
Config *config.Holder
Secrets SecretResolver
Grants Grants
// OAuth reads the stored token set whose expiry a Kit's credential file
// renders. A nil OAuth refuses the launch of a Kit that renders one, the
// same way a nil OAuthStore makes the proxy refuse a required OAuth
// credential.
OAuth OAuthSecrets
mu sync.Mutex
started bool
@@ -125,6 +141,10 @@ func (l *Launcher) Launch(ctx context.Context, req Request) (*Run, error) {
return nil, err
}
granted, bound := l.resolveCredentials(req, k.creds)
expiries, err := l.oauthExpiries(ctx, req.Org, k.creds, bound)
if err != nil {
return nil, err
}
if l.Grants != nil {
l.Grants.Grant(req.Execution, granted)
}
@@ -136,7 +156,7 @@ func (l *Launcher) Launch(ctx context.Context, req Request) (*Run, error) {
return nil, err
}
run := &Run{network: "archie-kit-" + req.Execution, token: session.Token(), execution: req.Execution}
launch, err := kit.Assemble(k.plan, k.img, kit.LaunchParams{Execution: req.Execution, ProxyToken: session.Token(), CAPath: caPath, Bound: bound})
launch, err := kit.Assemble(k.plan, k.img, kit.LaunchParams{Execution: req.Execution, ProxyToken: session.Token(), CAPath: caPath, Bound: bound, OAuthExpiries: expiries})
if err != nil {
l.release(run)
return nil, err
@@ -214,6 +234,28 @@ func (l *Launcher) resolveCredentials(req Request, creds []spec.CredentialCapabi
return granted, bound
}
// oauthExpiries reads the stored token set's expiry for each bound OAuth
// credential whose Kit renders a credential file. The store is read only for a
// service the run credential carries, and only the expiry leaves here: the
// tokens stay behind, so the renderer has no way to write one.
func (l *Launcher) oauthExpiries(ctx context.Context, org string, creds []spec.CredentialCapability, bound []string) (map[string]time.Time, error) {
expiries := map[string]time.Time{}
for _, c := range creds {
if c.OAuth == nil || c.OAuth.CredentialFile == nil || !egress.IsOAuthManaged(c) || !slices.Contains(bound, c.Service) {
continue
}
if l.OAuth == nil {
return nil, fmt.Errorf("credential %q renders a credential file, but no harness secret store is configured", c.Service)
}
secret, err := l.OAuth.GetHarnessSecret(ctx, org, c.Service)
if err != nil {
return nil, fmt.Errorf("credential %q renders a credential file and has no captured OAuth token (run the setup terminal first): %w", c.Service, err)
}
expiries[c.Service] = secret.ExpiresAt
}
return expiries, nil
}
// release undoes what Launch already did for run: the egress grant, then the
// session. Call sites past this point pass the network/container errors
// through their own cleanup; release only ever needs to run once per Launch