docs/prds/external-agent-harness.md (Credentials) and orgs-and-access.md: egress.Resolver had no production implementation, and no run carried a credential naming the org secrets its identity is granted, so a Kit's required credential@1 was refused at the proxy and no harness run authenticated (archie-core-egkf.11). Two things, as scoped (this does not attempt #1026's full run-credential consolidation replacing WorktreeGrantIssuer/StateStoreGrantIssuer -- that PRD item is real, separate, and still open; this is deliberately narrower): 1. A run credential naming granted secrets: config.CredentialBinding maps a Kit credential@1 service to a secret; config.Config/IdentityConfig gain Org and GrantedCredentials (a per-identity allowlist of service names, reusing the existing per-identity config-override pattern DiffCapLines already uses, not a new Cedar/Authorizer integration -- KindSecret policy objects exist in internal/domain/access but assembling a full Principal is #1026's job, not a two-line addition here). config.ContainerConfig. BoundCredentials computes the declared (Kit) ∩ granted (identity) ∩ org-matched intersection Sam's own rule requires: neither side widens the other, proven by a mutation-checked test flipping each of the three independently. 2. egress.GrantResolver: the production Resolver, holding only what a caller explicitly Grant-ed one run, replaced wholesale (not merged) on a repeated Grant, gone entirely on RevokeGrant. kitrun.Launcher.Launch computes the intersection per launch and resolves real values through the existing secret registry (SecretResolver), Grants it before the proxy session opens, and Release/error-path rollback (a new shared Launcher.release) always revokes it. Course-corrected mid-implementation (flagged by Sam): credential bindings first landed as a boot-time config.ContainerConfig.Credentials field captured once into Launcher.Bindings -- exactly the "parses but is not a resource" trap CLAUDE.md warns about, and inconsistent with agent-profiles (#1207) making a Kit profile apply without a restart. Rebuilt as its own live control-plane resource, CredentialBindingsKind ("credential-bindings"), following the agent-profiles/container-runtime-policies split precisely: config.ContainerConfig.Credentials is json:"-", [containers].credentials is only its seed, and kitrun.Launcher now holds *config.Holder (not a captured slice) and reads Containers.Credentials fresh on every Launch. Org/GrantedCredentials were already read fresh per dispatch (d.configFor inside runKitTask, never cached), so no equivalent fix was needed there. Deliberately not built: identities and grants as their own State Store resource (orgs-and-access.md's "Org owns ... identities and their grants"). Identities are entirely config.toml-defined today with no control-plane resource at all; moving GrantedCredentials alone into one would put half an identity in two places. That migration is identities' own scope, not credential bindings'.
280 lines
12 KiB
Go
280 lines
12 KiB
Go
package controlplane
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
|
|
)
|
|
|
|
// resourceReader is the one read the layering performs: a resource kind's value
|
|
// and the version it came from, or nothing at all when the store holds no value
|
|
// for that kind. The gRPC client and the in-process server both provide it, so
|
|
// "what the database covers in the running config" has exactly one
|
|
// implementation. The offline validate runs the same code as boot, which is the
|
|
// only way its verdict can be boot's verdict.
|
|
//
|
|
// found is false only for the reader that dials a live State Store: a kind with
|
|
// no stored value leaves the file document's value in effect instead of failing
|
|
// the process, which is the state a seed ImportConfig refused leaves behind
|
|
// (controlplane.Server.ImportConfig skips it) and the state of a database the
|
|
// migration has not reached yet. storeReader never reports absent -- it answers
|
|
// with the seed the State Store would write -- so the offline verdict stays
|
|
// boot's.
|
|
|
|
// RuntimeConfig applies restart-scoped database resources over bootstrap
|
|
// configuration. Values intentionally absent from a control-plane projection,
|
|
// such as secret-bearing MCP headers and channel update commands, remain
|
|
// bootstrap-owned.
|
|
//
|
|
// It also returns the version of each kind it read, so the process that
|
|
// layers them in can report which version it is running
|
|
// (docs/prds/control-plane-apply-status.md).
|
|
func (c *Client) RuntimeConfig(ctx context.Context, base config.Config) (config.Config, map[string]int64, error) {
|
|
return runtimeConfigFrom(ctx, c, base)
|
|
}
|
|
|
|
// RuntimeChatConfig layers the stored channel settings over the file document's
|
|
// chat section.
|
|
|
|
// StoredRuntimeConfig is RuntimeConfig's layering over the store this server
|
|
// owns, for a caller holding the database file rather than a connection to it.
|
|
// Boot layers the stored settings onto the file config and then runs
|
|
// configuration.Validate, so an offline check of that database has to make the
|
|
// same first move with the same implementation; called with the config the
|
|
// daemon would load, the result is the document boot decides on.
|
|
//
|
|
// A kind the store does not hold is read as the seed the State Store would
|
|
// write for it from base (see storeReader.query), because that store seeds
|
|
// every kind before it serves.
|
|
func (s *Server) StoredRuntimeConfig(ctx context.Context, base config.Config) (config.Config, map[string]int64, error) {
|
|
seeds, err := s.seededValues(base)
|
|
if err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
return runtimeConfigFrom(ctx, storeReader{resources: s.store, seeds: seeds}, base)
|
|
}
|
|
|
|
// storeReader reads the server's own store. It mirrors what the gRPC read
|
|
// answers -- a kind that is stored is the value and version it holds -- with
|
|
// one difference: a kind the store does not hold yet is the value the State
|
|
// Store seeds for it, since the daemon dials a store that has already run
|
|
// ImportConfig over the same config.
|
|
type storeReader struct {
|
|
resources ResourceStore
|
|
seeds map[string][]byte
|
|
}
|
|
|
|
func (r storeReader) Query(ctx context.Context, kind string, decode func([]byte) error) (int64, bool, error) {
|
|
resource, err := r.resources.Resource(ctx, kind)
|
|
if errors.Is(err, storecontract.ErrResourceNotFound) {
|
|
seed, ok := r.seeds[kind]
|
|
if !ok {
|
|
return 0, false, fmt.Errorf("read %s: %w", kind, storecontract.ErrResourceNotFound)
|
|
}
|
|
if err := decode(seed); err != nil {
|
|
return 0, false, fmt.Errorf("decode %s seed: %w", kind, err)
|
|
}
|
|
// No version: nothing has been stored for this kind, so nothing has
|
|
// been applied either. It is still a value to layer in -- the seed --
|
|
// which is why this reader never reports the kind absent.
|
|
return 0, true, nil
|
|
}
|
|
if err != nil {
|
|
return 0, false, fmt.Errorf("read %s: %w", kind, err)
|
|
}
|
|
if err := decode(resource.Value); err != nil {
|
|
return 0, false, fmt.Errorf("decode %s: %w", kind, err)
|
|
}
|
|
return resource.Version, true, nil
|
|
}
|
|
|
|
func runtimeConfigFrom(ctx context.Context, reader controlplanerpc.ResourceReader, base config.Config) (config.Config, map[string]int64, error) {
|
|
out := base.Clone()
|
|
versions := map[string]int64{}
|
|
if err := layerResource(ctx, reader, versions, ProviderSettingsKind, func(value []byte) error {
|
|
var providers map[string]providerDocument
|
|
if err := json.Unmarshal(value, &providers); err != nil {
|
|
return err
|
|
}
|
|
out.Providers = make(map[string]config.Provider, len(providers))
|
|
for name, provider := range providers {
|
|
if err := rejectBootDerivedProviderEnv(name, provider); err != nil {
|
|
return err
|
|
}
|
|
out.Providers[name] = config.Provider{Class: provider.Class, APIKeyEnv: provider.APIKeyEnv, APIKey: provider.APIKey, BaseURL: provider.BaseURL}
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
// The stored role assignments own cfg.Models once the store carries a
|
|
// value, the way the provider layer above owns cfg.Providers: a role
|
|
// removed from the store is gone from the layered document too. The
|
|
// runtime-resource watches re-layer over an already-layered base
|
|
// (archie-core-zfb0.1), so json.Unmarshal's map merge here would
|
|
// resurrect a role the store deleted every time any watched kind changed.
|
|
if err := layerResource(ctx, reader, versions, ModelRoleAssignmentsKind, func(value []byte) error {
|
|
var roles map[string]string
|
|
if err := json.Unmarshal(value, &roles); err != nil {
|
|
return err
|
|
}
|
|
out.Models = roles
|
|
return nil
|
|
}); err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
if err := layerResourceJSON(ctx, reader, versions, RepositoryPoliciesKind, &out.Repos); err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
chat, chatVersion, err := controlplanerpc.RuntimeChatConfigFrom(ctx, reader, out.Chat)
|
|
if err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
out.Chat, versions[ChannelSettingsKind] = chat, chatVersion
|
|
if err := layerResource(ctx, reader, versions, SchedulingPolicyKind, func(value []byte) error {
|
|
var policy schedulingPolicy
|
|
if err := json.Unmarshal(value, &policy); err != nil {
|
|
return err
|
|
}
|
|
interval, err := time.ParseDuration(policy.PollInterval)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
out.PollInterval, out.MaxRetries, out.Dispatch = config.Duration(interval), policy.MaxRetries, policy.Dispatch
|
|
// The label pairs with the trigger and layers with it: once the store
|
|
// carries one, it owns it, and the file can no longer drop the label a
|
|
// stored label-requiring trigger depends on. A policy stored before
|
|
// the field existed -- the nil the seed never produces -- leaves the
|
|
// file document's label in force, and boot's gate judges the pairing
|
|
// either way.
|
|
if policy.Label != nil {
|
|
out.Label = *policy.Label
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
return runtimeToolConfigFrom(ctx, reader, versions, out)
|
|
}
|
|
|
|
func runtimeToolConfigFrom(ctx context.Context, reader controlplanerpc.ResourceReader, versions map[string]int64, out config.Config) (config.Config, map[string]int64, error) {
|
|
if err := layerResource(ctx, reader, versions, ToolSettingsKind, func(value []byte) error {
|
|
var settings toolSettings
|
|
if err := json.Unmarshal(value, &settings); err != nil {
|
|
return err
|
|
}
|
|
headers := make(map[string]map[string]string, len(out.Tools.MCPServers))
|
|
for _, server := range out.Tools.MCPServers {
|
|
headers[server.Name] = server.Headers
|
|
}
|
|
servers := make([]config.MCPServer, 0, len(settings.MCPServers))
|
|
for _, server := range settings.MCPServers {
|
|
servers = append(servers, config.MCPServer{
|
|
Name: server.Name,
|
|
Transport: server.Transport,
|
|
Command: server.Command,
|
|
Args: server.Args,
|
|
WorkDir: server.WorkDir,
|
|
URL: server.URL,
|
|
Headers: headers[server.Name],
|
|
SSEEndpoint: server.SSEEndpoint,
|
|
MessageEndpoint: server.MessageEndpoint,
|
|
ParallelToolCalls: server.ParallelToolCalls,
|
|
})
|
|
}
|
|
out.Tools = config.ToolsConfig{MCPServers: servers, Policy: settings.Policy, WebFetch: settings.WebFetch, Minimax: config.MinimaxConfig{Enabled: settings.Minimax.Enabled, APIKey: settings.Minimax.APIKey, BaseURL: settings.Minimax.BaseURL}}
|
|
return nil
|
|
}); err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
if err := layerResource(ctx, reader, versions, PluginSettingsKind, func(value []byte) error {
|
|
var settings pluginSettings
|
|
if err := json.Unmarshal(value, &settings); err != nil {
|
|
return err
|
|
}
|
|
out.PluginDir, out.ModuleDir, out.SecretEngineDir, out.SkillsDir = settings.PluginDir, settings.ModuleDir, settings.SecretEngineDir, settings.SkillsDir
|
|
return nil
|
|
}); err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
if err := layerResource(ctx, reader, versions, ContainerRuntimePoliciesKind, func(value []byte) error {
|
|
var policies containerRuntimePolicies
|
|
if err := json.Unmarshal(value, &policies); err != nil {
|
|
return err
|
|
}
|
|
// Profiles survives this assignment untouched: containerRuntimePolicies
|
|
// carries no Profiles field at all (it is AgentProfileKind's document
|
|
// now), and settings() never sets it, so whatever the AgentProfileKind
|
|
// layering step below assigns is what's left standing regardless of
|
|
// which of the two runs first.
|
|
profiles := out.Containers.Profiles
|
|
out.Containers = policies.settings()
|
|
out.Containers.Profiles = profiles
|
|
return nil
|
|
}); err != nil {
|
|
return config.Config{}, nil, err
|
|
}
|
|
// AgentProfileKind is a separate resource from ContainerRuntimePoliciesKind
|
|
// (config.ContainerConfig.Profiles is json:"-") so a Kit profile applies
|
|
// without a restart: a stored value replaces the file's outright rather
|
|
// than merging into it, the same reason ModelRoleAssignmentsKind above
|
|
// reassigns out.Models wholesale instead of decoding into the existing map.
|
|
if err := layerResource(ctx, reader, versions, AgentProfileKind, func(value []byte) error {
|
|
var profiles map[string]agentProfile
|
|
if err := json.Unmarshal(value, &profiles); err != nil {
|
|
return err
|
|
}
|
|
out.Containers.Profiles = agentProfilesSettings(profiles)
|
|
return nil
|
|
}); 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
|
|
}
|
|
|
|
// layerResource decodes a resource and records the version it came from, so the
|
|
// layering ends up holding the version of every kind it applied.
|
|
//
|
|
// A kind with no stored value is not an error and records no version: the file
|
|
// document's value stays in effect. That is the state a seed the resource
|
|
// validator refused leaves behind (controlplane.Server.ImportConfig skips it),
|
|
// and failing here instead would stop the process with a database-named error
|
|
// that editing config.toml cannot clear.
|
|
func layerResource(ctx context.Context, reader controlplanerpc.ResourceReader, versions map[string]int64, kind string, decode func([]byte) error) error {
|
|
version, found, err := reader.Query(ctx, kind, decode)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if found {
|
|
versions[kind] = version
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func layerResourceJSON(ctx context.Context, reader controlplanerpc.ResourceReader, versions map[string]int64, kind string, target any) error {
|
|
return layerResource(ctx, reader, versions, kind, func(value []byte) error { return json.Unmarshal(value, target) })
|
|
}
|
|
|
|
// query returns the version of the resource it decoded, so callers that layer
|
|
// a resource in can report the version they applied. A kind the store holds no
|
|
// value for is reported as not found rather than as an error: the caller leaves
|
|
// the file document's value in effect (see resourceReader).
|