Files
archie/internal/infrastructure/configuration/defaults.go
T
sam c1cd5c8f5b chore(state-store): remove the one-time SQLite import and db_path
Every install serves from Postgres, so the legacyread/legacyimport packages,
the archie-state-store import command, the boot gate that refused to serve
over unimported SQLite files, and db_path (which only located those files)
go. Migration 0010 drops the import_completion table.
2026-09-25 00:40:48 +10:00

367 lines
13 KiB
Go

package configuration
import (
"os"
"path/filepath"
"strings"
"time"
"github.com/samcharles93/archie-core/internal/config"
)
// Defaults applied to absent input. Named so a reader can find the value
// without reading the code that applies it.
const (
defaultPollInterval = 60 * time.Second
defaultDiffCapLines = 400
defaultWebListen = "127.0.0.1:8484" // "off" disables
defaultMaxRetries = 3
defaultForgeType = "github"
defaultForgeHost = "https://github.com"
defaultDispatchTrigger = "assignee"
defaultAckReaction = "eyes"
defaultContainerUptime = 60 * time.Minute
defaultVolumeTTL = 72 * time.Hour
defaultPullPolicy = "missing"
defaultContainerImage = "ghcr.io/samcharles93/archie-agent:latest"
// defaultMaxResultChars bounds one tool result. It matches the 50KB the
// lifted workspace tools already truncate themselves at
// (tools/builtin.DefaultMaxBytes), so those stay the binding limit and
// only tools with no truncation of their own -- skill bodies, MCP
// results -- see a change.
defaultMaxResultChars = 50_000
defaultWebFetchTimeout = 30 * time.Second
// defaultWebFetchMaxBytes bounds a fetched body before the result limit
// above trims it further. Generous enough for a documentation page,
// small enough that a large download cannot occupy the daemon.
defaultWebFetchMaxBytes = 2_000_000
// Capture defaults, per docs/prds/event-capture-storage.md's disk-bound
// mechanics: retention + row cap + per-request size cap + per-source
// rate limit, composed.
defaultCaptureRetention = 7 * 24 * time.Hour
defaultCaptureMaxEvents = 5000
defaultCaptureMaxBodyBytes = 256 * 1024
defaultCaptureRatePerSecond = 1.0
defaultCaptureRateBurst = 5
// defaultHealthListen is the daemon's own liveness address. The update
// watchdog's fallback in scripts/archie-update-watchdog must match it.
defaultHealthListen = "127.0.0.1:8485"
// defaultHealthDependencyTimeout matches the extracted services'
// -dependency-timeout default, so every process bounds a probe into a
// dependency the same way out of the box.
defaultHealthDependencyTimeout = 5 * time.Second
)
// applyDefaults fills in every absent value. It never reports an error and
// never rejects input.
//
// Defaulting and validation were previously interleaved: functions named
// applyXDefaults also returned validation errors, and functions named
// validateX quietly mutated the config. That made it impossible to answer
// "what did the operator actually set?" -- the only way to see the supplied
// input was to not call them. Splitting them means defaults can be applied,
// inspected, and reasoned about independently of whether the result is valid.
func (l *Loader) applyDefaults(cfg *config.Config) {
applyServiceDefaults(cfg)
if cfg.Health.Listen == "" {
cfg.Health.Listen = defaultHealthListen
}
if cfg.Health.DependencyTimeout == 0 {
cfg.Health.DependencyTimeout = config.Duration(defaultHealthDependencyTimeout)
}
l.applyGeneralDefaults(cfg)
applyForgeDefaults(cfg)
applyArtifactsDefaults(cfg)
applyDispatchDefaults(cfg)
applyIdentityDefaults(cfg)
applyContainerDefaults(cfg)
applyToolPolicyDefaults(cfg)
applyCaptureDefaults(cfg)
applyNATSDefaults(cfg)
applyMemoryDefaults(cfg)
}
// applyServiceDefaults fills each registered service's absent addresses from
// its registration. It iterates the registry rather than naming services, so a
// new service needs no branch here -- only its RegisterService call.
//
// A registered service always ends with an entry, so later code can read
// cfg.Services.Get(name) without distinguishing "absent section" from
// "section with every field defaulted". An empty registered Target is a
// service whose target the operator must supply, and stays empty for
// validation to reject rather than being defaulted to something dialable.
func applyServiceDefaults(cfg *config.Config) {
if cfg.Services == nil {
cfg.Services = config.Services{}
}
for _, spec := range config.RegisteredServices() {
conn := cfg.Services[spec.Name]
if conn.Target == "" {
conn.Target = spec.Target
}
if conn.Listen == "" {
conn.Listen = spec.Listen
}
cfg.Services[spec.Name] = conn
}
}
// applyMemoryDefaults fills an absent engine choice with the builtin
// engine, so "nothing configured" and "explicitly builtin" are the same
// resolved state everywhere after this point -- validateMemory and every
// later reader see one value, not two that happen to mean the same thing.
func applyMemoryDefaults(cfg *config.Config) {
if cfg.Memory.Engine == "" {
cfg.Memory.Engine = memoryEngineBuiltin
}
}
// DefaultCapture returns the webhook capture endpoint's default settings
// (docs/prds/event-capture-storage.md). applyCaptureDefaults fills a decoded
// config with them; the UI process composes the same capture receiver and
// must produce the same effective values when it is driven by flags alone
// and no configuration file projected [capture] to it.
func DefaultCapture() config.CaptureConfig {
return config.CaptureConfig{
Retention: config.Duration(defaultCaptureRetention),
MaxEvents: defaultCaptureMaxEvents,
MaxBodyBytes: defaultCaptureMaxBodyBytes,
RatePerSecond: defaultCaptureRatePerSecond,
RateBurst: defaultCaptureRateBurst,
}
}
// applyCaptureDefaults fills the webhook capture endpoint's settings. See
// [config.CaptureConfig].
func applyCaptureDefaults(cfg *config.Config) {
c := DefaultCapture()
if cfg.Capture.Retention == 0 {
cfg.Capture.Retention = c.Retention
}
if cfg.Capture.MaxEvents == 0 {
cfg.Capture.MaxEvents = c.MaxEvents
}
if cfg.Capture.MaxBodyBytes == 0 {
cfg.Capture.MaxBodyBytes = c.MaxBodyBytes
}
if cfg.Capture.RatePerSecond == 0 {
cfg.Capture.RatePerSecond = c.RatePerSecond
}
if cfg.Capture.RateBurst == 0 {
cfg.Capture.RateBurst = c.RateBurst
}
}
// applyToolPolicyDefaults fills the tool result limits.
//
// Zero means "unset" and takes the default; a negative value is the operator
// saying "no limit" and is left alone. See [config.ToolPolicy].
func applyToolPolicyDefaults(cfg *config.Config) {
if cfg.Tools.Policy.MaxResultChars == 0 {
cfg.Tools.Policy.MaxResultChars = defaultMaxResultChars
}
// SpillDir is deliberately NOT defaulted.
//
// Spilling hands the model a file path to read back, and the read tool is
// confined to chat.workspace. A default under work_dir is outside that for
// any workspace narrower than the whole home directory, and always outside
// a task agent's worktree -- so the model would be given a path it cannot
// open and the result would be lost rather than displaced. Truncating
// inline at least shows the first part of the result and says so.
//
// An operator who wants spilling points this at a directory inside the
// workspace; startup warns when it is not (see cmd/archied).
applyWebFetchDefaults(cfg)
}
// applyWebFetchDefaults fills the fetch tool's settings. Enabled is left alone
// when the operator set it either way; see [config.WebFetchConfig].
func applyWebFetchDefaults(cfg *config.Config) {
if cfg.Tools.WebFetch.Timeout == 0 {
cfg.Tools.WebFetch.Timeout = config.Duration(defaultWebFetchTimeout)
}
if cfg.Tools.WebFetch.MaxBytes == 0 {
cfg.Tools.WebFetch.MaxBytes = defaultWebFetchMaxBytes
}
}
// DefaultWorkDir returns the work directory an unset work_dir would have been
// given. Callers that must fall back when a configured path turns out to be
// unusable use this so the fallback is the same location the operator would
// have got by saying nothing, rather than a second guess that only this
// caller knows about.
func DefaultWorkDir() string {
return filepath.Join(xdgDataHome(), "archie", "work")
}
// DefaultConfigDir returns the directory archie's configuration lives in:
// $XDG_CONFIG_HOME/archie, or ~/.config/archie. It is the base every
// config-home-derived path is built on. It is not the -config source
// directory, which is whichever file or directory the operator names.
func DefaultConfigDir() string {
return filepath.Join(xdgConfigHome(), "archie")
}
// DefaultConfigPath returns the configuration file an archie binary reads when
// -config is not given. Every binary that asks a question about a deployment
// has to read this path to be answering about the same deployment, so the rule
// lives here once and the binaries take it from here. Deriving it a second way
// is what went wrong before: os.UserConfigDir is a plausible-looking source for
// the same value that disagrees with this one on darwin and for a relative
// $XDG_CONFIG_HOME.
func DefaultConfigPath() string {
return filepath.Join(DefaultConfigDir(), "config.toml")
}
// applyGeneralDefaults derives the paths and limits that have no owning
// section.
func (l *Loader) applyGeneralDefaults(cfg *config.Config) {
cfg.SecretEngineDir = expandHomePath(cfg.SecretEngineDir)
cfg.WorkDir = expandHomePath(cfg.WorkDir)
cfg.StateDir = expandHomePath(cfg.StateDir)
cfg.Chat.Workspace = expandHomePath(cfg.Chat.Workspace)
// DatabaseURL has no default and is not path-expanded: it is a connection
// URL, not a file path. Empty means "not configured", which the State
// Store refuses at boot (fail closed) rather than a value this loader can
// invent -- a wrong default would point a production store at a database
// that does not exist.
if cfg.WorkDir == "" {
cfg.WorkDir = filepath.Join(l.dataHome(), "archie", "work")
}
if cfg.StateDir == "" {
cfg.StateDir = filepath.Join(l.dataHome(), "archie")
}
if cfg.PollInterval == 0 {
cfg.PollInterval = config.Duration(defaultPollInterval)
}
// Only an absent key takes the default. An explicit 0 is the documented
// way to switch the cap off and must survive.
if cfg.DiffCapLines == nil {
capLines := defaultDiffCapLines
cfg.DiffCapLines = &capLines
}
if cfg.Web.Listen == "" {
cfg.Web.Listen = defaultWebListen
}
if cfg.MaxRetries == 0 {
cfg.MaxRetries = defaultMaxRetries
}
}
func expandHomePath(path string) string {
if path != "~" && !strings.HasPrefix(path, "~/") {
return path
}
home, err := os.UserHomeDir()
if err != nil {
return path
}
if path == "~" {
return home
}
return filepath.Join(home, strings.TrimPrefix(path, "~/"))
}
// applyForgeDefaults fills the forge section, promoting the legacy
// token_env field to a secret reference when no explicit one was given.
func applyForgeDefaults(cfg *config.Config) {
if cfg.Forge.Type == "" {
cfg.Forge.Type = defaultForgeType
}
if cfg.Forge.Host == "" {
cfg.Forge.Host = defaultForgeHost
}
if cfg.Forge.Intake == "" {
cfg.Forge.Intake = config.ForgeIntakePoll
}
}
// applyArtifactsDefaults reads the artifacts token from WORKSPACE_INGEST_TOKEN
// when no secret reference is given.
func applyArtifactsDefaults(cfg *config.Config) {
if cfg.Artifacts.Token == (config.SecretRef{}) {
cfg.Artifacts.Token = config.SecretRef{Engine: "env", Key: "WORKSPACE_INGEST_TOKEN"}
}
}
// applyNATSDefaults resolves the nats mode from URL when the operator left it
// unset. URL set implies external; URL empty implies embedded.
func applyNATSDefaults(cfg *config.Config) {
if cfg.NATS.Mode == "" {
if cfg.NATS.URL != "" {
cfg.NATS.Mode = config.NATSModeExternal
} else {
cfg.NATS.Mode = config.NATSModeEmbedded
}
}
}
// applyDispatchDefaults fills the dispatch section. "off" is the documented
// way to disable the acknowledgement reaction, and normalises to empty.
func applyDispatchDefaults(cfg *config.Config) {
if cfg.Dispatch.Trigger == "" {
cfg.Dispatch.Trigger = defaultDispatchTrigger
}
switch {
case cfg.Dispatch.AckReaction == "":
cfg.Dispatch.AckReaction = defaultAckReaction
case isOff(cfg.Dispatch.AckReaction):
cfg.Dispatch.AckReaction = ""
}
if cfg.Dispatch.Labels == nil {
cfg.Dispatch.Labels = map[string]string{}
}
for k, v := range config.DispatchLabelDefaults() {
if cfg.Dispatch.Labels[k] == "" {
cfg.Dispatch.Labels[k] = v
}
}
}
// applyIdentityDefaults derives forge-appropriate commit emails wherever the
// operator omitted one, for both deployment shapes.
func applyIdentityDefaults(cfg *config.Config) {
if len(cfg.Identities) > 0 {
for i := range cfg.Identities {
cfg.Identities[i].BotEmail = defaultBotEmail(cfg.Identities[i].Forge.Type, cfg.Identities[i].BotUser, cfg.Identities[i].BotEmail)
}
}
cfg.BotEmail = defaultBotEmail(cfg.Forge.Type, cfg.BotUser, cfg.BotEmail)
}
func defaultBotEmail(forgeType, user, email string) string {
if user == "" || email != "" {
return email
}
switch forgeType {
case forgeTypeGitHub:
return user + "@users.noreply.github.com"
case forgeTypeGitea:
return user + "@gitea.local"
}
return email
}
// applyContainerDefaults makes managed task workers usable without an explicit
// [containers] section. A negative VolumeTTL is left for validation to reject.
func applyContainerDefaults(cfg *config.Config) {
if cfg.Containers.Image == "" {
cfg.Containers.Image = defaultContainerImage
}
if cfg.Containers.MaxUptime == 0 {
cfg.Containers.MaxUptime = config.Duration(defaultContainerUptime)
}
if cfg.Containers.VolumeTTL == 0 {
cfg.Containers.VolumeTTL = config.Duration(defaultVolumeTTL)
}
if cfg.Containers.PullPolicy == "" {
cfg.Containers.PullPolicy = defaultPullPolicy
}
}