Files
archie/internal/webui/server.go
T
sam 31fdbddd61 fix(config): complete the reloadable allowlist and pin it against ForTask
The allowlist drifted before the chunk shipped. ForTask (config.go:457-465)
is the authoritative per-dispatch snapshot and carries Models, Budgets,
Dispatch, DiffCapLines, Notify and Forge.Host -- I allowlisted only three.
And the poll path reads cfg.Label and cfg.BotUser live per cycle
(daemon.go:359,390 and :368,381) off the same per-poll config as
Dispatch.Trigger. Five fields would have reported 'requires a restart'
while actually taking effect immediately: the safe direction, but exactly
the warning-fatigue failure that kills the feature (an operator who is
told to restart for a label change that already applied learns the
warning is noise).

The fix is enforcement, not a bigger list: TestReloadableFieldsCoverForTaskSnapshot
reflects over TaskConfig and fails if any field ForTask carries is not in
the allowlist (Forge maps to the Forge.Host sub-field entry). A field
added to ForTask later now fails the test instead of silently producing a
wrong warning. Label and BotUser are not carried by ForTask -- they come
off the poll path -- so they are allowlisted by hand with a comment, and
the same test pins them explicitly.

Also documents on webui.Server.Cfg that in production it is the daemon's
OWN Holder (web.Cfg = d.Cfg), so Set publishes to the running daemon: a
config-mutating handler must apply to a copy, validate the materialised
config, persist, then Set -- never Set directly.

task check clean.
2026-08-10 00:47:30 +10:00

242 lines
9.2 KiB
Go

