Files
archie/cmd/archied/bootstrap.go
T
sam dbb6550ab3 fix(worktree): bind publication to dispatch grants
Worktree RPC used to accept repository coordinates from the sandbox. It now accepts only an opaque per-dispatch grant, and the daemon derives the repository path and branch from grant-owned state.

Repository worktree paths also move from an ambiguous flattened key to encoded owner/repo components. Origin-matched legacy clones migrate safely; mismatched legacy paths are preserved.
2026-08-22 22:06:54 +10:00

1342 lines
52 KiB
Go

// bootstrap.go owns the composition of the daemon: run() is the entry
// point and driver, and each phase of wiring lives in a method on boot.
// The struct exists because the composition root assembles ~30 pieces of
// state that every phase touches; passing them as parameters would make
// each phase function longer than the code it contains.
package main
import (
"context"
"encoding/json"
"fmt"
"log/slog"
"net/http"
"os"
"os/signal"
"path/filepath"
"sort"
"sync/atomic"
"syscall"
"time"
"github.com/samcharles93/ai-sdk/runtime"
"github.com/samcharles93/archie-core/internal/agentexec"
channelruntime "github.com/samcharles93/archie-core/internal/channels"
"github.com/samcharles93/archie-core/internal/channels/email"
"github.com/samcharles93/archie-core/internal/channels/webhook"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/container"
"github.com/samcharles93/archie-core/internal/daemon"
"github.com/samcharles93/archie-core/internal/domain/curator"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workflow/skillbuild"
"github.com/samcharles93/archie-core/internal/domain/workflow/wfeval"
"github.com/samcharles93/archie-core/internal/domain/workintake"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/forge"
forgewebhook "github.com/samcharles93/archie-core/internal/forge/webhook"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/overlay"
"github.com/samcharles93/archie-core/internal/infrastructure/eventbus/nats"
"github.com/samcharles93/archie-core/internal/infrastructure/modelcatalog"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/memory"
"github.com/samcharles93/archie-core/internal/plugin"
"github.com/samcharles93/archie-core/internal/plugin/pluginextract"
"github.com/samcharles93/archie-core/internal/releaseupdate"
"github.com/samcharles93/archie-core/internal/secret"
"github.com/samcharles93/archie-core/internal/skill"
"github.com/samcharles93/archie-core/internal/storage"
"github.com/samcharles93/archie-core/internal/store"
"github.com/samcharles93/archie-core/internal/tools"
toolprovider "github.com/samcharles93/archie-core/internal/tools/provider"
builtintoolprovider "github.com/samcharles93/archie-core/internal/tools/provider/builtin"
memorytoolprovider "github.com/samcharles93/archie-core/internal/tools/provider/memory"
"github.com/samcharles93/archie-core/internal/tools/webfetch"
"github.com/samcharles93/archie-core/internal/webhookguard"
"github.com/samcharles93/archie-core/internal/webui"
"github.com/samcharles93/archie-core/internal/worktree"
"github.com/samcharles93/archie-core/internal/worktreerpc"
)
// boot is the mutable wiring state assembled by the run() composition
// phases. Cleanup funcs are registered in creation order and run in
// reverse at shutdown, matching the LIFO ordering of the deferred calls
// they replace.
type boot struct {
cfg config.Config
log *slog.Logger
loader *configuration.Loader
doc *configuration.Document
overlayStore *overlay.Store
bootOverlayErr atomic.Pointer[string]
currentProvenance atomic.Pointer[configuration.Provenance]
logFeed *logging.Feed
taskLogs *logging.TaskRegistry
secrets *secret.Registry
forgeClient forge.Forge
token string
st store.TaskStore
chatSessionStore gateway.SessionStore
catalog modelcatalog.Snapshot
catalogModels []string
bus *events.Bus
restartTelegram func() error
channelManager *channelruntime.Manager
web *webui.Server
natsClient *nats.Client
// natsURL is the endpoint the daemon's own client connected with at
// startup. For external mode it is cfg.NATS.URL; for embedded mode it is
// the embedded server's ClientURL(). Recorded so Daemon.ConnectedNATS
// carries the real endpoint rather than an empty config URL.
natsURL string
containerPool *container.Pool
storeBackend storage.Backend
sandboxRequired bool
providers map[string]agentexec.Provider
llm *runtime.Runtime
toolReg *tools.Registry
chatModels gateway.ModelManager
personas *gateway.PersonaRegistry
chatTasks gateway.TaskCreator
chatController *gateway.StoreTaskController
defaultChatIdentity string
updateService *releaseupdate.Service
webRouter *gateway.Router
startGateways []func()
agentRunner agentexec.Runner
registry workflow.Registry
capabilityHost *plugin.Host
trees *worktree.Manager
worktreeGrants *worktreerpc.Grants
identityRunners []*daemon.IdentityRunner
memManager *memory.Manager
curatorRegistry *curator.Registry
curatorRuntime *curator.Runtime
guardrails *tools.GuardrailEngine
providerRegistry *toolprovider.Registry
d *daemon.Daemon
cleanups []func()
}
func newBootstrap() *boot {
return &boot{log: slog.New(slog.NewJSONHandler(os.Stderr, nil))}
}
func (b *boot) addCleanup(fn func()) {
b.cleanups = append(b.cleanups, fn)
}
func (b *boot) cleanup() {
for i := len(b.cleanups) - 1; i >= 0; i-- {
b.cleanups[i]()
}
}
// loadConfig resolves the file config and layers the runtime overlay
// over it. A Resolve failure is reported on stderr because the file log
// destination is itself configuration that has not been read yet.
func (b *boot) loadConfig(ctx context.Context, cfgPath, overlayPath string, noConfigOverlay bool) error {
loader := configuration.New(b.log)
b.loader = loader
skipOverlay := noConfigOverlay || configuration.SkipOverlay()
if skipOverlay {
b.log.Info("runtime config overlay disabled (recovery hatch); booting on file config alone")
}
doc, err := loader.Resolve(cfgPath, overlayPath)
if err != nil {
fmt.Fprintln(os.Stderr, err)
return err
}
b.doc = doc
// Runtime config overlay: dashboard-edited overrides layered over the
// file config from their own SQLite file (own user_version and
// migrator, no contention with the task store). Skipped under
// --no-config-overlay / ARCHIE_SKIP_CONFIG_OVERLAY=1, or when the
// store cannot be opened or its values fail validation -- a broken
// overlay must not brick the daemon. bootOverlayErr carries the
// degrade reason into /api/config's reload status so it is visible
// where the operator is looking, not only in logs.
if !skipOverlay {
b.overlayStore, b.doc = bootConfigOverlay(ctx, loader, doc, &b.bootOverlayErr, b.log)
if b.overlayStore != nil {
store := b.overlayStore
b.addCleanup(func() { _ = store.Close() })
}
}
b.cfg = b.doc.Config
b.currentProvenance.Store(&b.doc.Provenance)
return b.setupLogging()
}
// setupLogging re-creates the logger now the config is known. Everything
// before this point logs to stderr only, which is unavoidable: the log
// destination is itself configuration. A file that cannot be opened is
// reported and the daemon continues on stderr -- losing the durable copy
// must not take the daemon down with it.
func (b *boot) setupLogging() error {
cfg := b.cfg
logFeed := logging.NewFeed(1000)
b.logFeed = logFeed
// Task logs live alongside the store rather than under cfg.Log.File's
// directory: cfg.Log.File is optional (file logging can be off), while
// DBPath is required for the daemon to run at all, so it is the more
// reliable anchor for "where archie keeps its state" on this host.
taskLogs := logging.NewTaskRegistry(filepath.Join(filepath.Dir(cfg.DBPath), "logs", "tasks"), logFeed, logging.TaskSinkOptions{})
b.taskLogs = taskLogs
fileLog, logCloser, logErr := logging.New(logging.Options{
File: cfg.Log.File,
MaxSizeMB: cfg.Log.MaxSizeMB,
Keep: cfg.Log.Keep,
Level: cfg.Log.Level,
Stderr: !cfg.Log.Quiet,
Feed: logFeed,
})
b.log = fileLog
b.addCleanup(func() { _ = logCloser.Close() })
if logErr != nil {
b.log.Error("file logging disabled", "err", logErr)
} else if cfg.Log.File != "" {
b.log.Info("logging to file", "path", cfg.Log.File)
}
return nil
}
// openStores wires the secret registry, forge client and both stores.
func (b *boot) openStores(ctx context.Context) error {
cfg, log := b.cfg, b.log
secrets, err := configuredSecretRegistry(&cfg, log)
if err != nil {
log.Error("configure secrets", "err", err)
return err
}
b.secrets = secrets
b.forgeClient, b.token = resolveForge(cfg.Forge, secrets, log)
st, err := openProductionTaskStore(ctx, taskDBPath(cfg.DBPath))
if err != nil {
log.Error("open store", "err", err)
return err
}
b.st = st
b.addCleanup(func() {
if err := st.Close(); err != nil {
log.Error("close store", "err", err)
}
})
chatSessionStore, err := makeTelegramSessionStore(cfg) //nolint:contextcheck // the session store opener takes no context by design; its schema init must complete at boot regardless of cancellation
if err != nil {
log.Error("open conversation store", "path", conversationDBPath(cfg.DBPath), "err", err)
return err
}
b.chatSessionStore = chatSessionStore
b.addCleanup(func() {
if err := chatSessionStore.Close(); err != nil {
log.Error("close conversation store", "err", err)
}
})
return nil
}
// handleRequeue replays a parked/waiting task by id, then signals an
// early success exit unless -once keeps the daemon running.
func (b *boot) handleRequeue(ctx context.Context, requeue int64, once bool) (bool, error) {
if requeue <= 0 {
return false, nil
}
if err := manualRequeueTask(ctx, b.st, requeue); err != nil {
b.log.Error("requeue failed", "task", requeue, "err", err)
return false, err
}
b.log.Info("task requeued", "task", requeue)
return !once, nil
}
func (b *boot) loadCatalog(ctx context.Context, cfgPath string) {
catalog, err := modelcatalog.Load(ctx, modelcatalog.Options{
CachePath: filepath.Join(filepath.Dir(cfgPath), "models.json"),
Getenv: b.secrets.Getenv,
Configured: b.cfg.Providers,
})
b.catalog = catalog
if err != nil {
b.log.Warn("model catalog unavailable; using configured providers and models", "err", err)
return
}
b.catalogModels = applyModelCatalog(&b.cfg, catalog)
b.log.Info("model catalog loaded", "providers", len(catalog.Providers), "models", len(b.catalogModels))
}
// setupObservability builds the event bus, channel manager and dashboard
// server. Every event is logged to SQLite (stamped with its row id) and
// then fanned out to live dashboard connections.
func (b *boot) setupObservability() {
cfg, log := b.cfg, b.log
bus := events.NewBus()
b.bus = bus
b.addCleanup(func() { bus.Close() })
telegramDetail := ""
if cfg.Chat.Telegram.TokenEnv != "" && len(cfg.Chat.Telegram.AllowedUserIDs) == 0 {
telegramDetail = "Token set, but the allowlist is empty -- the bot answers nobody."
}
b.channelManager = channelruntime.NewManager([]channelruntime.Descriptor{
{ID: "telegram", Name: "Telegram", Configured: cfg.Chat.Telegram.TokenEnv != "", ReloadSupported: cfg.Chat.Telegram.TokenEnv != "", Detail: telegramDetail},
{ID: "email", Name: "Email", Configured: cfg.Chat.Email.ListenAddr != ""},
{ID: "webhook", Name: "Webhook gateway", Configured: cfg.Chat.WebhookAddr != ""},
})
configProvenance := make([]webui.ConfigOrigin, 0, len(b.doc.Provenance.Origins))
for _, origin := range b.doc.Provenance.Origins {
configProvenance = append(configProvenance, webui.ConfigOrigin{
Path: origin.Path, Role: string(origin.Role), Layer: string(origin.Layer), Feature: string(origin.Feature),
})
}
b.web = &webui.Server{Store: b.st, Log: log, LogFeed: b.logFeed, TaskLogs: b.taskLogs, Cfg: config.NewHolder(cfg), Channels: b.channelManager, Events: bus}
b.web.SetProvenance(configProvenance)
b.web.ReloadChannel = func(ctx context.Context, id string) error {
if id != "telegram" || b.restartTelegram == nil {
return fmt.Errorf("channel reload unavailable")
}
return b.restartTelegram()
}
// The dashboard closes the forge issue behind a rejected task, or the
// issue is re-polled and the work is done again. It gets only that one
// method, not the forge client.
b.web.Issues = b.forgeClient
// Capture storage: openProductionTaskStore's declared return type is the
// narrow store.TaskStore, so the CaptureStore surface (implemented by
// the same *store.Store) needs its own assertion here rather than a
// direct field reuse. See docs/prds/event-capture-storage.md.
if cs, ok := b.st.(store.CaptureStore); ok {
b.web.Captures = cs
} else {
log.Warn("capture storage unavailable: task store does not implement CaptureStore")
}
b.web.CaptureRetention = cfg.Capture.Retention.Std()
b.web.CaptureMaxEvents = cfg.Capture.MaxEvents
b.web.CaptureMaxBodyBytes = int64(cfg.Capture.MaxBodyBytes)
b.web.CaptureLimiter = webhookguard.NewRateLimiter(cfg.Capture.RatePerSecond, cfg.Capture.RateBurst, time.Now)
// Mapping storage: same narrow-assertion pattern as CaptureStore above,
// for the same reason -- openProductionTaskStore's declared return type
// doesn't expose it. See docs/prds/payload-field-mapping.md.
if ms, ok := b.st.(store.MappingStore); ok {
b.web.Mappings = ms
} else {
log.Warn("mapping storage unavailable: task store does not implement MappingStore")
}
sink := bus.Subscribe(256)
go persistAndBroadcastEvents(sink, b.st, b.web, log)
}
// connectNATS opens the NATS client. External mode dials cfg.NATS.URL;
// embedded mode starts an in-process nats-server and dials it, so single-
// process deployments get task distribution and reaction delivery without a
// separate server. Off mode returns nil and the SQLite ClaimNext flow runs.
func (b *boot) connectNATS(ctx context.Context) error {
cfg, log := b.cfg, b.log
if cfg.NATS.Mode == config.NATSModeOff {
return nil
}
url := cfg.NATS.URL
var natsToken string
if cfg.NATS.Mode == config.NATSModeExternal {
var err error
natsToken, err = configuredNATSToken(cfg.NATS, os.Getenv)
if err != nil {
log.Error("nats credentials", "err", err)
return err
}
} else {
// Embedded. Start the in-process server before dialing, and register
// its shutdown BEFORE the client close below so the client closes
// first (cleanups run LIFO).
srv, err := nats.StartEmbedded(ctx, nats.EmbeddedOptions{
StoreDir: filepath.Join(filepath.Dir(cfg.DBPath), "nats"),
}, log)
if err != nil {
log.Error("embedded nats start failed", "err", err)
return err
}
b.addCleanup(func() { srv.Shutdown() })
url = srv.ClientURL()
log.Info("embedded nats started", "url", url)
}
// Composition owns the subject list: the bus must not know which
// subjects belong to which domain.
natsClient, err := nats.Connect(ctx, nats.Config{
URL: url,
Token: natsToken,
Subjects: []string{workintake.SubjectTaskWildcard, agentexec.SubjectAgentWildcard},
FilterSubject: workintake.SubjectTaskWildcard,
}, log)
if err != nil {
log.Error("nats connect failed", "err", err)
return err
}
b.natsClient = natsClient
b.natsURL = url
b.addCleanup(func() { natsClient.Close() })
log.Info("nats connected", "url", url)
return nil
}
// setupContainers builds the optional container pool. Container setup
// degrades rather than aborting, for the same reason resolveForge does:
// containers are one capability among many, and refusing to start denies
// the operator chat, the dashboard and every other subsystem over a
// feature they may not be exercising right now. Under a systemd unit
// with Restart=on-failure it also turns a recoverable problem into a
// crash loop with the real error scrolling past unread.
func (b *boot) setupContainers(ctx context.Context) {
containerPool, storeBackend, closeDocker := startContainers(ctx, b.cfg, b.log)
b.containerPool = containerPool
b.storeBackend = storeBackend
b.addCleanup(closeDocker)
// Sandboxing that was asked for and could not start must not silently
// become no sandboxing: the daemon stays up, but tasks park rather than
// running the agent loop on the host.
b.sandboxRequired = b.cfg.Containers.Enabled && containerPool == nil
}
// setupLLMAndChat wires the runtime, tool registry, model management,
// personas and the dashboard's chat service.
func (b *boot) setupLLMAndChat(ctx context.Context) {
cfg, log := b.cfg, b.log
// ── LLM runtime ──────────────────────────────────────────────────
// Created before gateways so the LLMResponder can be wired into the
// Telegram router for non-command message processing.
providers := executionProviders(cfg)
b.providers = providers
b.llm = agentexec.NewRuntime(providers)
b.toolReg = tools.NewRegistry()
chatModels := newChatModelManager(cfg.Models, cfg.Chat.Models, b.catalogModels)
chatModels.ApplyModelCatalog(b.catalog)
b.chatModels = chatModels
// ── Persona registry ─────────────────────────────────────────────
b.personas = gateway.NewPersonaRegistry(gateway.DefaultPersonas())
profiles, defaultChatIdentity := chatTaskProfiles(cfg)
var chatTasks gateway.TaskCreator
if len(profiles) > 0 {
chatTasks = gateway.NewStoreTaskCreatorForProfiles(
chatTaskWriterAdapter{enqueue: b.st.EnqueueChatTask},
profiles,
)
}
b.chatTasks = chatTasks
b.defaultChatIdentity = defaultChatIdentity
chatController := gateway.NewStoreTaskController(chatTaskControllerAdapter{
taskByID: b.st.TaskByID,
requeue: b.st.Requeue,
transition: b.st.Transition,
})
b.chatController = chatController
b.updateService = makeUpdateService(telegramSetup{Cfg: config.NewHolder(cfg)})
b.web.WorkRequests = b.chatTasks
// The dashboard is another gateway, not a second chat implementation. It
// shares the router, session history, model selection, personas and LLM
// responder with Telegram while using a stable browser channel id.
b.webRouter = gateway.NewRouter(b.st, nil, "web")
b.webRouter.Version = fmt.Sprintf("Archie\nGateway: %s\nRuntime: %s", gatewayVersion, runtimeVersion)
if cfg.Chat.Telegram.TokenEnv != "" {
b.webRouter.Restart = func(context.Context) error {
if b.restartTelegram == nil {
return fmt.Errorf("telegram gateway is not ready")
}
return b.restartTelegram()
}
}
b.webRouter.Models = b.chatModels
if b.updateService != nil {
b.webRouter.Updates = b.updateService
}
b.webRouter.Personas = b.personas
b.webRouter.InitSessions(b.chatSessionStore)
configureTaskCommands(b.webRouter, b.chatTasks, b.chatController, b.defaultChatIdentity)
webSetup := telegramSetup{
Cfg: config.NewHolder(cfg), St: b.st, LLM: b.llm, ChatModels: b.chatModels, ToolReg: b.toolReg,
Personas: b.personas, ChatTasks: b.chatTasks, ChatController: b.chatController,
ChatTaskLister: chatTaskListerAdapter{tasks: b.st.Tasks},
ChatTaskLogs: chatTaskLogReaderAdapter{
tasks: b.st.TaskByID,
taskLogs: b.taskLogs,
},
DefaultChatIdentity: b.defaultChatIdentity, SessionStore: b.chatSessionStore,
Bus: b.bus, Log: log,
}
b.webRouter.LLM, b.webRouter.LLMStream = makeChatLLMResponder(ctx, "web", webSetup, b.chatSessionStore, b.webRouter)
b.webRouter.Titles = newChatTitleGenerator(webSetup)
b.webRouter.Log = log
b.web.Chat = &webui.ChatService{
Router: b.webRouter, Sessions: b.chatSessionStore,
Turns: gateway.NewTurns(log),
Models: b.chatModels, Personas: b.personas,
}
if b.updateService != nil {
b.web.Chat.Updates = b.updateService
}
}
// setupGateways assembles the Telegram, email and webhook gateways. It
// returns false when the Telegram gateway could not start, which the
// caller treats as a fatal boot error.
//
// Multi-agent collaboration PRD phase C (docs/prds/multi-agent-collaboration.md).
func (b *boot) setupGateways(ctx context.Context, cfgPath, overlayPath string) bool {
cfg, log := b.cfg, b.log
start, ok := setupTelegramGateway(ctx, telegramSetup{
Cfg: config.NewHolder(cfg), CfgPath: cfgPath, OverlayPath: overlayPath,
St: b.st, LLM: b.llm, ChatModels: b.chatModels, ToolReg: b.toolReg,
Personas: b.personas, ChatTasks: b.chatTasks, ChatController: b.chatController,
ChatTaskLister: chatTaskListerAdapter{tasks: b.st.Tasks},
ChatTaskLogs: chatTaskLogReaderAdapter{
tasks: b.st.TaskByID,
taskLogs: b.taskLogs,
},
DefaultChatIdentity: b.defaultChatIdentity, SessionStore: b.chatSessionStore, Updates: b.updateService,
Bus: b.bus,
RegisterRestart: func(request func() error) { b.restartTelegram = request }, Log: log,
ChannelManager: b.channelManager,
})
if !ok {
return false
}
if start != nil {
b.startGateways = append(b.startGateways, start)
}
// ── Email gateway (optional) ───────────────────────────────────
if cfg.Chat.Email.ListenAddr != "" {
em := email.New(cfg.Chat.Email.ListenAddr, cfg.Chat.Email.RelayAddr, log)
emRouter := gateway.NewRouter(b.st, nil, "email")
configureTaskCommands(emRouter, b.chatTasks, b.chatController, b.defaultChatIdentity)
b.startGateways = append(b.startGateways, func() {
b.channelManager.MarkStarting("email")
go func() {
if err := em.Start(ctx, emRouter); err != nil && ctx.Err() == nil {
b.channelManager.MarkFailed("email", err.Error())
log.Error("email gateway stopped", "err", err)
}
}()
log.Info("email gateway started", "addr", cfg.Chat.Email.ListenAddr)
})
}
// ── Webhook gateway (optional) ─────────────────────────────────
// Enabled when chat.webhook is set to a host:port listen address.
if cfg.Chat.WebhookAddr != "" {
host, port := parseListenAddr(cfg.Chat.WebhookAddr, "0.0.0.0", 8644)
wh := webhook.New(
host, port,
[]webhook.RouteConfig{{Path: "/webhook"}},
log,
)
whRouter := gateway.NewRouter(b.st, nil, "webhook")
configureTaskCommands(whRouter, b.chatTasks, b.chatController, b.defaultChatIdentity)
b.startGateways = append(b.startGateways, func() {
b.channelManager.MarkStarting("webhook")
go func() {
if err := wh.Start(ctx, whRouter); err != nil && ctx.Err() == nil {
b.channelManager.MarkFailed("webhook", err.Error())
log.Error("webhook gateway stopped", "err", err)
}
}()
log.Info("webhook gateway started", "addr", fmt.Sprintf("%s:%d", host, port))
})
}
return true
}
func (b *boot) buildAgentRunner() error {
cfg, log := b.cfg, b.log
if b.llm == nil {
return nil
}
switch cfg.Agent.Mode {
case "subprocess":
b.agentRunner = &agentexec.SubprocessRunner{
Command: cfg.Agent.Command,
Environ: os.Environ(),
AdditionalEnv: cfg.Agent.Env,
Diagnostics: os.Stderr,
Providers: b.providers,
}
case "inprocess":
inproc := agentexec.NewInProcessRunner(b.llm, log, b.toolReg)
inproc.Limits = toolLimits(cfg)
b.agentRunner = inproc
case "nats":
if b.natsClient == nil {
log.Error("agent.mode is nats but nats is unavailable (nats.mode is off)")
return fmt.Errorf("agent.mode is nats but nats is unavailable (nats.mode is off)")
}
b.agentRunner = &agentexec.NATSRunner{
Bus: b.natsClient,
Providers: b.providers,
MCPServers: cfg.Tools.MCPServers,
Log: log,
}
}
return nil
}
// loadWorkflows builds the workflow registry from the skill catalog.
// Plugin-defined workflows override built-ins of the same name;
// built-ins fill gaps.
func (b *boot) loadWorkflows(ctx context.Context) error {
cfg, log := b.cfg, b.log
skillsBase := cfg.SkillsDir
if skillsBase == "" {
skillsBase = cfg.WorkDir
}
workflowCatalog, err := skillbuild.BuildCatalog(skillsBase)
if err != nil {
log.Error("skill registry build failed", "err", err)
return err
}
b.registry = workflowCatalog.Registry
log.Info("workflow registry built", "workflows", len(b.registry))
b.web.Workflows = workflow.DefinitionsWithOrigins(b.registry, workflowCatalog.Origins)
if l := cfg.Web.Listen; l != "" && l != "off" {
b.web.Token = webTokenFor(l, cfg.DBPath, log)
go func() {
if err := b.web.Run(ctx, l); err != nil {
log.Error("web ui failed", "err", err)
}
}()
}
return nil
}
// loadPlugins loads daemon plugins from the configured plugin directory
// (Layer 2). Failed plugins are skipped -- the daemon starts with the
// remaining set.
func (b *boot) loadPlugins() error {
cfg, log := b.cfg, b.log
b.capabilityHost = plugin.NewHost()
if cfg.PluginDir == "" {
return nil
}
plugins, err := plugin.LoadDir(cfg.PluginDir, pluginextract.Symbols)
if err != nil {
log.Error("plugin load failed", "dir", cfg.PluginDir, "err", err)
return err
}
for _, p := range plugins {
name, version := safePluginInfo(p)
module, err := plugin.AdaptLegacy(p)
if err != nil {
log.Warn("daemon plugin capability registration skipped", "name", name, "version", version, "err", err)
continue
}
if err := b.capabilityHost.Register(module); err != nil {
log.Warn("daemon plugin capability registration skipped", "name", name, "version", version, "err", err)
continue
}
log.Info("daemon plugin loaded", "name", name, "version", version)
}
return nil
}
// buildTreesAndIdentities composes the worktree manager and the
// multi-identity runners. Each configured identity gets its own forge
// client (its own token, possibly its own forge type/host) and its own
// worktree manager (a distinct WorkDir so concurrent identities never
// collide on the same clone). When cfg.Identities is empty,
// Daemon.Identities stays nil and Run() takes the single-identity path
// unchanged.
func (b *boot) buildTreesAndIdentities(ctx context.Context) error {
cfg, log := b.cfg, b.log
b.trees = &worktree.Manager{
WorkDir: cfg.WorkDir,
Token: b.token,
BotUser: cfg.BotUser,
BotEmail: cfg.BotEmail,
BaseURL: cfg.Forge.Host,
}
for _, idCfg := range cfg.Identities {
// Same reasoning as the primary forge: one identity whose credential is
// missing must not deny every other identity, and every other
// subsystem, the ability to run.
idForge, idToken := resolveForge(idCfg.Forge, b.secrets, log.With("identity", idCfg.Name))
idTrees := &worktree.Manager{
WorkDir: filepath.Join(cfg.WorkDir, "identity-"+idCfg.Name),
Token: idToken,
BotUser: idCfg.BotUser,
BotEmail: idCfg.BotEmail,
BaseURL: idCfg.Forge.Host,
}
runner, err := daemon.NewIdentityRunner(ctx, idCfg, idForge, idTrees, log)
if err != nil {
log.Error("identity construction failed", "identity", idCfg.Name, "err", err)
return err
}
idProviders := agentexec.ProvidersFromConfig(idCfg.Providers)
idRuntime := agentexec.NewRuntime(idProviders)
if idRuntime != nil {
switch cfg.Agent.Mode {
case "subprocess":
runner.Agent = &agentexec.SubprocessRunner{
Command: cfg.Agent.Command,
Environ: os.Environ(),
AdditionalEnv: cfg.Agent.Env,
Diagnostics: os.Stderr,
Providers: idProviders,
}
case "inprocess":
idRunner := agentexec.NewInProcessRunner(idRuntime, log.With("identity", idCfg.Name), b.toolReg)
idRunner.Limits = toolLimits(cfg)
runner.Agent = idRunner
case "nats":
runner.Agent = &agentexec.NATSRunner{
Bus: b.natsClient, Providers: idProviders,
MCPServers: cfg.Tools.MCPServers, Log: log.With("identity", idCfg.Name),
}
}
}
b.identityRunners = append(b.identityRunners, runner)
log.Info("identity configured", "identity", idCfg.Name, "bot_user", idCfg.BotUser, "repos", len(idCfg.Repos))
}
return nil
}
// registerNATSRPC lets archie-agent containers (which hold no DB
// connection, forge token, or push credential) proxy Store/Forge/
// worktree operations back to archied over NATS.
func (b *boot) registerNATSRPC() error {
log := b.log
if b.natsClient == nil {
return nil
}
coreConn, err := b.natsClient.CoreConn()
if err != nil {
log.Error("nats connection unavailable for task RPC", "err", err)
return err
}
b.worktreeGrants = worktreerpc.NewGrants()
unsubscribe, err := registerTaskRPCServers(coreConn, b.st, b.forgeClient, b.trees, b.identityRunners, b.worktreeGrants, log)
if err != nil {
log.Error("task RPC server registration failed", "err", err)
return err
}
b.addCleanup(unsubscribe)
unsubscribeSystemLogs, err := subscribeSystemLogs(coreConn, b.taskLogs, log)
if err != nil {
log.Error("system log subscribe failed", "err", err)
return err
}
b.addCleanup(unsubscribeSystemLogs)
unsubscribeAgentEvents, err := subscribeAgentEvents(coreConn, b.bus, log)
if err != nil {
log.Error("agent event subscribe failed", "err", err)
return err
}
b.addCleanup(unsubscribeAgentEvents)
return nil
}
// setupMemory starts the memory manager. The built-in file-backed
// provider (MEMORY.md + USER.md) lives under the daemon work directory.
// External providers from config are added via RegisterExternal when
// cfg.Memory.Provider is set.
func (b *boot) setupMemory() error {
cfg, log := b.cfg, b.log
memProvider, memDir := memoryProvider(cfg.WorkDir, log)
if memProvider == nil {
log.Error("memory provider init failed", "dir", memDir)
return fmt.Errorf("memory provider init failed in %s", memDir)
}
memManager, err := memory.NewManager(memProvider, nil)
if err != nil {
log.Error("memory manager init failed", "err", err)
return err
}
b.memManager = memManager
// The dashboard is built before memory exists, so it is wired in here
// rather than at construction.
b.web.Memory = memManager
if err := memManager.Initialize("daemon"); err != nil {
log.Warn("memory manager initialize", "err", err)
}
mm := memManager
b.addCleanup(func() {
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := mm.ShutdownContext(shutdownCtx); err != nil {
log.Error("memory manager shutdown", "err", err)
}
})
log.Info("memory manager started", "dir", memDir)
return nil
}
// setupCurators wires the curator engine family. The registry owns
// curator registration, lifecycle and shutdown ordering. The runtime
// loop (archie-core-89x) and the reference curators (archie-core-i7i,
// gs8) are wired by their issues; until then the registry is empty and
// Stop is a no-op. The event sink rides the in-process bus, whose
// bounded dropping per-subscriber buffers guarantee curator activity can
// never backpressure the daemon or a chat turn.
func (b *boot) setupCurators(ctx context.Context) {
log := b.log
b.curatorRegistry = curator.NewRegistry(curator.Registrar{
Events: curatorEventSink{b.bus},
})
// The runtime owns the per-curator loops (archie-core-89x): one
// goroutine per curator, wake nudges, per-pass budgets, panic
// recovery, bounded shutdown. Stop order at shutdown: runtime first
// (cancels in-flight passes, then stops curator lifecycle), then the
// registry's own Stop below, which is a no-op by then.
b.curatorRuntime = curator.NewRuntime(b.curatorRegistry, curator.RuntimeConfig{})
// Primary chat turns wake input-driven curators (archie-core-035):
// the forwarder consumes only primary-input kinds, and curator
// output never produces them, so derived work cannot feed its own
// trigger. The subscriber buffer is bounded and dropping — a slow
// curator can never backpressure the chat publisher.
curator.WakeOnPrimaryInput(ctx, b.bus, b.curatorRuntime, events.KindTurnCompleted)
rt := b.curatorRuntime
b.addCleanup(shutdownCuratorRuntime(rt, log))
reg := b.curatorRegistry
b.addCleanup(shutdownCuratorRegistry(reg, log))
}
func (b *boot) setupGuardrails() {
log := b.log
gc := tools.DefaultGuardrailConfig()
b.guardrails = tools.NewGuardrailEngine(gc)
log.Info(
"guardrail engine enabled",
"exact_failure_warn", gc.ExactFailureWarnAfter,
"same_tool_failure_warn", gc.SameToolFailureWarnAfter,
"no_progress_warn", gc.NoProgressWarnAfter,
)
}
// registerTools registers the tool providers with a lifecycle: memory,
// workspace file/shell tools and optional MCP servers.
func (b *boot) registerTools() error {
cfg, log := b.cfg, b.log
b.providerRegistry = toolprovider.NewRegistry(b.toolReg)
if err := b.providerRegistry.Register(memorytoolprovider.New(b.memManager)); err != nil {
log.Error("memory tool provider registration failed", "err", err)
return err
}
// Workspace file and shell tools. Registered only when a workspace is
// configured: these read, write and execute, so the directory is a
// deliberate choice rather than a default.
if workspace := cfg.Chat.Workspace; workspace != "" {
unrestricted := cfg.Chat.UnrestrictedFilesystem
if err := b.providerRegistry.Register(builtintoolprovider.New(workspace, unrestricted)); err != nil {
log.Error("workspace tool provider registration failed", "err", err)
return err
}
// Logged at the same level either way: which of the two postures is
// running is the first thing worth knowing when a file tool refuses a
// path, or reaches one it should not have.
log.Info("workspace tools enabled",
"workspace", workspace, "unrestricted_filesystem", unrestricted)
} else {
log.Info("workspace tools disabled (chat.workspace is unset)")
}
for _, srv := range cfg.Tools.MCPServers {
provider, err := configuredMCPProvider(srv, cfg.WorkDir)
if err != nil {
log.Warn("mcp tool provider skipped", "name", srv.Name, "err", err)
continue
}
// Optional: an MCP server is a third-party process pulled in at
// runtime, and it is exactly the category that is allowed to be
// absent. Registering it as required meant one failing npm package
// unregistered every builtin tool and exited the daemon, which under
// Restart=on-failure is a crash loop that takes chat and the gateway
// with it.
if err := b.providerRegistry.RegisterOptional(provider); err != nil {
log.Warn("mcp tool provider skipped", "name", srv.Name, "err", err)
continue
}
}
if err := b.capabilityHost.Register(b.providerRegistry); err != nil {
log.Error("tool-provider capability registration failed", "err", err)
return err
}
return nil
}
// registerStandaloneTools registers the tools with no provider
// lifecycle: the skill catalog activator, the spill directory check and
// web_fetch.
func (b *boot) registerStandaloneTools() {
cfg, log := b.cfg, b.log
// Skill catalog → skill_activate tool (progressive disclosure: the
// catalog's name+description is always in the tool schema; the full
// SKILL.md body loads only when the model activates one).
if catalog, err := skill.CatalogRoots(skill.DefaultRoots(cfg.WorkDir, cfg.SkillsDir)...); err != nil {
log.Warn("skill catalog load failed", "err", err)
} else if entry := skill.ActivateTool(cfg.WorkDir, catalog); entry != nil {
if err := b.toolReg.Register(*entry); err != nil {
log.Warn("skill_activate registration failed", "err", err)
} else {
log.Info("skill catalog registered", "skills", len(catalog))
}
}
// Tool results too large to inline are written here. Created once, at
// startup: the write failure inside a turn is silent, so without this
// every oversized result would quietly fall back to truncation and
// spilling would look configured while doing nothing.
if spillDir := cfg.Tools.Policy.SpillDir; spillDir != "" {
if err := toolLimits(cfg).EnsureSpillDir(); err != nil {
log.Warn("tool spill directory unavailable; large results will be truncated instead", "err", err)
} else if ws := cfg.Chat.Workspace; ws != "" && !cfg.Chat.UnrestrictedFilesystem && !isWithin(ws, spillDir) {
// A spill hands the model a path to read back, and a confined read
// tool refuses anything outside the workspace. Outside it, the
// spill reference is a dead end and the result is lost rather than
// displaced -- worse than truncating in the first place.
//
// Not a concern when the filesystem is unrestricted: the read tool
// can reach the spill wherever it lives.
log.Warn("tool spill directory is outside chat.workspace; the model cannot read back what is spilled there",
"spill_dir", spillDir, "workspace", ws)
}
}
// web_fetch. Registered directly rather than as a tool provider: it has
// no process to start or stop, so the provider lifecycle would buy
// nothing. Disabled by configuration returns nil and advertises nothing.
if entry := webfetch.Tool(webfetch.Config{
Enabled: cfg.Tools.WebFetch.IsEnabled(),
Timeout: cfg.Tools.WebFetch.Timeout.Std(),
MaxBytes: cfg.Tools.WebFetch.MaxBytes,
AllowPrivateNetworks: cfg.Tools.WebFetch.AllowPrivateNetworks,
}); entry != nil {
if err := b.toolReg.Register(*entry); err != nil {
log.Warn("web_fetch registration failed", "err", err)
} else {
log.Info("web fetch enabled",
"allow_private_networks", cfg.Tools.WebFetch.AllowPrivateNetworks)
}
} else {
log.Info("web fetch disabled")
}
}
// buildDaemon constructs the daemon and hands the dashboard the handles
// it shares with it.
func (b *boot) buildDaemon() {
cfg, log := b.cfg, b.log
// ConnectedNATS must carry the endpoint the daemon's own client connected
// with at startup, not the raw config: for embedded mode the config URL is
// empty, but container env must never see an empty NATS_URL. (Containers
// are rejected in embedded mode by validation, but the field should mean
// the same thing regardless of mode.)
connectedNATS := cfg.NATS
connectedNATS.URL = b.natsURL
b.d = &daemon.Daemon{
Cfg: config.NewHolder(cfg),
ConnectedNATS: connectedNATS,
Store: b.st,
Bus: b.bus,
Forge: b.forgeClient,
Trees: b.trees,
Agent: b.agentRunner,
Workflows: b.registry,
CapabilityHost: b.capabilityHost,
Storage: b.storeBackend,
Log: log,
CustomStages: wfeval.Discover,
Tasks: b.natsClient,
WorktreeGrants: b.worktreeGrants,
ContainerPool: b.containerPool,
SandboxRequired: b.sandboxRequired,
Memory: b.memManager,
Guardrails: b.guardrails,
ToolRegistry: b.toolReg,
Curators: b.curatorRegistry,
Identities: b.identityRunners,
TaskLogs: b.taskLogs,
}
b.web.TaskStopper = b.d
// web and the daemon must share ONE Holder: a reload swaps d.Cfg and
// the dashboard reads the running config from the same snapshot. The
// webui Holder seeded in the literal above is replaced here; after
// this point /api/config and the daemon can never disagree about the
// published config.
b.web.Cfg = b.d.Cfg
b.setupForgeWebhook()
}
// setupForgeWebhook starts the forge webhook receiver when intake is "webhook"
// or "both". It decodes GitHub issue events into task envelopes and publishes
// them through the same path the poller uses, so a labelled or assigned issue
// becomes work immediately instead of on the next poll. Called from
// buildDaemon, since it needs the freshly built (*daemon.Daemon).PublishTask.
//
// A secret that fails to resolve degrades rather than aborts boot, same
// reasoning as resolveForge: under intake="both" the poll is the deployment's
// explicit backstop for exactly this kind of misconfiguration (CLAUDE.md's
// "polling has to remain a first-class option, not a legacy fallback"), so a
// typo'd env var name must not take the whole daemon down and silently stop
// polling too. Config validation already requires webhook_secret to be a
// configured reference before intake="webhook"/"both" is accepted; this
// handles the reference resolving to nothing at runtime.
//
// Single-identity only: the receiver has one dispatch config (root
// Dispatch.Trigger/Label/BotUser), so a multi-identity deployment's
// per-identity trigger/label/bot user cannot be matched correctly. Rather
// than run with the wrong identity's rules and silently misclassify or drop
// events for identity-scoped repos, webhook intake refuses to start when
// [[identities]] is configured; those repos keep working via their own
// per-identity poll loop, unaffected. Extending this to multi-identity is a
// separate feature, not a bug in this one.
func (b *boot) setupForgeWebhook() {
cfg, log := b.cfg, b.log
if cfg.Forge.Intake != config.ForgeIntakeWebhook && cfg.Forge.Intake != config.ForgeIntakeBoth {
return
}
if len(cfg.Identities) > 0 {
log.Error("forge webhook disabled: multi-identity deployments are not supported yet (each identity's own poll loop is unaffected)")
return
}
secretValue, err := cfg.Forge.WebhookSecret.Resolve(b.secrets)
if err != nil || secretValue == "" {
log.Error("forge webhook disabled: secret unavailable",
"engine", cfg.Forge.WebhookSecret.Engine, "key", cfg.Forge.WebhookSecret.Key, "err", err)
return
}
receiver := forgewebhook.New(secretValue, cfg.Dispatch.Trigger, cfg.Label, cfg.BotUser, b.d.PublishTask, log)
host, port := parseListenAddr(cfg.Forge.WebhookAddr, "0.0.0.0", 8645)
addr := fmt.Sprintf("%s:%d", host, port)
srv := &http.Server{Addr: addr, Handler: receiver}
b.startGateways = append(b.startGateways, func() {
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Error("forge webhook server stopped", "err", err)
}
}()
log.Info("forge webhook listening", "addr", addr)
})
b.addCleanup(func() {
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
_ = srv.Shutdown(shutdownCtx)
})
}
// publishConfig publishes a config snapshot and its provenance to both
// the daemon and the dashboard (they share one Holder). Reload and the
// PATCH path both go through it, so the two can never diverge.
// currentProvenance (an atomic) is the last published provenance chain;
// the PATCH path appends the runtime-overlay origin to it.
func (b *boot) publishConfig(cfg config.Config, provenance configuration.Provenance) {
b.d.Cfg.Set(cfg)
origins := make([]webui.ConfigOrigin, 0, len(provenance.Origins))
for _, origin := range provenance.Origins {
origins = append(origins, webui.ConfigOrigin{
Path: origin.Path, Role: string(origin.Role), Layer: string(origin.Layer), Feature: string(origin.Feature),
})
}
b.web.SetProvenance(origins)
}
// wireConfigPublishing installs SIGHUP reload and the reload status
// surface. The reload log warns about changed fields that require a
// restart, so an operator never has to read the source to find out
// whether their edit took effect. web.LastReload exposes the outcome to
// /api/config.
func (b *boot) wireConfigPublishing(ctx context.Context, cfgPath, overlayPath string) {
log := b.log
reloadController := newReloadController(b.loader, cfgPath, overlayPath, func(doc *configuration.Document) {
// Boot merges catalog-discovered providers into cfg before the
// Holders are seeded; publishing the raw reloaded document would
// drop them from the running config even though the file is
// unchanged. Re-apply the same merge (idempotent: a catalog that
// failed to load merges to identity).
applyModelCatalog(&doc.Config, b.catalog)
old := b.d.Cfg.Get()
b.currentProvenance.Store(&doc.Provenance)
b.publishConfig(doc.Config, doc.Provenance)
if fields := changedNonReloadableFields(old, doc.Config); len(fields) > 0 {
log.Warn("config reloaded; some changes require a restart",
"fields", fields, "paths", doc.Provenance.Paths())
} else {
log.Info("config reloaded", "paths", doc.Provenance.Paths())
}
})
if b.overlayStore != nil {
reloadController.WithOverlay(func() (map[string]any, error) { return b.overlayStore.Snapshot(ctx) })
}
// LastReload merges the reload controller's outcome with the boot-time
// overlay degrade, so /api/config carries both the last reload result
// and whether the runtime overlay is in effect at all.
b.web.LastReload = func() config.ReloadStatus {
st := reloadController.Status()
if p := b.bootOverlayErr.Load(); p != nil {
st.OverlayUnavailable = *p
}
return st
}
reloadCh := make(chan os.Signal, 1)
signal.Notify(reloadCh, syscall.SIGHUP)
b.addCleanup(func() { signal.Stop(reloadCh) })
go reloadLoop(ctx, reloadCh, reloadController, log)
// Give /cancel and /stop a handle on work already in flight. The
// controller is built before the daemon exists, so the runtime is
// attached here; gateways start further down, after d.Startup, so no
// command can arrive before this is wired.
b.chatController.WithRuntime(b.d)
}
// installUpdateConfigHandler installs the dashboard's PATCH /api/config
// handler. It applies updates to a deep copy of the published config,
// validates the materialised result, persists to the overlay, then
// publishes through the same path as reload. It must never call Set
// directly from the handler -- web.Cfg is the daemon's own Holder -- and
// it decodes into a Clone so a failed validation cannot mutate the
// published snapshot's shared maps.
func (b *boot) installUpdateConfigHandler() {
log := b.log
b.web.UpdateConfig = func(ctx context.Context, updates map[string]any) error {
if b.overlayStore == nil {
return fmt.Errorf("%w: config overlay is disabled (--no-config-overlay or ARCHIE_SKIP_CONFIG_OVERLAY=1)", webui.ErrConfigUpdateUnavailable)
}
for key := range updates {
if reason, denied := overlay.DeniedKeys[key]; denied {
return fmt.Errorf("%w: config key %s is not runtime-tunable: %s", webui.ErrConfigUpdateInvalid, key, reason)
}
}
next := b.d.Cfg.Get().Clone()
if err := applyDottedOverlay(&next, updates); err != nil {
return fmt.Errorf("%w: %w", webui.ErrConfigUpdateInvalid, err)
}
if err := configuration.Validate(&next); err != nil {
return fmt.Errorf("%w: %w", webui.ErrConfigUpdateInvalid, err)
}
for key, value := range updates {
data, err := json.Marshal(value)
if err != nil {
return fmt.Errorf("%w: %w", webui.ErrConfigUpdateInvalid, err)
}
if err := b.overlayStore.Set(ctx, key, string(data), "dashboard"); err != nil {
return err
}
}
// Provenance gets the runtime-overlay origin, replacing any prior
// one so the chain does not grow unboundedly across edits.
var kept []configuration.Origin
for _, origin := range b.currentProvenance.Load().Origins {
if origin.Path == "config_overlay (runtime)" {
continue
}
kept = append(kept, origin)
}
prov := configuration.Provenance{Origins: append(kept,
configuration.Origin{Path: "config_overlay (runtime)", Role: configuration.RoleMain, Layer: configuration.LayerOverlay})}
b.currentProvenance.Store(&prov)
b.publishConfig(next, prov)
b.bootOverlayErr.Store(nil) // a successful write proves the overlay works again
log.Info("config updated from dashboard", "keys", len(updates))
return nil
}
}
// installConfigHandlers installs the dashboard's config override
// listing and per-row reset handlers, both going through the same
// publish path as reload.
func (b *boot) installConfigHandlers(cfgPath, overlayPath string) {
log := b.log
// ConfigOverrides lists the dotted keys currently overridden by the
// runtime overlay, so the dashboard can mark those rows and offer a
// reset. A disabled store reports no overrides.
b.web.ConfigOverrides = func(ctx context.Context) ([]string, error) {
if b.overlayStore == nil {
return nil, nil
}
rows, err := b.overlayStore.Snapshot(ctx)
if err != nil {
return nil, err
}
keys := make([]string, 0, len(rows))
for k := range rows {
keys = append(keys, k)
}
sort.Strings(keys)
return keys, nil
}
// ResetConfig deletes one overlay row and republishes file + remaining
// overlay, so a dashboard-created override can be removed without
// editing SQL -- and so an operator whose file edit is shadowed by an
// override can recover it with one click. The file is resolved and
// the target state validated BEFORE the row is deleted, so a broken
// file cannot leave the store and the running config disagreeing.
b.web.ResetConfig = func(ctx context.Context, key string) error {
if b.overlayStore == nil {
return fmt.Errorf("%w: config overlay is disabled", webui.ErrConfigUpdateUnavailable)
}
overrides, err := b.overlayStore.Snapshot(ctx)
if err != nil {
return err
}
delete(overrides, key) // the target overlay state after the reset
doc, err := b.loader.Resolve(cfgPath, overlayPath)
if err != nil {
return fmt.Errorf("%w: %w", webui.ErrConfigUpdateInvalid, err)
}
if len(overrides) > 0 {
if doc, err = b.loader.ApplyOverlay(doc, overrides); err != nil {
return fmt.Errorf("%w: %w", webui.ErrConfigUpdateInvalid, err)
}
}
if err := b.overlayStore.Delete(ctx, key); err != nil {
return err
}
applyModelCatalog(&doc.Config, b.catalog)
b.currentProvenance.Store(&doc.Provenance)
b.publishConfig(doc.Config, doc.Provenance)
b.bootOverlayErr.Store(nil)
log.Info("config key reset to file value", "key", key)
return nil
}
}
// shutdownCapabilityHost returns a cleanup that stops the capability
// host; same Background reasoning as shutdownCuratorRuntime. Defined
// before startServices so the Stop-before-Start ordering stays visible
// in the source layout the contract test reads.
//
//nolint:contextcheck
func shutdownCapabilityHost(capabilityHost *plugin.Host, log *slog.Logger) func() {
return func() {
stopCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := capabilityHost.Stop(stopCtx); err != nil {
log.Error("capability host shutdown", "err", err)
}
}
}
// startServices starts the capability host, daemon and curator runtime,
// then launches the gateways. Optional providers that could not start
// are excluded rather than fatal, so the only way an operator learns
// about one is this loop's log line.
func (b *boot) startServices(ctx context.Context) error {
log := b.log
capabilityHost := b.capabilityHost
b.addCleanup(shutdownCapabilityHost(capabilityHost, log))
if err := b.capabilityHost.Start(ctx); err != nil {
log.Error("capability host startup", "err", err)
return err
}
for _, skipped := range b.providerRegistry.Skipped() {
log.Error("tool provider unavailable; archie is running without its tools",
"provider", skipped.ID, "err", skipped.Err)
}
if err := b.d.Startup(ctx); err != nil {
log.Error("startup", "err", err)
return err
}
if err := b.curatorRuntime.Start(ctx); err != nil {
log.Error("curator runtime startup", "err", err)
}
for _, startGateway := range b.startGateways {
startGateway()
}
return nil
}
// setupBackends wires the optional runtime backends: the NATS client
// and the container pool.
func (b *boot) setupBackends(ctx context.Context) error {
if err := b.connectNATS(ctx); err != nil {
return err
}
b.setupContainers(ctx)
return nil
}
// buildAgentAndWorkflows builds the agent runner and the workflow
// registry it executes.
func (b *boot) buildAgentAndWorkflows(ctx context.Context) error {
if err := b.buildAgentRunner(); err != nil {
return err
}
return b.loadWorkflows(ctx)
}
// shutdownCuratorRuntime returns a cleanup that stops the curator
// runtime. The stop path derives its own timeout budget from Background
// rather than the boot context, which is already cancelled by the time
// shutdown runs.
//
//nolint:contextcheck
func shutdownCuratorRuntime(rt *curator.Runtime, log *slog.Logger) func() {
return func() {
stopCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := rt.Stop(stopCtx); err != nil {
log.Error("curator runtime shutdown", "err", err)
}
}
}
// shutdownCuratorRegistry returns a cleanup that stops the curator
// registry; same Background reasoning as shutdownCuratorRuntime.
//
//nolint:contextcheck
func shutdownCuratorRegistry(reg *curator.Registry, log *slog.Logger) func() {
return func() {
stopCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := reg.Stop(stopCtx); err != nil {
log.Error("curator registry shutdown", "err", err)
}
}
}
// exitCode maps a bootstrap error to the process exit code.
func exitCode(err error) int {
if err != nil {
return 1
}
return 0
}
func (b *boot) runLoop(ctx context.Context, once bool) error {
if once {
b.d.Cycle(ctx)
return nil
}
b.log.Info("archied running", "repos", len(b.cfg.Repos), "poll", b.cfg.PollInterval.Std().String(), "label", b.cfg.Label)
if err := b.d.Run(ctx); err != nil && ctx.Err() == nil {
b.log.Error("daemon exited", "err", err)
return err
}
return nil
}