Files
archie/internal/webui/api_config.go
T
sam 5288a8d980 feat(webui): render configuration from a published snapshot
The configuration page had exactly one source: this process's own
config.Holder. The UI process has no holder and is not permitted one, so the
page was empty there and the shared-holder assumption was the thing blocking
the cutover.

GET /api/config now reads a ConfigViewSource. The daemon builds the
projection from the configuration it owns, as before, and publishes that same
document to the State Store on boot and on every republish -- reload, a
dashboard edit, a repository field change -- since those are exactly the
moments it changes. The UI process renders what it reads there and nothing
else; an unknown schema is refused rather than half-rendered, and nothing
published yet is the documented empty response, not an error.

Editable is a property of the process, not of the configuration, so each
source sets it: the daemon holds the update path, the reader does not. The
settings page honours it, rendering values where it would otherwise offer
controls whose PATCH would answer 503 -- the deliberate feature reduction
archie-core-ymut recorded, made visible instead of discovered by clicking.

A failed publish is logged and degrades to a stale page. It must never fail
the reload or the edit that produced the configuration, both of which have
already taken effect.
2026-09-09 23:43:17 +10:00

566 lines
20 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"fmt"
"maps"
"net/http"
"strconv"
"strings"
"github.com/samcharles93/archie-core/internal/channels"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/overlay"
"github.com/samcharles93/archie-core/internal/secret"
"github.com/samcharles93/archie-core/internal/store"
)
// Sentinel errors for handleConfigUpdate status classification. The
// composition root wraps its UpdateConfig errors with these so the
// handler can answer 400 (invalid input) or 503 (unavailable) without
// reaching into infrastructure internals.
var (
// ErrConfigUpdateUnavailable reports that config editing is not
// wired (no UpdateConfig seam, or the overlay is skipped by the
// recovery flag).
ErrConfigUpdateUnavailable = errors.New("config editing unavailable")
// ErrConfigUpdateInvalid reports a rejected update: a denylisted
// key, a failed validation of the materialised config, or an
// unparseable value.
ErrConfigUpdateInvalid = errors.New("config update invalid")
)
// ChannelView is one conversational front-end as shown on the dashboard's
// Channels page: whether it is reachable today, and what configuring it
// would unlock.
type ChannelView struct {
ID string `json:"id"`
Name string `json:"name"`
Configured bool `json:"configured"`
Detail string `json:"detail"`
Description string `json:"description"`
State string `json:"state"`
ReloadSupported bool `json:"reload_supported"`
}
// handleChannels reports how a human can reach Archie today. It exists so
// "how do I talk to this thing" has one answer that does not require
// reading config.toml -- see ChatConfig in internal/config/config.go for
// the fields this derives from.
func (s *Server) handleChannels(w http.ResponseWriter, r *http.Request) {
if s.Channels != nil {
views := make([]ChannelView, 0, len(s.Channels.Snapshot()))
for _, status := range s.Channels.Snapshot() {
views = append(views, channelViewFromStatus(status))
}
writeJSON(w, map[string]any{"channels": views})
return
}
if s.Cfg == nil {
writeJSON(w, map[string]any{"channels": []ChannelView{}})
return
}
chat := s.Cfg.Get().Chat
views := []ChannelView{
telegramChannelView(chat.Telegram),
webhookChannelView(chat.WebhookAddr),
emailChannelView(chat.Email),
}
writeJSON(w, map[string]any{"channels": views})
}
func (s *Server) handleChannelReload(w http.ResponseWriter, r *http.Request) {
if !s.authorizeTaskMutation(w, r) {
return
}
id := r.PathValue("id")
if s.Channels == nil || s.ReloadChannel == nil {
http.Error(w, "channel reload unavailable", http.StatusNotImplemented)
return
}
var status *channels.Status
for _, candidate := range s.Channels.Snapshot() {
if candidate.ID == id {
status = &candidate
break
}
}
if status == nil || !status.ReloadSupported {
http.Error(w, "channel does not support reload", http.StatusConflict)
return
}
if err := s.ReloadChannel(r.Context(), id); err != nil {
http.Error(w, "channel reload failed", http.StatusBadGateway)
return
}
writeJSON(w, map[string]any{"ok": true, "channel": id})
}
func channelViewFromStatus(status channels.Status) ChannelView {
view := ChannelView{
ID: status.ID, Name: status.Name, Configured: status.Configured, Detail: status.Detail,
State: string(status.State), ReloadSupported: status.ReloadSupported,
}
switch status.ID {
case "telegram":
view.Description = "Talk to Archie and approve its work from your phone."
case "webhook":
view.Description = "Lets another service push messages to Archie over HTTP."
case "email":
view.Description = "Email Archie a task and receive replies through its inbound SMTP listener."
}
if view.Detail == "" {
view.Detail = channelStateDetail(status.State, status.Configured)
}
return view
}
func channelStateDetail(state channels.State, configured bool) string {
if !configured {
return "Not configured."
}
switch state {
case channels.StateConfigured:
return "Configured; waiting for the daemon to start it."
case channels.StateStarting:
return "Starting."
case channels.StateRunning:
return "Running."
case channels.StateDegraded:
return "Running with a degraded capability."
case channels.StateFailed:
return "Failed to start."
default:
return "Stopped."
}
}
func telegramChannelView(t config.TelegramConfig) ChannelView {
configured := t.Token != (secret.SecretRef{}) || strings.TrimSpace(t.TokenEnv) != ""
detail := "Not configured."
if configured {
n := len(t.AllowedUserIDs)
switch n {
case 0:
detail = "Token set, but the allowlist is empty -- the bot answers nobody."
case 1:
detail = "1 user allowed."
default:
detail = strconv.Itoa(n) + " users allowed."
}
}
return ChannelView{
ID: "telegram",
Name: "Telegram",
Configured: configured,
Detail: detail,
Description: "Talk to Archie and approve its work from your phone.",
State: string(channels.StateConfigured),
ReloadSupported: true,
}
}
func webhookChannelView(addr string) ChannelView {
configured := strings.TrimSpace(addr) != ""
detail := "Not configured."
if configured {
detail = "Listening for inbound chat requests."
}
return ChannelView{
ID: "webhook",
Name: "Webhook gateway",
Configured: configured,
Detail: detail,
Description: "Lets another service (e.g. a Telegram webhook, a custom front-end) push messages to Archie over HTTP instead of long-polling.",
State: staticChannelState(configured),
}
}
func emailChannelView(e config.EmailConfig) ChannelView {
configured := strings.TrimSpace(e.ListenAddr) != ""
detail := "Not configured."
if configured {
detail = "Archie accepts inbound mail and can reply through the configured relay."
}
return ChannelView{
ID: "email",
Name: "Email",
Configured: configured,
Detail: detail,
Description: "Email Archie a task and it replies from its own inbound SMTP listener.",
State: staticChannelState(configured),
}
}
func staticChannelState(configured bool) string {
if configured {
return string(channels.StateConfigured)
}
return string(channels.StateStopped)
}
// ConfigView is the read-only, secret-free projection of config.Config
// shown on the dashboard's Configuration page. Every field here is an
// explicit, hand-picked allowlist -- see handleConfig for why this is
// built field by field rather than by marshalling config.Config directly.
type ConfigView struct {
Identity IdentityView `json:"identity"`
Repositories []RepoView `json:"repositories"`
Models map[string]string `json:"models"`
Providers map[string]ProviderView `json:"providers"`
Budgets BudgetsView `json:"budgets"`
Storage StorageView `json:"storage"`
Containers ContainersView `json:"containers"`
Web WebView `json:"web"`
Provenance []ConfigOrigin `json:"provenance"`
// Reload reports the most recent config reload outcome. Omitted when
// the reload status is unavailable.
Reload *config.ReloadStatus `json:"reload,omitempty"`
// Locked maps dotted config keys that cannot be changed from the
// dashboard to the reason. The UI renders these rows disabled rather
// than silently omitting the edit affordance.
Locked map[string]string `json:"locked,omitempty"`
// Overridden lists the dotted config keys currently set by the
// runtime overlay, so the UI can mark those rows (their file value
// is shadowed until reset) and offer a per-row reset.
Overridden []string `json:"overridden,omitempty"`
// Editable reports whether this process can apply configuration
// changes. False makes the page render values without edit controls,
// which is what a process that only displays a published snapshot can
// honestly offer -- its write routes answer 503.
Editable bool `json:"editable"`
// Schema is the field-descriptor catalog (archie-core-b6ew) attached to
// this view's own values, locked reasons, and overridden markers -- see
// config_schema.go. The dashboard's generic renderer (archie-core-b6ew.3)
// reads this instead of the flat fields above to decide labels,
// sections, types, and editability; the flat fields stay for existing
// consumers (structured cards, provenance, reload/lock plumbing) rather
// than being removed in the same change that adds their replacement.
Schema []ConfigSection `json:"schema"`
}
// IdentityView is who Archie is on the forge -- never the token that
// authenticates as that identity.
type IdentityView struct {
BotUser string `json:"bot_user"`
BotEmail string `json:"bot_email"`
Label string `json:"label"`
ForgeType string `json:"forge_type"`
ForgeHost string `json:"forge_host"`
DiffCapLines int `json:"diff_cap_lines"`
}
// RepoView is one managed repository and the quality gate it must pass.
// Gate and Preflight are shell command argv lists -- test runners and
// linters, not secrets -- so they are safe to show verbatim.
type RepoView struct {
Owner string `json:"owner"`
Name string `json:"name"`
Base string `json:"base"`
Gate [][]string `json:"gate"`
Protect []string `json:"protect"`
Ecosystem string `json:"ecosystem"`
PersistentStorage bool `json:"persistent_storage"`
AllowConcurrent bool `json:"allow_concurrent"`
MaxRetries int `json:"max_retries"`
ReviewEnabled bool `json:"review_enabled"`
}
// ProviderView is an LLM provider's shape, never its key. APIKeyEnv is the
// name of an environment variable, not a value, so it is safe to show;
// Configured reports whether either credential form (env or secret engine)
// is actually set, without revealing which or what.
type ProviderView struct {
Class string `json:"class"`
BaseURL string `json:"base_url,omitempty"`
APIKeyEnv string `json:"api_key_env,omitempty"`
Configured bool `json:"configured"`
}
// BudgetsView mirrors config.Budgets, none of which is secret.
type BudgetsView struct {
MaxSteps int `json:"max_steps"`
WallClock string `json:"wall_clock"`
GateMaxFailures int `json:"gate_max_failures"`
}
// StorageView is where archied keeps its state on disk. All paths, no
// secrets.
type StorageView struct {
WorkDir string `json:"work_dir"`
DBPath string `json:"db_path"`
SkillsDir string `json:"skills_dir,omitempty"`
PluginDir string `json:"plugin_dir,omitempty"`
SecretEngineDir string `json:"secret_engine_dir,omitempty"`
}
// ContainersView is how sandboxed task execution is configured.
type ContainersView struct {
Image string `json:"image,omitempty"`
MaxConcurrency int `json:"max_concurrency"`
MaxUptime string `json:"max_uptime"`
VolumeTTL string `json:"volume_ttl"`
PullPolicy string `json:"pull_policy"`
Network string `json:"network,omitempty"`
}
// WebView is the dashboard's own listen address and proxy header trust settings.
type WebView struct {
Listen string `json:"listen"`
TrustForwardedHeaders bool `json:"trust_forwarded_headers"`
}
// handleConfig returns a read-only, secret-free view of the running
// configuration.
//
// This handler builds ConfigView field by field from an explicit allowlist
// rather than marshalling config.Config and stripping fields afterward:
// config.Config carries secret.SecretRef values (forge tokens, provider API
// keys) and there is no way to guarantee a strip-after-marshal approach
// keeps working as fields are added to Config in the future. An allowlist
// fails safe -- a new secret field added upstream is simply absent here
// until someone deliberately adds it.
// ConfigViewSchema names the projection's shape. It travels with a published
// snapshot so a reader can refuse a document it does not understand, and it
// changes when ConfigView's JSON shape changes incompatibly.
const ConfigViewSchema = "webui.ConfigView/1"
// ConfigViewSource supplies the configuration projection the page renders.
// The process that owns configuration builds it; a process that only displays
// configuration reads the published snapshot instead. found is false when no
// configuration is available to render, which the handler answers with an
// empty object rather than an error.
type ConfigViewSource func(ctx context.Context) (ConfigView, bool, error)
func (s *Server) configSource() ConfigViewSource {
if s.ConfigSource != nil {
return s.ConfigSource
}
return s.LocalConfigView
}
func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
view, found, err := s.configSource()(r.Context())
if err != nil {
s.logf("config view unavailable", "err", err)
http.Error(w, "configuration is unavailable", http.StatusServiceUnavailable)
return
}
if !found {
writeJSON(w, map[string]any{})
return
}
writeJSON(w, view)
}
// LocalConfigView builds the projection from the configuration this process
// holds. It is what the daemon serves and, byte for byte, what it publishes
// for the UI process to render (see store.ConfigSnapshot).
//
// Every value here is read from one config snapshot taken up front: under the
// Holder a reload swaps the whole value, which is what a read-only view
// always wanted.
func (s *Server) LocalConfigView(ctx context.Context) (ConfigView, bool, error) {
if s.Cfg == nil {
return ConfigView{}, false, nil
}
cfg := s.Cfg.Get()
var provenance []ConfigOrigin
if p := s.ConfigProvenance.Load(); p != nil {
provenance = append([]ConfigOrigin(nil), (*p)...)
}
view := ConfigView{
Identity: IdentityView{
BotUser: cfg.BotUser,
BotEmail: cfg.BotEmail,
Label: cfg.Label,
ForgeType: cfg.Forge.Type,
ForgeHost: cfg.Forge.Host,
DiffCapLines: cfg.DiffCapLines,
},
Repositories: reposView(cfg.Repos),
Models: cfg.Models,
Providers: providersView(cfg.Providers),
Budgets: BudgetsView{
MaxSteps: cfg.Budgets.MaxSteps,
WallClock: cfg.Budgets.WallClock.Std().String(),
GateMaxFailures: cfg.Budgets.GateMaxFailures,
},
Storage: StorageView{
WorkDir: cfg.WorkDir,
DBPath: cfg.DBPath,
SkillsDir: cfg.SkillsDir,
PluginDir: cfg.PluginDir,
SecretEngineDir: cfg.SecretEngineDir,
},
Containers: ContainersView{
Image: cfg.Containers.Image,
MaxConcurrency: cfg.Containers.MaxConcurrency,
MaxUptime: cfg.Containers.MaxUptime.Std().String(),
VolumeTTL: cfg.Containers.VolumeTTL.Std().String(),
PullPolicy: cfg.Containers.PullPolicy,
Network: cfg.Containers.Network,
},
Web: WebView{
Listen: cfg.Web.Listen,
TrustForwardedHeaders: cfg.Web.TrustForwardedHeaders,
},
Provenance: provenance,
Locked: lockedConfigKeys(),
// Editable is a property of this process, not of the
// configuration, so it is set by the source rather than carried
// in a published document: the writer is whoever holds the
// update path.
Editable: s.UpdateConfig != nil,
}
if s.ConfigOverrides != nil {
if overridden, err := s.ConfigOverrides(ctx); err == nil {
view.Overridden = overridden
}
// A failed read omits the list rather than failing the whole
// view; the reload status carries the overlay degrade reason.
}
if s.LastReload != nil {
rs := s.LastReload()
view.Reload = &rs
}
view.Schema = buildConfigSchema(view)
return view, true, nil
}
// RemoteConfigView reads the projection the configuration owner published.
// The reading process cannot edit it: it has no update path, and the page is
// told so rather than offering a control that would 503.
func RemoteConfigView(snapshots store.ConfigSnapshotStore) ConfigViewSource {
return func(ctx context.Context) (ConfigView, bool, error) {
snapshot, found, err := snapshots.ConfigSnapshot(ctx)
if err != nil || !found {
return ConfigView{}, false, err
}
if snapshot.Schema != ConfigViewSchema {
return ConfigView{}, false, fmt.Errorf("webui: published config snapshot has schema %q, want %q", snapshot.Schema, ConfigViewSchema)
}
var view ConfigView
if err := json.Unmarshal(snapshot.Document, &view); err != nil {
return ConfigView{}, false, fmt.Errorf("webui: decode published config snapshot: %w", err)
}
view.Editable = false
return view, true, nil
}
}
// handleConfigReset deletes one runtime-overlay row via ResetConfig,
// restoring the file value for that key. The dashboard offers this on
// overridden rows so it can remove an override it created.
func (s *Server) handleConfigReset(w http.ResponseWriter, r *http.Request) {
if s.ResetConfig == nil {
http.Error(w, ErrConfigUpdateUnavailable.Error(), http.StatusServiceUnavailable)
return
}
var body struct {
Key string `json:"key"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
http.Error(w, "invalid request body: "+err.Error(), http.StatusBadRequest)
return
}
if body.Key == "" {
http.Error(w, "key required", http.StatusBadRequest)
return
}
if err := s.ResetConfig(r.Context(), body.Key); err != nil {
switch {
case errors.Is(err, ErrConfigUpdateUnavailable):
http.Error(w, err.Error(), http.StatusServiceUnavailable)
case errors.Is(err, ErrConfigUpdateInvalid):
http.Error(w, err.Error(), http.StatusBadRequest)
default:
http.Error(w, "config reset failed: "+err.Error(), http.StatusInternalServerError)
}
return
}
writeJSON(w, map[string]any{"ok": true})
}
// lockedConfigKeys returns the dotted config keys the overlay refuses
// to set, with the reason shown in the UI. These are the daemon's own
// bootstrap inputs; changing them from the dashboard could break the
// next boot.
func lockedConfigKeys() map[string]string {
out := make(map[string]string, len(overlay.DeniedKeys))
maps.Copy(out, overlay.DeniedKeys)
return out
}
// handleConfigUpdate applies a set of dotted-path config updates via
// UpdateConfig, which the composition root wires to the same
// validate-persist-publish path as reload. The dashboard can then
// change runtime-tunable settings without hand-editing TOML.
func (s *Server) handleConfigUpdate(w http.ResponseWriter, r *http.Request) {
if s.UpdateConfig == nil {
http.Error(w, ErrConfigUpdateUnavailable.Error(), http.StatusServiceUnavailable)
return
}
var body struct {
Updates map[string]any `json:"updates"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
http.Error(w, "invalid request body: "+err.Error(), http.StatusBadRequest)
return
}
if len(body.Updates) == 0 {
http.Error(w, "no updates provided", http.StatusBadRequest)
return
}
if err := s.UpdateConfig(r.Context(), body.Updates); err != nil {
switch {
case errors.Is(err, ErrConfigUpdateUnavailable):
http.Error(w, err.Error(), http.StatusServiceUnavailable)
case errors.Is(err, ErrConfigUpdateInvalid):
http.Error(w, err.Error(), http.StatusBadRequest)
default:
http.Error(w, "config update failed: "+err.Error(), http.StatusInternalServerError)
}
return
}
writeJSON(w, map[string]any{"ok": true})
}
func reposView(repos []config.Repo) []RepoView {
out := make([]RepoView, 0, len(repos))
for _, r := range repos {
out = append(out, RepoView{
Owner: r.Owner,
Name: r.Name,
Base: r.BaseBranch(),
Gate: r.Gate,
Protect: r.Protect,
Ecosystem: r.Ecosystem,
PersistentStorage: r.PersistentStorage,
AllowConcurrent: r.AllowConcurrent,
MaxRetries: r.MaxRetries,
ReviewEnabled: r.ReviewEnabled,
})
}
return out
}
func providersView(providers map[string]config.Provider) map[string]ProviderView {
out := make(map[string]ProviderView, len(providers))
for name, p := range providers {
out[name] = ProviderView{
Class: p.Class,
BaseURL: p.BaseURL,
APIKeyEnv: p.APIKeyEnv,
Configured: strings.TrimSpace(p.APIKeyEnv) != "" || strings.TrimSpace(p.APIKey.Key) != "",
}
}
return out
}