Files
archie/internal/infrastructure/configuration/defaults.go
T
sam 856e2eef71 fix(configuration): resolve the default config path in one place
Four binaries derived the default with os.UserConfigDir while the daemon
resolved it from its own config home. The two agree on Linux with an
absolute XDG_CONFIG_HOME and diverge everywhere else, so one deployment
booted from a different config file depending on which binary started.

Move the rule into the package that owns configuration resolution
(internal/infrastructure/configuration, which already owns xdgDataHome and
DefaultWorkDir) as DefaultConfigDir/DefaultConfigPath, and have every
-config default take it from there: archie-gateway, archie-messaging,
archie-state-store (serve and recovery) and archie-ui, plus the daemon's
own parseArgs, setup generator and drain-marker path.

Fence the claim at the source, since the resolved value is only observable
by starting a process: no source under cmd/ or internal/app/archied may
call os.UserConfigDir, and every -config registration must default to the
helper.
2026-09-22 01:57:49 +10:00

357 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)
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.DBPath = expandHomePath(cfg.DBPath)
cfg.Chat.Workspace = expandHomePath(cfg.Chat.Workspace)
if cfg.WorkDir == "" {
cfg.WorkDir = filepath.Join(l.dataHome(), "archie", "work")
}
if cfg.DBPath == "" {
cfg.DBPath = filepath.Join(l.dataHome(), "archie", "archie.db")
}
cfg.Indexing = cfg.Indexing.WithDefaults(cfg.WorkDir)
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.Token.Engine == "" && cfg.Forge.Token.Key == "" && cfg.Forge.TokenEnv != "" {
cfg.Forge.Token = config.SecretRef{Engine: "env", Key: cfg.Forge.TokenEnv}
}
if cfg.Forge.Intake == "" {
cfg.Forge.Intake = config.ForgeIntakePoll
}
}
// 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
}
}