// Package webui is archied's dashboard: a control room over the daemon's
// task board, activity stream and configuration.
//
// The Go side owns serving and the JSON API only; the frontend lives in the
// repo-root ui/ package, which exposes the built assets as an embedded FS.
// Handlers are split by concern -- one file per API area -- so a section can
// be added without growing a single file without end.
package webui
import (
"context"
"encoding/json"
"io/fs"
"log/slog"
"net/http"
"sync"
"sync/atomic"
"time"
"github.com/samcharles93/archie-core/internal/channels"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/memory"
"github.com/samcharles93/archie-core/internal/store"
"github.com/samcharles93/archie-core/ui"
)
type Server struct {
Store store.TaskStore
Log *slog.Logger
// Cfg backs the setup checklist and configuration views. Optional: the
// dashboard degrades to task data alone when it is nil. Held through a
// Holder so a reload swaps the snapshot atomically across handler
// goroutines that would otherwise race on the raw shared pointer.
//
// In production this is the daemon's OWN Holder (main.go wires
// web.Cfg = d.Cfg), so Set here publishes to the running daemon. A
// config-mutating handler must never call Set directly: it goes
// through the same path as reload -- apply to a copy, validate the
// materialised config, persist, then Set.
Cfg *config.Holder
// Workflows is the executable registry snapshot supplied by composition.
Workflows []workflow.Definition
// WorkRequests admits dashboard requests through the same task-creation
// boundary used by chat; it never invokes a workflow runner directly.
WorkRequests gateway.TaskCreator
// LogFeed is the daemon diagnostic stream. It is separate from Events,
// which contains persisted task lifecycle activity only.
LogFeed *logging.Feed
// TaskLogs holds each task's persisted log output. Archiving a task
// removes its log files here too, via TaskLogs.Remove -- nil (task
// logging not configured) makes that a no-op.
TaskLogs *logging.TaskRegistry
// ConfigProvenance lists the files that produced the running config,
// in precedence order. Held through atomic.Pointer so a reload can
// swap it independently of Cfg. A reader may therefore observe the
// new config alongside the old provenance (or vice versa); this is
// display-only, and the skew is accepted rather than serialised.
ConfigProvenance atomic.Pointer[[]ConfigOrigin]
// LastReload reports the most recent config reload outcome, so the
// dashboard can tell the operator when the running config is stale
// (a reload failed validation and the daemon kept the previous
// config). Optional: when nil, the /api/config response omits the
// reload status.
LastReload func() config.ReloadStatus
// Channels reports actual adapter lifecycle, independently of configuration
// presence. Nil preserves the configuration-only fallback for tests and
// minimal embedding.
Channels *channels.Manager
// ReloadChannel invokes a channel-specific reload seam. Only adapters that
// explicitly support reload are wired here; nil means reload is unavailable.
ReloadChannel func(context.Context, string) error
// Memory backs the memory view. Optional: the section reports memory as
// unavailable rather than failing when it is nil.
Memory *memory.Manager
// Chat exposes the same gateway router used by the conversational
// channels. Optional: the dashboard simply omits chat when it is nil.
Chat *ChatService
// Token gates access. Empty means no check, which is how loopback binds
// stay frictionless -- see IsLoopback.
Token string
// Issues closes the forge issue behind a rejected task. Optional: the
// action still records the operator's decision without it, and says so
// in the log. Deliberately the narrowest interface that does the job
// rather than the whole forge client -- the dashboard has no business
// commenting, labelling or opening PRs.
Issues IssueCloser
// Events publishes operator actions so they reach the task timeline and
// the live activity stream. Optional: nil means the action is recorded
// in the store but invisible to anyone watching.
Events EventPublisher
// TaskStopper reaches work that is actually executing. A store row cannot
// stop a goroutine or container; the daemon supplies this narrow runtime
// seam so the Stop action cancels work before parking its task record.
TaskStopper TaskStopper
mu sync.Mutex
conns map[chan events.Event]struct{}
}
// ConfigOrigin explains one source file contributing to the effective
// configuration. Sources are ordered from lowest to highest precedence.
type ConfigOrigin struct {
Path string `json:"path"`
Role string `json:"role"`
Layer string `json:"layer"`
Feature string `json:"feature,omitempty"`
}
// SetProvenance publishes a fresh provenance list after a config reload.
func (s *Server) SetProvenance(origins []ConfigOrigin) {
s.ConfigProvenance.Store(&origins)
}
// IssueCloser closes the forge issue behind a task.
type IssueCloser interface {
CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error
}
// EventPublisher accepts events for the store and the live stream. The bus
// in cmd/archied satisfies it.
type EventPublisher interface {
Publish(events.Event)
}
// TaskStopper interrupts one task currently executing in the daemon.
type TaskStopper interface {
CancelTask(taskID int64) bool
}
// Broadcast fans an (ID-stamped) event out to every connected SSE
// client; stalled clients drop events rather than blocking the caller.
func (s *Server) Broadcast(e events.Event) {
s.mu.Lock()
defer s.mu.Unlock()
for c := range s.conns {
select {
case c <- e:
default:
}
}
}
func (s *Server) Handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /api/summary", s.handleSummary)
mux.HandleFunc("GET /api/setup", s.handleSetup)
mux.HandleFunc("GET /api/tasks", s.handleTasks)
mux.HandleFunc("POST /api/tasks/{id}/action", s.handleTaskAction)
mux.HandleFunc("GET /api/tasks/{id}", s.handleTask)
mux.HandleFunc("GET /api/workflows", s.handleWorkflows)
mux.HandleFunc("POST /api/work-requests", s.handleWorkRequest)
mux.HandleFunc("GET /api/skills", s.handleSkills)
mux.HandleFunc("GET /api/channels", s.handleChannels)
mux.HandleFunc("POST /api/channels/{id}/reload", s.handleChannelReload)
mux.HandleFunc("GET /api/config", s.handleConfig)
mux.HandleFunc("GET /api/logs", s.handleLogs)
mux.HandleFunc("GET /api/tasks/{id}/logs", s.handleTaskLogs)
mux.HandleFunc("GET /api/logs/stream", s.handleLogStream)
mux.HandleFunc("GET /api/memory", s.handleMemory)
mux.HandleFunc("GET /api/chat/sessions", s.handleChatSessions)
mux.HandleFunc("GET /api/chat/sessions/{id}/messages", s.handleChatMessages)
mux.HandleFunc("POST /api/chat/message", s.handleChatMessage)
mux.HandleFunc("POST /api/chat/stream", s.handleChatStream)
mux.HandleFunc("POST /api/chat/cancel", s.handleChatCancel)
mux.HandleFunc("POST /api/chat/persona", s.handleChatPersona)
mux.HandleFunc("GET /api/chat/update", s.handleChatUpdate)
mux.HandleFunc("POST /api/chat/update/defer", s.handleChatUpdateDefer)
mux.HandleFunc("POST /api/chat/update/install", s.handleChatUpdateInstall)
mux.HandleFunc("GET /api/chat/dangerous", s.handleChatDangerousState)
mux.HandleFunc("POST /api/chat/dangerous/{kind}", s.handleChatDangerousRequest)
mux.HandleFunc("POST /api/chat/dangerous/{id}/decision", s.handleChatDangerousDecision)
mux.HandleFunc("GET /events", s.handleSSE)
mux.Handle("GET /", s.assets())
return s.requireToken(mux)
}
// assets serves the embedded dashboard, falling back to index.html so client
// routes deep-link correctly. Under the no_ui build tag the assets are absent
// and a plain explanation is served instead of a confusing 404.
func (s *Server) assets() http.Handler {
if ui.DistDirFS == nil {
return http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
http.Error(w, "dashboard not built into this binary (no_ui)", http.StatusNotFound)
})
}
files := http.FileServerFS(ui.DistDirFS)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if _, err := fs.Stat(ui.DistDirFS, trimLeadingSlash(r.URL.Path)); err != nil {
r = r.Clone(r.Context())
r.URL.Path = "/"
}
files.ServeHTTP(w, r)
})
}
func trimLeadingSlash(p string) string {
if len(p) > 0 && p[0] == '/' {
return p[1:]
}
if p == "" {
return "."
}
return p
}
// Run serves until ctx ends.
func (s *Server) Run(ctx context.Context, listen string) error {
srv := &http.Server{Addr: listen, Handler: s.Handler(), ReadHeaderTimeout: 5 * time.Second}
go func() {
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 2*time.Second)
defer cancel()
_ = srv.Shutdown(shutdownCtx)
}()
s.Log.Info("web ui listening", "addr", "http://"+listen)
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
return err
}
return nil
}
func writeJSON(w http.ResponseWriter, v any) {
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(v)
}