Files
archie/internal/webui/api_setup.go
T
sam 19062a702d refactor(webui): take configuration off the dashboard server
webui.Server declared Cfg *config.Holder with eight read sites, none of
which ran in the UI process: composition leaves it nil there. The field
survived because the daemon kept a webui.Server it never served, using it
to render the published ConfigView snapshot and to hold the readiness
probes (archie-core-ml30).

Split at the producer. LocalConfigView becomes webui.BuildConfigView, a
pure function over a ConfigViewInput the configuration owner assembles;
the DTO and its schema stay where the UI renders them. The daemon builds
that input from its own state (boot.configViewInput) and publishes the
result. Readiness reads the daemon's Holder, channel manager and chat
contract, and the registry it produces is a daemon field, not a field on
a server with no listener. Boot now owns one Holder instead of seeding a
second and replacing it in buildDaemon; operator retry caps read it too,
so they follow a reload rather than a boot-time snapshot.

Server loses Cfg, ConfigProvenance, LastReload, ConfigOverrides and
SetProvenance. The nil-guarded branches they fed went with them, each
checked first against what the UI process actually serves:

- chat.show_tool_calls and the /api/setup checklist were degraded, not
  dead. ConfigView gains a chat section carrying show_tool_calls, the
  operator name and whether a channel is configured, and both surfaces
  read the projection. The end-to-end suite asserts the checklist renders
  from the published snapshot.
- /api/logs takes its path as a process-local option. The history is on
  the daemon's disk, so a dashboard elsewhere cannot read it by learning
  the path; that route still needs a contract.
- handleChannels drops its config-derived fallback, superseded by the
  status manager, which already carries the descriptions and detail.
- trustForwardedHeaders keeps only the process's own setting, which the
  UI process already sets.
- resolveForge keeps the published-projection path it already had.

ConfigView.Editable moves to handleConfig, decided by whether this
process holds UpdateConfig. It describes the writer, not the document, so
the write contract (archie-core-j28m) makes the page editable by wiring
one field. The write handlers and their seams stay for it.

overlay.Store gains Keys: Snapshot nests dotted keys for decoding, so the
overridden-key list was publishing section names ("budgets") where the
dashboard marks and resets rows by stored key ("budgets.max_steps").

Multi-identity forge links move to archie-core-pv6t: forgeConfigForTask
resolved a task's forge from config.Config, had no reachable caller once
the holder was gone, and belongs in the projection rather than the
rendering package.
2026-09-11 23:57:38 +10:00

77 lines
2.4 KiB
Go

package webui
import (
"net/http"
"strings"
)
// SetupStep is one item in the dashboard's getting-started checklist.
type SetupStep struct {
Title string `json:"title"`
Detail string `json:"detail,omitempty"`
Done bool `json:"done"`
}
// handleSetup reports which parts of archied are configured.
//
// The checklist exists so a new operator is told what is missing rather than
// shown a dashboard of zeroes and left to infer it. Steps are phrased as
// actions in plain language -- "Connect a chat channel", not "channels.telegram
// .bot_token unset" -- because someone who already knows the config key does
// not need the checklist.
//
// Every step is derived from live state, so the list disappears on its own
// once setup is complete rather than needing to be dismissed.
func (s *Server) handleSetup(w http.ResponseWriter, r *http.Request) {
steps := []SetupStep{}
// Every step is read from the configuration projection this process
// renders, so the checklist works the same whether configuration is
// held here or published by its owner.
view, found, err := s.configSource()(r.Context())
if err != nil || !found {
// No configuration available: report nothing rather than
// guessing, so the dashboard simply omits the panel.
writeJSON(w, map[string]any{"steps": steps})
return
}
// The operator's name is deployment data, configured once in [chat]. The
// dashboard greets with it rather than hardcoding a name, which would be
// wrong on every deployment but one.
operator := view.Chat.Operator
steps = append(steps, SetupStep{
Title: "Give Archie an identity",
Detail: "The account it commits and comments as.",
Done: strings.TrimSpace(view.Identity.BotUser) != "",
})
steps = append(steps, SetupStep{
Title: "Connect a repository",
Detail: "Archie polls these for issues assigned to it.",
Done: len(view.Repositories) > 0,
})
steps = append(steps, SetupStep{
Title: "Connect a chat channel",
Detail: "Talk to Archie and approve its work from your phone.",
Done: view.Chat.ChannelConfigured,
})
// Only meaningful once there is somewhere to run work.
if count, err := s.Store.StatusCounts(r.Context()); err == nil {
total := 0
for _, n := range count {
total += n
}
steps = append(steps, SetupStep{
Title: "Run your first task",
Detail: "Assign Archie an issue, or ask it for something in chat.",
Done: total > 0,
})
}
writeJSON(w, map[string]any{"steps": steps, "operator": operator})
}