applyContainerDefaults no longer fills containers.image with a hard-coded private-registry reference. An unset image now fails configuration validation with 'containers.image is required for autonomous workflow workers', so a fresh instance is told at startup (and via the readiness probe at runtime) instead of at the first failed container pull. Configs that relied on the default now set it explicitly: dev.toml (the local task image:agent build, which e2e also overlays), plus commented [containers] blocks in config.example.toml and standalone.toml. The deploy docs no longer describe a code-level default.
350 lines
11 KiB
Go
350 lines
11 KiB
Go
package configuration
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"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
|
|
defaultWebListen = "127.0.0.1:8484" // "off" disables
|
|
defaultMaxRetries = 3
|
|
defaultIntakePerPass = 20
|
|
defaultForgeType = "github"
|
|
defaultForgeHost = "https://github.com"
|
|
defaultDispatchTrigger = "assignee"
|
|
defaultAckReaction = "eyes"
|
|
// defaultContainerUptime outlasts the default whole-task limit (4h) so the
|
|
// task budget, not the container reaper, ends a run.
|
|
defaultContainerUptime = 5 * time.Hour
|
|
defaultVolumeTTL = 72 * time.Hour
|
|
defaultPullPolicy = "missing"
|
|
|
|
// defaultMaxResultChars bounds one tool result.
|
|
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.
|
|
defaultCaptureRetention = 7 * 24 * time.Hour
|
|
defaultCaptureMaxEvents = 5000
|
|
defaultCaptureMaxBodyBytes = 256 * 1024
|
|
defaultCaptureRatePerSecond = 1.0
|
|
defaultCaptureRateBurst = 5
|
|
|
|
// defaultDenialRetention keeps denial records for 90 days, the same
|
|
// horizon the audit-retention seed gives the audit trail
|
|
// (docs/prds/orgs-and-access.md, "Audit retention").
|
|
defaultDenialRetention = 90 * 24 * time.Hour
|
|
|
|
// defaultHealthListen is the daemon's own liveness address.
|
|
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 every absent value. It never validates.
|
|
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)
|
|
}
|
|
if cfg.Telemetry.SampleRatio == 0 {
|
|
cfg.Telemetry.SampleRatio = 1
|
|
}
|
|
l.applyGeneralDefaults(cfg)
|
|
applyForgeDefaults(cfg)
|
|
applyDispatchDefaults(cfg)
|
|
applyIdentityDefaults(cfg)
|
|
applyContainerDefaults(cfg)
|
|
applyToolPolicyDefaults(cfg)
|
|
applyCaptureDefaults(cfg)
|
|
applyAccessDefaults(cfg)
|
|
applyNATSDefaults(cfg)
|
|
applyMemoryDefaults(cfg)
|
|
applyCuratorDefaults(cfg)
|
|
}
|
|
|
|
// applyCuratorDefaults resolves an omitted enabled key to on, so the seeded
|
|
// resource and the dashboard show the state the runtime applies.
|
|
func applyCuratorDefaults(cfg *config.Config) {
|
|
for i := range cfg.Curators {
|
|
if cfg.Curators[i].Enabled == nil {
|
|
on := true
|
|
cfg.Curators[i].Enabled = &on
|
|
}
|
|
}
|
|
}
|
|
|
|
// applyServiceDefaults fills each registered service's absent addresses from
|
|
// its registration. An empty registered target stays empty for validation.
|
|
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 default capture settings.
|
|
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 not defaulted: spilled results must be inside the read tool's
|
|
// workspace to be readable.
|
|
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 default work directory.
|
|
func DefaultWorkDir() string {
|
|
return filepath.Join(xdgDataHome(), InstanceName(), "work")
|
|
}
|
|
|
|
// DefaultPostgresSocketDir is where the bundled PostgreSQL's Unix socket is
|
|
// mounted on the host.
|
|
func DefaultPostgresSocketDir() string {
|
|
return filepath.Join(xdgDataHome(), InstanceName(), "postgres")
|
|
}
|
|
|
|
// DefaultConfigDir returns the directory archie's configuration lives in:
|
|
// $XDG_CONFIG_HOME/<instance>, or ~/.config/<instance>. 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(), InstanceName())
|
|
}
|
|
|
|
// DefaultConfigPath returns the config file archie binaries read when
|
|
// -config is not given.
|
|
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.SkillsDir = expandHomePath(cfg.SkillsDir)
|
|
cfg.WorkDir = expandHomePath(cfg.WorkDir)
|
|
cfg.StateDir = expandHomePath(cfg.StateDir)
|
|
cfg.Chat.Workspace = expandHomePath(cfg.Chat.Workspace)
|
|
// DatabaseURL has no default.
|
|
if cfg.WorkDir == "" {
|
|
cfg.WorkDir = filepath.Join(l.dataHome(), cfg.Instance, "work")
|
|
}
|
|
if cfg.StateDir == "" {
|
|
cfg.StateDir = filepath.Join(l.dataHome(), cfg.Instance)
|
|
}
|
|
if cfg.PollInterval == 0 {
|
|
cfg.PollInterval = config.Duration(defaultPollInterval)
|
|
}
|
|
if cfg.Web.Listen == "" {
|
|
cfg.Web.Listen = defaultWebListen
|
|
}
|
|
if cfg.MaxRetries == 0 {
|
|
cfg.MaxRetries = defaultMaxRetries
|
|
}
|
|
if cfg.IntakePerPass == 0 {
|
|
cfg.IntakePerPass = defaultIntakePerPass
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
// applyAccessDefaults fills the access surfaces' settings. See
|
|
// [config.AccessConfig].
|
|
func applyAccessDefaults(cfg *config.Config) {
|
|
if cfg.Access.DenialRetention == 0 {
|
|
cfg.Access.DenialRetention = config.Duration(defaultDenialRetention)
|
|
}
|
|
}
|
|
|
|
// 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 = ""
|
|
}
|
|
}
|
|
|
|
// applyIdentityDefaults fills omitted commit emails and copies a sole
|
|
// [[identities]] entry into the root single-identity fields.
|
|
func applyIdentityDefaults(cfg *config.Config) {
|
|
if len(cfg.Identities) > 0 {
|
|
for i := range cfg.Identities {
|
|
cfg.Identities[i].BotEmail = DefaultBotEmail(cfg.Forge.Type, cfg.Identities[i].BotUser, cfg.Identities[i].BotEmail)
|
|
}
|
|
if len(cfg.Identities) == 1 && cfg.BotUser == "" {
|
|
cfg.BotUser = cfg.Identities[0].BotUser
|
|
if cfg.BotEmail == "" {
|
|
cfg.BotEmail = cfg.Identities[0].BotEmail
|
|
}
|
|
}
|
|
}
|
|
cfg.BotEmail = DefaultBotEmail(cfg.Forge.Type, cfg.BotUser, cfg.BotEmail)
|
|
}
|
|
|
|
// DefaultBotEmail is the forge-appropriate commit email for user when email is empty.
|
|
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 fills the optional [containers] values. There is
|
|
// deliberately no default image: validateContainers reports a missing
|
|
// containers.image at startup instead of pointing task workers at one
|
|
// registry. A negative VolumeTTL is left for validation to reject.
|
|
func applyContainerDefaults(cfg *config.Config) {
|
|
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
|
|
}
|
|
// Nil, not empty: an operator who clears the list keeps it empty.
|
|
if cfg.Containers.EgressHosts == nil {
|
|
cfg.Containers.EgressHosts = slices.Clone(defaultEgressHosts)
|
|
}
|
|
}
|
|
|
|
// defaultEgressHosts are the package registries the agent image's tools
|
|
// install from at run time: Go modules, npm, PyPI and uv's Python builds.
|
|
var defaultEgressHosts = []string{
|
|
"proxy.golang.org", "sum.golang.org", "registry.npmjs.org",
|
|
"pypi.org", "files.pythonhosted.org", "github.com", "objects.githubusercontent.com",
|
|
}
|