Merge crew/claude-997: egress credential resolver backed by declared-and-granted run credentials

This commit is contained in:
sam committed 2026-09-27 06:19:07 +10:00
commit 09fa8e2e86
18 files changed
+752 -25

No files matched your search

@@ -176,6 +176,8 @@ looking at before reporting one:
| `pull_policy` | Default `missing` when enabled. Pool code recognises `missing` and `always`; other strings silently skip pre-pull. |
| `network` | Empty uses best-effort self-network detection. Repository overlay pins `archie-core_default`. |
| `profiles` | Named agent execution environments (image or Kit); resolved per task dispatch (`ContainerConfig.Profile`). Own control-plane resource `agent-profiles` (`json:"-"` on the field so `container-runtime-policies` never carries it), `ApplyMode: live` -- a profile change applies without a restart, unlike the rest of `[containers]`. |
| `credentials` | Maps a Kit `credential@1` service to a secret (`config.CredentialBinding`). Own control-plane resource `credential-bindings`, `ApplyMode: live`, `json:"-"` on the field. `kitrun.Launcher` reads it fresh from the live `config.Holder` on every `Launch`, never a value captured at boot -- see `internal/infrastructure/kitrun/launcher.go`'s `resolveCredentials`. A binding alone grants nothing; see `org`/`granted_credentials` below. |
| `org` / `granted_credentials` (root and per-identity) | An identity's org and the `credentials` service names it may resolve. `daemon.runKitTask` reads both fresh per dispatch (`d.configFor(task)`) and passes them to `kitrun.Request`; `config.ContainerConfig.BoundCredentials` computes the declared (Kit) ∩ granted (identity) ∩ org-matched intersection -- neither declared nor granted widens the other. |
### Channel settings
+14
View File
@@ -34,6 +34,8 @@ label = "archie"
bot_user = "vectis-labs-archie"
# 0 switches the cap off; omit the key to take the built-in default (400).
diff_cap_lines = 400
# org = "acme" # empty means the default org (a single-operator install's one identity)
# granted_credentials = ["openai"] # credential@1 services the root identity may resolve (see [containers.credentials])
# how many operator-triggered retries a parked task gets
# before it moves to dead (global default; set per-repo to
@@ -75,6 +77,8 @@ token = { engine = "env", key = "ARCHIE_GITHUB_TOKEN" }
# name = "personal" # required; namespaces logs/events/NATS subjects
# bot_user = "your-bot" # required
# forge = { type = "github", host = "https://github.com", token = { engine = "env", key = "ARCHIE_GITHUB_TOKEN_PERSONAL" } }
# org = "acme" # empty inherits the shared org (empty = default)
# granted_credentials = ["openai"] # credential@1 services this identity may resolve (see [containers.credentials])
[dispatch]
# Can be of "assignee", "label", or "either"
@@ -450,6 +454,16 @@ target = "127.0.0.1:9090" # REQUIRED. The State Store gRPC address arch
# [containers.profiles.claude]
# kit = ["docker/claude-code-kit@sha256:<digest>"]
# adapter = "claude-code" # claude-code, codex, pi, omp or copilot; empty runs without capture tools or usage
#
# Credential bindings map a Kit's credential@1 service name to a secret. A
# binding alone grants nothing -- an identity resolves it only when its own
# org matches and the service is in its granted_credentials (see
# [[identities]] above). Once the State Store holds it, edit bindings in the
# dashboard (Settings, Advanced); a stored set replaces the file's.
# [[containers.credentials]]
# service = "openai"
# org = "acme" # empty means the default org
# secret = {engine = "env", key = "OPENAI_API_KEY"}
# At least one [[repos]] entry is required before archied will poll
# anything -- it is deliberately left commented rather than shipped active:
+6 -3
View File
@@ -59,9 +59,11 @@ func (b *boot) setupKitLauncher(ctx context.Context) {
log.Warn("kit harness runs disabled: egress relay", "err", err)
return
}
// No credential resolver yet (archie-core-egkf.11): a Kit's required
// credential is refused at the proxy until run credentials carry secrets.
proxy := egress.NewProxy(ca, egress.ProxyOptions{})
// grants is the production Resolver: Launch/Release Grant/RevokeGrant it
// per run with exactly the declared-and-granted intersection
// (docs/prds/external-agent-harness.md, Credentials; archie-core-egkf.11).
grants := egress.NewGrantResolver()
proxy := egress.NewProxy(ca, egress.ProxyOptions{Resolver: grants})
srv := &http.Server{Handler: proxy, ReadHeaderTimeout: 30 * time.Second}
go func() {
if err := srv.Serve(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {
@@ -76,6 +78,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,
}
log.Info("kit harness runs enabled", "proxy", ln.Addr().String())
}
+5 -2
View File
@@ -152,7 +152,10 @@ var reloadableFields = map[string]bool{
// Containers.Profile, called from pinTaskProfile) and is also its own
// live-applying control-plane resource (AgentProfileKind), never captured at
// container-pool construction -- docs/prds/external-agent-harness.md
// "Selection": a Kit profile applies without a restart. Everything else in
// "Selection": a Kit profile applies without a restart. Credentials is the
// same shape one layer down: kitrun.Launcher reads Config.Get().Containers.
// Credentials fresh on every Launch (CredentialBindingsKind), never a slice
// captured once when the launcher was built. Everything else in
// Containers (Image, MaxConcurrency, MaxUptime, PullPolicy, Network) is
// frozen in the startup-built container pool -- the dispatchers re-read
// MaxConcurrency but the pool captures it at construction
@@ -161,7 +164,7 @@ var reloadableFields = map[string]bool{
// (display/link building only); the forge client itself is startup-built, so
// Type/Token/TokenEnv stay requires-restart.
var reloadableSubFields = map[string]map[string]bool{
"Containers": {"VolumeTTL": true, "Profiles": true},
"Containers": {"VolumeTTL": true, "Profiles": true, "Credentials": true},
"Forge": {"Host": true},
// Policy is carried into TaskConfig by ForTask (config.go); MCPServers,
// WebFetch and Minimax are not and stay requires-restart.
@@ -0,0 +1,78 @@
package controlplane
import "github.com/samcharles93/archie-core/internal/config"
// CredentialBindingsKind is the control-plane resource mapping a Kit
// credential@1 service name to an org secret
// (docs/prds/external-agent-harness.md, Credentials; docs/prds/orgs-and-access.md).
// It exists so a binding applies without a restart, the same reason
// AgentProfileKind is its own resource: [containers].credentials in
// config.toml is only its seed, and kitrun.Launcher reads the live
// control-plane document on every launch, never a value captured at boot.
const CredentialBindingsKind = "credential-bindings"
// credentialBinding is one config.CredentialBinding as the document writes
// it: explicit snake_case json tags, following channel_settings.go /
// container_settings.go's precedent, never the internal config struct
// (which has no json tags and would fall back to Go field names).
type credentialBinding struct {
Service string `json:"service"`
Org string `json:"org,omitempty"`
Secret credentialValue `json:"secret"`
}
// credentialValue is config.SecretRef as this document writes it.
type credentialValue struct {
Engine string `json:"engine,omitempty"`
Key string `json:"key,omitempty"`
}
func credentialBindingsDefinition() Definition {
return Definition{
Kind: CredentialBindingsKind,
Title: "Credential bindings",
ApplyMode: "live",
Document: []credentialBinding{},
Seed: seedCredentialBindings,
Validate: validateCredentialBindings,
}
}
func seedCredentialBindings(cfg config.Config) any {
return credentialBindingsDocument(cfg.Containers.Credentials)
}
func credentialBindingsDocument(bindings []config.CredentialBinding) []credentialBinding {
if bindings == nil {
return nil
}
out := make([]credentialBinding, len(bindings))
for i, b := range bindings {
out[i] = credentialBinding{Service: b.Service, Org: b.Org, Secret: credentialValue{Engine: b.Secret.Engine, Key: b.Secret.Key}}
}
return out
}
// credentialBindingsSettings reverses credentialBindingsDocument, for the
// layering in runtime_config.go and for validation against
// config.ContainerConfig.ValidateCredentialBindings.
func credentialBindingsSettings(bindings []credentialBinding) []config.CredentialBinding {
if bindings == nil {
return nil
}
out := make([]config.CredentialBinding, len(bindings))
for i, b := range bindings {
out[i] = config.CredentialBinding{Service: b.Service, Org: b.Org, Secret: config.SecretRef{Engine: b.Secret.Engine, Key: b.Secret.Key}}
}
return out
}
func validateCredentialBindings(input []byte) error {
// The rules live in the config package and are shared with the file
// document's own validation (config.ContainerConfig.ValidateCredentialBindings):
// which bindings are valid cannot differ between the file that seeds this
// resource and the resource that replaces it.
return validateAs(input, func(bindings []credentialBinding) error {
return config.ContainerConfig{Credentials: credentialBindingsSettings(bindings)}.ValidateCredentialBindings()
})
}
+1 -1
View File
@@ -8,7 +8,7 @@ import (
// Schemas are not declared here: each Definition names its document type, and
// Definition.Descriptor derives the JSON Schema from it (internal/app/controlplane/schema.go).
func builtinDefinitions(steps workflow.StepRegistry) []Definition {
definitions := []Definition{workflowDefinition(), workflowDefinitionsDefinition(steps), personaDefinition(), scheduleDefinition(), agentProfileDefinition()}
definitions := []Definition{workflowDefinition(), workflowDefinitionsDefinition(steps), personaDefinition(), scheduleDefinition(), agentProfileDefinition(), credentialBindingsDefinition()}
definitions = append(definitions, modelDefinitions()...)
definitions = append(definitions, operationalDefinitions()...)
return definitions
@@ -235,6 +235,18 @@ func runtimeToolConfigFrom(ctx context.Context, reader controlplanerpc.ResourceR
}); err != nil {
return config.Config{}, nil, err
}
// CredentialBindingsKind is likewise its own resource: a binding applies
// without a restart, and a stored value replaces the file's outright.
if err := layerResource(ctx, reader, versions, CredentialBindingsKind, func(value []byte) error {
var bindings []credentialBinding
if err := json.Unmarshal(value, &bindings); err != nil {
return err
}
out.Containers.Credentials = credentialBindingsSettings(bindings)
return nil
}); err != nil {
return config.Config{}, nil, err
}
return out, versions, nil
}
@@ -60,6 +60,7 @@ func TestRuntimeConfigUsesDatabaseResourcesAndPreservesBootstrapOnlySecrets(t *t
PluginSettingsKind: map[string]any{"plugin_dir": "/plugins", "module_dir": "/modules", "secret_engine_dir": "/secrets", "skills_dir": "/skills"},
ContainerRuntimePoliciesKind: map[string]any{"image": "archie:next", "pull_policy": "missing"},
AgentProfileKind: map[string]any{"net": map[string]any{"tools": []string{"whois"}}},
CredentialBindingsKind: []map[string]any{{"service": "openai", "org": "acme", "secret": map[string]any{"engine": "env", "key": "OPENAI_KEY"}}},
}})
got, versions, err := client.RuntimeConfig(t.Context(), base)
@@ -70,7 +71,7 @@ func TestRuntimeConfigUsesDatabaseResourcesAndPreservesBootstrapOnlySecrets(t *t
// publishes is the one it actually layered in (archie-core-pskb).
for _, kind := range []string{
ProviderSettingsKind, ModelRoleAssignmentsKind, RepositoryPoliciesKind, ChannelSettingsKind,
SchedulingPolicyKind, ToolSettingsKind, PluginSettingsKind, ContainerRuntimePoliciesKind, AgentProfileKind,
SchedulingPolicyKind, ToolSettingsKind, PluginSettingsKind, ContainerRuntimePoliciesKind, AgentProfileKind, CredentialBindingsKind,
} {
if versions[kind] != 2 {
t.Errorf("versions[%s] = %d, want the 2 the store answered with", kind, versions[kind])
@@ -552,7 +553,7 @@ func TestRuntimeResourceKindsApplyLive(t *testing.T) {
modes[definition.Kind] = definition.ApplyMode
}
for _, kind := range []string{
ProviderSettingsKind, ModelRoleAssignmentsKind, RepositoryPoliciesKind, SchedulingPolicyKind, AgentProfileKind,
ProviderSettingsKind, ModelRoleAssignmentsKind, RepositoryPoliciesKind, SchedulingPolicyKind, AgentProfileKind, CredentialBindingsKind,
} {
if modes[kind] != "live" {
t.Errorf("%s applies %q, want live: the daemon re-layers this kind on a watch", kind, modes[kind])
@@ -658,3 +659,42 @@ func TestRuntimeConfigLayersStoredProfiles(t *testing.T) {
t.Fatalf("layering mutated the file document's profiles: %v", got)
}
}
// A stored CredentialBindingsKind value replaces the file's bindings
// outright; no stored value at all leaves the file's in effect (the same
// shape TestRuntimeConfigLayersStoredProfiles pins for AgentProfileKind, for
// the same reason: a binding applies without a restart).
func TestRuntimeConfigLayersStoredCredentialBindings(t *testing.T) {
base := config.Config{Containers: config.ContainerConfig{Image: "agent:1", Credentials: []config.CredentialBinding{
{Service: "file-only", Org: "acme"},
}}}
t.Run("a stored value replaces the file's", func(t *testing.T) {
client := NewRPCClient(&runtimeConfigClient{values: map[string]any{
SchedulingPolicyKind: map[string]any{"poll_interval": "2m", "dispatch": map[string]any{"trigger": "assignee"}},
ContainerRuntimePoliciesKind: map[string]any{"image": "agent:2"},
CredentialBindingsKind: []map[string]any{{"service": "openai", "org": "acme", "secret": map[string]any{"engine": "env", "key": "OPENAI_KEY"}}},
}})
got, _, err := client.RuntimeConfig(t.Context(), base)
if err != nil {
t.Fatalf("RuntimeConfig: %v", err)
}
if len(got.Containers.Credentials) != 1 || got.Containers.Credentials[0].Service != "openai" || got.Containers.Credentials[0].Secret.Key != "OPENAI_KEY" {
t.Fatalf("credentials = %+v, want the stored binding", got.Containers.Credentials)
}
})
t.Run("no stored value inherits the file's", func(t *testing.T) {
got, _, err := runtimeConfigFrom(t.Context(), absentReader{}, base)
if err != nil {
t.Fatalf("runtimeConfigFrom: %v", err)
}
if len(got.Containers.Credentials) != 1 || got.Containers.Credentials[0].Service != "file-only" {
t.Fatalf("credentials = %+v, want the file's binding", got.Containers.Credentials)
}
})
if got := base.Containers.Credentials; len(got) != 1 {
t.Fatalf("layering mutated the file document's credentials: %v", got)
}
}
@@ -122,6 +122,17 @@ func TestResourceValidatorsRejectWhatEffectiveValidationRejects(t *testing.T) {
},
wantErr: true,
},
{
name: "credential binding with an empty service name",
kind: CredentialBindingsKind,
value: []credentialBinding{
{Service: "", Org: "acme"},
},
mutate: func(cfg *config.Config) {
cfg.Containers.Credentials = []config.CredentialBinding{{Service: "", Org: "acme"}}
},
wantErr: true,
},
{
name: "container runtime policies without an image",
kind: ContainerRuntimePoliciesKind,
+94
View File
@@ -458,6 +458,20 @@ type Config struct {
// Label marks issues archie should pick up.
Label string `toml:"label" yaml:"label"`
BotUser string `toml:"bot_user" yaml:"bot_user"`
// Org is this identity's org (docs/prds/orgs-and-access.md). Empty means
// "default": the org a single-operator install's one identity belongs to.
// A credential binding whose Org does not match a run's identity never
// resolves for it, regardless of what the identity is granted.
Org string `toml:"org" yaml:"org"`
// GrantedCredentials names the credential@1 services this identity may
// use, by CredentialBinding.Service (docs/prds/external-agent-harness.md,
// Organisations: "a harness run ... acts as the workflow's identity").
// Empty grants none -- a binding existing is not a grant, the same
// fail-closed default the proxy itself already applies to an unbound
// required credential. Declared (what a Kit's descriptor asks for) and
// granted (this list) are two separate facts; only their intersection
// resolves, and neither widens the other.
GrantedCredentials []string `toml:"granted_credentials" yaml:"granted_credentials"`
// BotEmail is the git author email; defaults to the GitHub noreply
// address for BotUser.
BotEmail string `toml:"bot_email" yaml:"bot_email"`
@@ -547,6 +561,13 @@ type IdentityConfig struct {
// BotEmail is the git author email. Falls back to a forge-appropriate
// default from BotUser when empty.
BotEmail string `toml:"bot_email" yaml:"bot_email"`
// Org overrides the shared Org for this identity. Empty inherits it.
Org string `toml:"org" yaml:"org"`
// GrantedCredentials overrides the shared GrantedCredentials for this
// identity. Nil (absent) inherits it; a present, empty list grants none
// -- the same explicit-empty-means-off shape DiffCapLines uses, needed
// because a plain nil already means "not set" here.
GrantedCredentials *[]string `toml:"granted_credentials" yaml:"granted_credentials"`
// DiffCapLines overrides the shared cap for this identity. Nil (absent)
// inherits it; an explicit 0 switches the cap off for this identity only.
DiffCapLines *int `toml:"diff_cap_lines" yaml:"diff_cap_lines"`
@@ -851,6 +872,79 @@ type ContainerConfig struct {
// AgentProfileKind, seeded from this field but validated and stored
// (and reloaded live) separately -- see internal/app/controlplane.
Profiles map[string]AgentProfile `toml:"profiles" yaml:"profiles" json:"-"`
// Credentials binds a Kit's credential@1 service names to org secrets
// (docs/prds/external-agent-harness.md, Credentials). A binding names
// where the value comes from; it is not itself a grant -- an identity
// resolves a bound service only when its own Org matches and the service
// is in its GrantedCredentials.
// Credentials is excluded from the control-plane JSON document
// (container-runtime-policies): it is its own resource, CredentialBindingsKind,
// seeded from this field but validated and stored (and reloaded live)
// separately -- see internal/app/controlplane.
Credentials []CredentialBinding `toml:"credentials" yaml:"credentials" json:"-"`
}
// CredentialBinding maps one Kit credential@1 service name to an org secret.
// It carries no secret value itself, only where to resolve one from: the
// existing secret registry (env/file), not yet the encrypted org-secret
// store docs/prds/binding-secret-encryption.md describes -- that store is
// separate, still-open work this does not attempt.
type CredentialBinding struct {
// Service names the credential@1 service a Kit's descriptor declares
// (docker/sandbox-kit-spec spec.CredentialCapability.Service).
Service string `toml:"service" yaml:"service"`
// Org is the org this binding belongs to. Empty means the default org.
// A run whose identity's Org does not match never resolves this binding,
// however it is granted (docs/prds/orgs-and-access.md: "No record is
// shared between orgs").
Org string `toml:"org" yaml:"org"`
// Secret is where the real value is resolved from.
Secret SecretRef `toml:"secret" yaml:"secret"`
}
// BoundCredentials returns the credential bindings one run may actually use:
// every declared service (what a Kit's descriptor asks for) that is also
// granted (the run's identity's GrantedCredentials) and belongs to org (the
// run's identity's Org). This is the whole enforcement of "authority is an
// intersection": declared and granted are two independent facts, neither
// widens the other, and only a service present in all three -- org, granted,
// declared -- resolves. A service missing from any one is simply absent from
// the result; the caller (the egress resolver) treats that as unbound.
func (c ContainerConfig) BoundCredentials(org string, granted, declared []string) map[string]CredentialBinding {
grantedSet := make(map[string]bool, len(granted))
for _, g := range granted {
grantedSet[g] = true
}
declaredSet := make(map[string]bool, len(declared))
for _, d := range declared {
declaredSet[d] = true
}
out := make(map[string]CredentialBinding)
for _, b := range c.Credentials {
if b.Org != org || !grantedSet[b.Service] || !declaredSet[b.Service] {
continue
}
out[b.Service] = b
}
return out
}
// ValidateCredentialBindings rejects a binding with an empty service name or
// duplicated (service, org) pair: two bindings resolving the same Kit
// credential in the same org is ambiguous, not a fallback chain.
func (c ContainerConfig) ValidateCredentialBindings() error {
seen := make(map[string]bool, len(c.Credentials))
for _, b := range c.Credentials {
if strings.TrimSpace(b.Service) == "" {
return fmt.Errorf("containers.credentials: a service name must not be empty")
}
key := b.Org + "\x00" + b.Service
if seen[key] {
return fmt.Errorf("containers.credentials: service %q is bound more than once for org %q", b.Service, b.Org)
}
seen[key] = true
}
return nil
}
// AgentProfile is a named execution environment for an agent. Secrets and
+115
View File
@@ -0,0 +1,115 @@
package config
import (
"strings"
"testing"
)
// TestBoundCredentialsIsAnIntersection is the mutation-checked isolation
// proof docs/prds/external-agent-harness.md and orgs-and-access.md require:
// declared (what a Kit's descriptor asks for) and granted (an identity's
// GrantedCredentials) are independent facts, and a binding's Org is a third.
// Flip any single one of the three and the service must fall out of the
// result -- never partially, never because another passed.
func TestBoundCredentialsIsAnIntersection(t *testing.T) {
c := ContainerConfig{Credentials: []CredentialBinding{
{Service: "openai", Org: "acme", Secret: SecretRef{Engine: "env", Key: "OPENAI_KEY"}},
{Service: "other-org-svc", Org: "other", Secret: SecretRef{Engine: "env", Key: "X"}},
}}
tests := []struct {
name string
org string
granted []string
declared []string
want []string
}{
{
name: "org, granted and declared all agree", org: "acme",
granted: []string{"openai"}, declared: []string{"openai"},
want: []string{"openai"},
},
{
name: "declared but not granted resolves nothing", org: "acme",
granted: nil, declared: []string{"openai"},
want: nil,
},
{
name: "granted but not declared resolves nothing", org: "acme",
granted: []string{"openai"}, declared: nil,
want: nil,
},
{
name: "granted and declared but the wrong org resolves nothing", org: "not-acme",
granted: []string{"openai"}, declared: []string{"openai"},
want: nil,
},
{
name: "a service bound to a different org is never returned regardless of grants", org: "acme",
granted: []string{"other-org-svc"}, declared: []string{"other-org-svc"},
want: nil,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := c.BoundCredentials(tt.org, tt.granted, tt.declared)
var names []string
for name := range got {
names = append(names, name)
}
if len(names) != len(tt.want) {
t.Fatalf("BoundCredentials() = %v, want %v", names, tt.want)
}
for _, want := range tt.want {
if _, ok := got[want]; !ok {
t.Fatalf("BoundCredentials() = %v, want it to carry %q", names, want)
}
}
})
}
}
func TestValidateCredentialBindings(t *testing.T) {
tests := []struct {
name string
c ContainerConfig
wantErr string
}{
{name: "no bindings", c: ContainerConfig{}},
{name: "one binding", c: ContainerConfig{Credentials: []CredentialBinding{{Service: "openai", Org: "acme"}}}},
{
name: "empty service name",
c: ContainerConfig{Credentials: []CredentialBinding{{Service: "", Org: "acme"}}},
wantErr: "service name must not be empty",
},
{
name: "duplicate service in the same org",
c: ContainerConfig{Credentials: []CredentialBinding{
{Service: "openai", Org: "acme"},
{Service: "openai", Org: "acme"},
}},
wantErr: "bound more than once",
},
{
name: "same service, different orgs is not a duplicate",
c: ContainerConfig{Credentials: []CredentialBinding{
{Service: "openai", Org: "acme"},
{Service: "openai", Org: "other"},
}},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := tt.c.ValidateCredentialBindings()
if tt.wantErr == "" {
if err != nil {
t.Fatalf("ValidateCredentialBindings() = %v, want nil", err)
}
return
}
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
t.Fatalf("ValidateCredentialBindings() = %v, want containing %q", err, tt.wantErr)
}
})
}
}
+6
View File
@@ -2089,6 +2089,12 @@ func configForIdentity(root config.Config, identity config.IdentityConfig) confi
if identity.DiffCapLines != nil {
root.DiffCapLines = identity.DiffCapLines
}
if identity.Org != "" {
root.Org = identity.Org
}
if identity.GrantedCredentials != nil {
root.GrantedCredentials = *identity.GrantedCredentials
}
root.Forge = identity.Forge
root.Dispatch = identity.Dispatch
root.Models = identity.Models
+13 -6
View File
@@ -61,13 +61,20 @@ func (d *Daemon) runKitTask(ctx context.Context, task *workflow.Task, repo confi
park("kit workflow interface", err)
return
}
// Org and GrantedServices are the dispatching identity's own facts, read
// fresh here rather than cached anywhere: the same per-task
// config.Config d.configFor already resolves for every other identity
// override (Forge, Budgets, ...).
taskCfg := d.configFor(task)
run, err := d.KitLauncher.Launch(ctx, kitrun.Request{
Execution: fmt.Sprintf("task-%d", task.ID),
Kit: profile.Kit,
Adapter: profile.Adapter,
WorkDir: workDir,
WorkerEnv: env,
GateRetries: iface.Needs.GateRetries,
Execution: fmt.Sprintf("task-%d", task.ID),
Kit: profile.Kit,
Adapter: profile.Adapter,
WorkDir: workDir,
WorkerEnv: env,
GateRetries: iface.Needs.GateRetries,
Org: taskCfg.Org,
GrantedServices: taskCfg.GrantedCredentials,
})
if err != nil {
park("kit launch failed", err)
@@ -486,6 +486,9 @@ func validateContainers(cfg *config.Config) error {
if err := cfg.Containers.ValidateProfiles(); err != nil {
return fmt.Errorf("%w: %w", ErrInvalidInput, err)
}
if err := cfg.Containers.ValidateCredentialBindings(); err != nil {
return fmt.Errorf("%w: %w", ErrInvalidInput, err)
}
return nil
}
+59
View File
@@ -0,0 +1,59 @@
package egress
import (
"context"
"sync"
)
// GrantResolver is the production Resolver: it holds, per active run, only
// the secrets a caller explicitly Grant-ed it -- the intersection a run
// credential carries (docs/prds/external-agent-harness.md, Credentials;
// docs/prds/orgs-and-access.md, "Agents: decided once, carried as a run
// credential"). It never derives a secret from anything else, so a service
// nobody granted, or granted to a different run, always answers ErrUnbound.
type GrantResolver struct {
mu sync.RWMutex
grants map[string]map[string]string
}
// NewGrantResolver returns an empty resolver: no run may resolve anything
// until Grant is called for it.
func NewGrantResolver() *GrantResolver {
return &GrantResolver{grants: map[string]map[string]string{}}
}
// Grant records exactly what one run may resolve, replacing whatever it held
// before -- a repeated Grant for the same run (a retry, or a narrower set)
// never merges with the last, since a service the caller dropped must not
// keep resolving from a stale entry.
func (g *GrantResolver) Grant(run string, secrets map[string]string) {
g.mu.Lock()
defer g.mu.Unlock()
g.grants[run] = secrets
}
// RevokeGrant ends a run: nothing it was granted resolves after this call.
func (g *GrantResolver) RevokeGrant(run string) {
g.mu.Lock()
defer g.mu.Unlock()
delete(g.grants, run)
}
// Resolve implements Resolver. A run with no Grant, or a service not among
// what it was granted, answers ErrUnbound -- the only error ambiguous enough
// for an optional credential to pass over (see Resolver's doc).
func (g *GrantResolver) Resolve(_ context.Context, run, service string) (string, error) {
g.mu.RLock()
defer g.mu.RUnlock()
secrets, ok := g.grants[run]
if !ok {
return "", ErrUnbound
}
v, ok := secrets[service]
if !ok {
return "", ErrUnbound
}
return v, nil
}
var _ Resolver = (*GrantResolver)(nil)
@@ -0,0 +1,72 @@
package egress
import "testing"
// TestGrantResolverOnlyResolvesWhatWasGranted is the mutation-checked
// isolation proof: a service never granted for a run, a service granted only
// to a different run, and a service already revoked must all answer
// ErrUnbound -- there is no path from "asked" to "returned" that does not go
// through an explicit Grant.
func TestGrantResolverOnlyResolvesWhatWasGranted(t *testing.T) {
g := NewGrantResolver()
g.Grant("run-a", map[string]string{"openai": "sk-a"})
g.Grant("run-b", map[string]string{"anthropic": "sk-b"})
tests := []struct {
name string
run string
service string
want string
wantErr bool
}{
{name: "a granted service resolves", run: "run-a", service: "openai", want: "sk-a"},
{name: "a service granted to a different run never resolves here", run: "run-a", service: "anthropic", wantErr: true},
{name: "a service never granted to any run", run: "run-a", service: "unknown", wantErr: true},
{name: "an unknown run resolves nothing", run: "run-c", service: "openai", wantErr: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := g.Resolve(t.Context(), tt.run, tt.service)
if tt.wantErr {
if err == nil {
t.Fatalf("Resolve(%q, %q) = (%q, nil), want ErrUnbound", tt.run, tt.service, got)
}
return
}
if err != nil || got != tt.want {
t.Fatalf("Resolve(%q, %q) = (%q, %v), want (%q, nil)", tt.run, tt.service, got, err, tt.want)
}
})
}
}
func TestGrantResolverRevokeRemovesEveryGrantForTheRun(t *testing.T) {
g := NewGrantResolver()
g.Grant("run-a", map[string]string{"openai": "sk-a", "anthropic": "sk-b"})
g.RevokeGrant("run-a")
if _, err := g.Resolve(t.Context(), "run-a", "openai"); err == nil {
t.Fatal("Resolve after RevokeGrant returned a value, want ErrUnbound")
}
if _, err := g.Resolve(t.Context(), "run-a", "anthropic"); err == nil {
t.Fatal("Resolve after RevokeGrant returned a value, want ErrUnbound")
}
}
// TestGrantResolverGrantReplacesNotMerges: a run re-granted with a narrower
// set (a Kit that stopped declaring a service it once did, or a retry
// dispatched after a grant changed) must lose the dropped service, not keep
// it from the previous Grant call.
func TestGrantResolverGrantReplacesNotMerges(t *testing.T) {
g := NewGrantResolver()
g.Grant("run-a", map[string]string{"openai": "sk-a", "anthropic": "sk-b"})
g.Grant("run-a", map[string]string{"openai": "sk-a2"})
got, err := g.Resolve(t.Context(), "run-a", "openai")
if err != nil || got != "sk-a2" {
t.Fatalf("Resolve(openai) = (%q, %v), want (sk-a2, nil)", got, err)
}
if _, err := g.Resolve(t.Context(), "run-a", "anthropic"); err == nil {
t.Fatal("anthropic still resolves after a narrower Grant replaced it, want ErrUnbound")
}
}
+101 -11
View File
@@ -15,11 +15,27 @@ import (
"github.com/docker/sandbox-kit-spec/v3/spec"
"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/infrastructure/egress"
"github.com/samcharles93/archie-core/internal/infrastructure/kit"
)
// SecretResolver resolves a credential binding's secret value. *secret.Registry
// satisfies it; the interface stays narrow so kitrun does not need the whole
// secret engine surface, and a test can fake it with no engine at all.
type SecretResolver interface {
Resolve(config.SecretRef) (string, error)
}
// Grants is what Launch and Release tell the egress proxy's resolver about a
// run's credentials: exactly the intersection Launch computed, and nothing
// once the run ends. *egress.GrantResolver satisfies it.
type Grants interface {
Grant(run string, secrets map[string]string)
RevokeGrant(run string)
}
const (
agentPath = "/opt/archie/archie-agent"
caPath = "/opt/archie/ca.pem"
@@ -35,6 +51,18 @@ type Launcher struct {
// Kit container: the worker's own binary and the egress CA.
AgentBinary string
CAFile string
// Config is read fresh on every Launch, never captured once at
// construction: credential bindings are their own live control-plane
// resource (controlplane.CredentialBindingsKind), so a binding added or
// changed after this daemon started must take effect on the very next
// dispatch, the same way an agent profile already does
// (docs/prds/external-agent-harness.md, "Selection": applies without a
// restart). A nil Secrets or Grants degrades every credential to unbound
// rather than panicking: a daemon with no Kit profile configured wires
// neither.
Config *config.Holder
Secrets SecretResolver
Grants Grants
mu sync.Mutex
started bool
@@ -55,6 +83,15 @@ type Request struct {
// a positive one, and Launch refuses it rather than starting a
// container no gate failure could ever resume.
GateRetries int
// Org and GrantedServices are the dispatching identity's own facts
// (config.Config.Org, config.Config.GrantedCredentials), carried here
// because kitrun holds no store or config of its own. Launch resolves a
// Kit credential only where these agree with a configured
// CredentialBinding and the Kit's own declared service -- the
// declared-and-granted intersection docs/prds/external-agent-harness.md
// and orgs-and-access.md both require; neither side widens the other.
Org string
GrantedServices []string
}
// Run is a started Kit task.
@@ -63,9 +100,10 @@ type Run struct {
Harness agentexec.HarnessSpec
// Volumes outlive the run; remove them with RemoveVolumes once the
// execution has ended.
Volumes []kit.Volume
network string
token string
Volumes []kit.Volume
network string
token string
execution string
}
// Launch composes the request's Kits and starts its container.
@@ -95,20 +133,27 @@ func (l *Launcher) Launch(ctx context.Context, req Request) (*Run, error) {
if err != nil {
return nil, err
}
granted, bound := l.resolveCredentials(req, creds)
if l.Grants != nil {
l.Grants.Grant(req.Execution, granted)
}
session, err := l.Proxy.Register(egress.SessionOptions{Run: req.Execution, Network: network, Credentials: creds})
if err != nil {
if l.Grants != nil {
l.Grants.RevokeGrant(req.Execution)
}
return nil, err
}
run := &Run{network: "archie-kit-" + req.Execution, token: session.Token()}
launch, err := kit.Assemble(plan, img, kit.LaunchParams{Execution: req.Execution, ProxyToken: session.Token(), CAPath: caPath})
run := &Run{network: "archie-kit-" + req.Execution, token: session.Token(), execution: req.Execution}
launch, err := kit.Assemble(plan, img, kit.LaunchParams{Execution: req.Execution, ProxyToken: session.Token(), CAPath: caPath, Bound: bound})
if err != nil {
l.Proxy.Revoke(run.token)
l.release(run)
return nil, err
}
launch.Harness.Adapter, launch.Harness.MCPConfig = req.Adapter, adapter.MCPConfig
run.Harness, run.Volumes = launch.Harness, launch.Volumes
if err := l.Networks.Create(ctx, run.network); err != nil {
l.Proxy.Revoke(run.token)
l.release(run)
return nil, err
}
run.Container, err = l.Pool.AcquireKit(ctx, container.KitSpec{
@@ -126,12 +171,57 @@ func (l *Launcher) Launch(ctx context.Context, req Request) (*Run, error) {
InstallDone: session.EnterRuntime,
})
if err != nil {
l.Proxy.Revoke(run.token)
l.release(run)
return nil, errors.Join(err, l.Networks.Remove(context.WithoutCancel(ctx), run.network))
}
return run, nil
}
// resolveCredentials computes the run's granted secrets -- the intersection
// of what the Kit composition declares, what config.CredentialBinding
// entries exist, and what the dispatching identity is granted and belongs
// to -- and resolves each to a real value. granted is the run/service ->
// value map for Grants.Grant; bound is the service-name list kit.Assemble
// renders sentinel-mode env vars from. A service failing any part of the
// intersection, or whose binding's secret does not resolve, is simply
// absent from both: it stays unbound, exactly as if credential@1 named a
// service nobody configured.
func (l *Launcher) resolveCredentials(req Request, creds []spec.CredentialCapability) (granted map[string]string, bound []string) {
granted = map[string]string{}
if l.Secrets == nil || l.Config == nil {
return granted, bound
}
current := l.Config.Get().Containers.Credentials
if len(current) == 0 {
return granted, bound
}
declared := make([]string, len(creds))
for i, c := range creds {
declared[i] = c.Service
}
bindings := config.ContainerConfig{Credentials: current}.BoundCredentials(req.Org, req.GrantedServices, declared)
for service, binding := range bindings {
value, err := l.Secrets.Resolve(binding.Secret)
if err != nil {
continue
}
granted[service] = value
bound = append(bound, service)
}
return granted, bound
}
// 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
// failure, so it takes no error to join.
func (l *Launcher) release(run *Run) {
if l.Grants != nil {
l.Grants.RevokeGrant(run.execution)
}
l.Proxy.Revoke(run.token)
}
// compose assembles the profile's Kits and reads the workload image's
// config, the first Kit being the workload.
func (l *Launcher) compose(ctx context.Context, refs []string) (*kit.Plan, kit.ImageConfig, error) {
@@ -157,11 +247,11 @@ func (l *Launcher) compose(ctx context.Context, refs []string) (*kit.Plan, kit.I
return plan, img, nil
}
// Release stops the run's container, then removes its network and ends
// its egress session.
// Release stops the run's container, then removes its network, revokes its
// credential grant and ends its egress session.
func (l *Launcher) Release(ctx context.Context, run *Run) error {
l.Pool.Release(ctx, run.Container)
l.Proxy.Revoke(run.token)
l.release(run)
return l.Networks.Remove(context.WithoutCancel(ctx), run.network)
}
@@ -0,0 +1,118 @@
package kitrun
import (
"errors"
"testing"
"github.com/docker/sandbox-kit-spec/v3/spec"
"github.com/samcharles93/archie-core/internal/config"
)
var errSecretNotConfigured = errors.New("secret not configured")
type fakeSecretResolver map[config.SecretRef]string
func (f fakeSecretResolver) Resolve(ref config.SecretRef) (string, error) {
v, ok := f[ref]
if !ok {
return "", errSecretNotConfigured
}
return v, nil
}
func declaredCred(service string) spec.CredentialCapability {
return spec.CredentialCapability{Service: service}
}
// TestResolveCredentialsReadsTheLiveConfig is the "reads current, not a boot
// snapshot" requirement: two calls against the same Launcher, differing only
// in what l.Config now holds, must produce different results. A Launcher
// that captured Bindings once at construction (the reverted design) cannot
// pass this.
func TestResolveCredentialsReadsTheLiveConfig(t *testing.T) {
ref := config.SecretRef{Engine: "env", Key: "OPENAI_KEY"}
l := &Launcher{
Config: config.NewHolder(config.Config{}),
Secrets: fakeSecretResolver{ref: "sk-live"},
}
req := Request{Org: "acme", GrantedServices: []string{"openai"}}
creds := []spec.CredentialCapability{declaredCred("openai")}
granted, bound := l.resolveCredentials(req, creds)
if len(granted) != 0 || len(bound) != 0 {
t.Fatalf("resolveCredentials with no configured binding = (%v, %v), want both empty", granted, bound)
}
l.Config.Set(config.Config{Containers: config.ContainerConfig{
Credentials: []config.CredentialBinding{{Service: "openai", Org: "acme", Secret: ref}},
}})
granted, bound = l.resolveCredentials(req, creds)
if granted["openai"] != "sk-live" || len(bound) != 1 || bound[0] != "openai" {
t.Fatalf("resolveCredentials after the binding was added = (%v, %v), want openai granted", granted, bound)
}
}
// TestResolveCredentialsIsAnIntersection is the isolation proof at the
// Launcher boundary: a secret the identity is not granted, or a binding from
// another org, is never in the resolved set, however the Kit declares it.
func TestResolveCredentialsIsAnIntersection(t *testing.T) {
openaiRef := config.SecretRef{Engine: "env", Key: "OPENAI_KEY"}
otherRef := config.SecretRef{Engine: "env", Key: "OTHER_KEY"}
l := &Launcher{
Config: config.NewHolder(config.Config{Containers: config.ContainerConfig{
Credentials: []config.CredentialBinding{
{Service: "openai", Org: "acme", Secret: openaiRef},
{Service: "other-org-svc", Org: "other-org", Secret: otherRef},
},
}}),
Secrets: fakeSecretResolver{openaiRef: "sk-acme", otherRef: "sk-other"},
}
tests := []struct {
name string
req Request
creds []spec.CredentialCapability
want map[string]string
mutated bool
}{
{
name: "declared, granted, matching org resolves",
req: Request{Org: "acme", GrantedServices: []string{"openai"}},
creds: []spec.CredentialCapability{declaredCred("openai")},
want: map[string]string{"openai": "sk-acme"},
},
{
name: "not granted never resolves even though declared and the org matches",
req: Request{Org: "acme", GrantedServices: nil},
creds: []spec.CredentialCapability{declaredCred("openai")},
want: map[string]string{},
},
{
name: "a binding from another org never resolves even when granted",
req: Request{Org: "acme", GrantedServices: []string{"other-org-svc"}},
creds: []spec.CredentialCapability{declaredCred("other-org-svc")},
want: map[string]string{},
},
{
name: "not declared by the Kit never resolves even though granted",
req: Request{Org: "acme", GrantedServices: []string{"openai"}},
creds: nil,
want: map[string]string{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
granted, _ := l.resolveCredentials(tt.req, tt.creds)
if len(granted) != len(tt.want) {
t.Fatalf("resolveCredentials() = %v, want %v", granted, tt.want)
}
for service, value := range tt.want {
if granted[service] != value {
t.Fatalf("resolveCredentials()[%q] = %q, want %q", service, granted[service], value)
}
}
})
}
}