package servicekit import ( "crypto/sha256" "fmt" "log/slog" "os" "strings" "github.com/samcharles93/archie-core/internal/config" "github.com/samcharles93/archie-core/internal/secret" ) func ResolveProviderSecrets(cfg *config.Config, registry *secret.Registry, log *slog.Logger) error { if err := resolveProviderMap("root", cfg.Providers, registry, log); err != nil { return err } return nil } // resolveProviderMap exports each provider's resolved api_key into a private // environment variable and rewrites the provider to reference that variable, so // a key never travels as config data. // // A credential that cannot be resolved disables that provider and is reported, // rather than failing the boot. configuration.md's startup policy is that a // missing credential disables a capability and only an invalid config stops the // daemon, and it names LLM keys as the case that must behave that way; the forge // path was fixed to degrade for the same reason (resolveForge). // // A reference naming only one of engine and key is a config error rather than a // missing credential, so that stays fatal. applyForgeDefaults only ever builds a // ref with both halves, so a half-named one can only come from a hand-edited // config. func resolveProviderMap(scope string, providers map[string]config.Provider, registry *secret.Registry, log *slog.Logger) error { for id, provider := range providers { switch { case provider.APIKey == (secret.SecretRef{}): continue case provider.APIKey.Engine == "" || provider.APIKey.Key == "": return fmt.Errorf("provider %q: api_key must name both an engine and a key, got {engine: %q, key: %q}", id, provider.APIKey.Engine, provider.APIKey.Key) } value, err := registry.Resolve(provider.APIKey) if err != nil { disableProvider(providers, id, provider, log, "api_key unavailable", err) continue } if value = strings.TrimSpace(value); value == "" { disableProvider(providers, id, provider, log, "api_key resolved empty", nil) continue } envName := providerSecretEnvName(scope, id) if err := os.Setenv(envName, value); err != nil { disableProvider(providers, id, provider, log, "api_key could not be exported", err) continue } provider.APIKey = secret.SecretRef{} provider.APIKeyEnv = envName providers[id] = provider } return nil } // disableProvider clears a provider's credential so every consumer sees it as // unconfigured, and says why. func disableProvider(providers map[string]config.Provider, id string, provider config.Provider, log *slog.Logger, reason string, cause error) { provider.APIKey = secret.SecretRef{} provider.APIKeyEnv = "" provider.Disabled = true providers[id] = provider if cause != nil { log.Warn("provider disabled: "+reason, "provider", id, "err", cause) return } log.Warn("provider disabled: "+reason, "provider", id) } func providerSecretEnvName(scope, providerID string) string { sum := sha256.Sum256([]byte(scope + "\x00" + providerID)) return fmt.Sprintf("ARCHIE_PROVIDER_%X_API_KEY", sum[:8]) } // ResolveProviders resolves cfg's provider credentials the way the daemon does // at boot, for a tool that calls models outside the daemon. Only the env engine // is available there: extension engines run inside the processes that supervise them. func ResolveProviders(cfg *config.Config, log *slog.Logger) error { return ResolveProviderSecrets(cfg, secret.NewRegistry(), log) }