Completes the objective deletion gate for the UI Service (archie-core-8cda.5.6): go list -deps ./cmd/archie-ui now links zero banned packages -- no modernc.org/sqlite, no internal/store, gateway, channels, memory, secret, agentexec, tools, skill, yaegiutil, curator, or the workflow engine. The closure shrinks from 68 to 26 archie-core packages. Each cut is a producer-side move; no consumer-side defensive shims. - Store contracts (TaskStore family, value types, sentinels) moved from internal/store to internal/domain/storecontract -- the approved contract location per state-store-contract rev. 2d, and NOT internal/contracts: that tree is buf generate output and tools/proto.sh check deletes hand-written files there. internal/store keeps aliases; sentinel message strings are byte-identical and remain the wire contract. - Chat contracts (ChatContract, sessions, turns, streaming, commands) moved from internal/gateway to internal/domain/messaging; gateway keeps aliases. ToolCallEvent rendering helpers become gateway functions (methods cannot live on alias types). - Task vocabulary (Task, statuses, mid-run Store, Definition) split into internal/domain/workflow/task; the pipeline engine stays in package workflow with aliases, so daemon-side callers are unchanged. - overlay.DeniedKeys moved to internal/infrastructure/configuration: webui referenced the constant and that dragged the overlay SQLite store in. - webui.Server's concrete runtime handles become webui-owned view interfaces with daemon-side bootstrap adapters: channel lifecycle (internal/channels/status), MemoryStatus, CuratorStatus, and a SkillCatalog seam replacing the direct skill.DefaultRoots/CatalogRoots calls. Each degrades to an empty page when unwired. - config.SecretRef moved into internal/config (config vocabulary); internal/secret keeps an alias and Registry.Resolve absorbs the zero-value short-circuit. Docs: state-store-contract rev. 2d relocation record; ui-service-boundary deletion gate marked satisfied; ARCHITECTURE.md package map rows.
394 lines
17 KiB
Go
394 lines
17 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"
|
|
|
|
"github.com/samcharles93/archie-core/internal/channels/status"
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/health"
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
"github.com/samcharles93/archie-core/ui"
|
|
)
|
|
|
|
type Server struct {
|
|
Store storecontract.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
|
|
|
|
// ConfigSource supplies the configuration projection GET /api/config
|
|
// renders. Composition sets it to RemoteConfigView in a process that
|
|
// only displays configuration; unset means this process builds the view
|
|
// from the configuration it holds (LocalConfigView).
|
|
ConfigSource ConfigViewSource
|
|
|
|
// Workflows is the executable registry snapshot supplied by composition.
|
|
Workflows []task.Definition
|
|
// WorkRequests admits dashboard requests through the same task-creation
|
|
// boundary used by chat; it never invokes a workflow runner directly.
|
|
WorkRequests messaging.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
|
|
|
|
// UpdateConfig applies a set of dotted-path config updates through
|
|
// the same validate-persist-publish path as reload (wired by the
|
|
// composition root). Optional: when nil, PATCH /api/config answers
|
|
// 503. The handler never touches the Cfg Holder directly -- see the
|
|
// Cfg field doc.
|
|
UpdateConfig func(context.Context, map[string]any) error
|
|
|
|
// ConfigOverrides lists the dotted config keys currently overridden
|
|
// by the runtime overlay, so the dashboard can mark those rows and
|
|
// offer a reset. Optional: when nil, the /api/config response omits
|
|
// the overridden list.
|
|
ConfigOverrides func(context.Context) ([]string, error)
|
|
|
|
// ResetConfig deletes one runtime-overlay row and republishes file +
|
|
// remaining overlay. Optional: when nil, POST /api/config/reset
|
|
// answers 503. Like UpdateConfig, it never touches the Cfg Holder
|
|
// directly.
|
|
ResetConfig func(context.Context, string) error
|
|
|
|
// UpdateRepoField changes one editable field (RepoEditableFields) on
|
|
// the repository identified by owner/name, republishing the full
|
|
// repository list through the same path as UpdateConfig. Optional:
|
|
// when nil, PATCH /api/config/repos/{owner}/{name} answers 503. See
|
|
// handleConfigRepoUpdate for why this needs its own seam rather than
|
|
// going through UpdateConfig's dotted-key path directly.
|
|
UpdateRepoField func(ctx context.Context, owner, name, field string, value any) error
|
|
|
|
// Channels reports actual adapter lifecycle, independently of configuration
|
|
// presence. Nil preserves the configuration-only fallback for tests and
|
|
// minimal embedding.
|
|
Channels *status.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 MemoryStatus
|
|
// Skills is the webui-owned skill catalogue view; nil degrades
|
|
// /api/skills to an empty page.
|
|
Skills SkillCatalog
|
|
|
|
// Curators is the daemon's live curator registry (epic archie-core-yp9).
|
|
// Backs GET /api/curators: registered names, per-curator health, and
|
|
// recent activity (archie-core-1786637489932-6). Optional: nil reports
|
|
// an empty curator list rather than failing the dashboard.
|
|
Curators CuratorStatus
|
|
|
|
// Chat exposes the Gateway's wire-safe conversational contract. Optional:
|
|
// the dashboard simply omits chat when it is nil.
|
|
Chat *ChatService
|
|
|
|
// Health runs the operator readiness probes served by /health/detailed.
|
|
// Optional: nil answers 503 rather than fabricating a report, so a
|
|
// deployment that has not wired probes never looks healthy by accident.
|
|
Health *health.Registry
|
|
|
|
// Token gates access. Empty means no check, which is how loopback binds
|
|
// stay frictionless -- see IsLoopback.
|
|
Token string
|
|
|
|
// 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
|
|
|
|
// Captures backs the dashboard's read of captured events: the
|
|
// GET /api/captures list and the mapping preview's by-ID scan
|
|
// (docs/prds/event-capture-storage.md). Optional: nil makes the list
|
|
// answer {"enabled": false} rather than the dashboard failing to start.
|
|
Captures storecontract.CaptureStore
|
|
// CaptureMaxEvents is the operator's configured [capture] max_events,
|
|
// used to bound captureByID's scan window (api_mapping.go).
|
|
// CaptureIntake is the write half's mount.
|
|
CaptureMaxEvents int
|
|
// CaptureIntake serves POST /webhooks/capture/{source} on the bypass
|
|
// mux, alongside /healthz: capture must accept unauthenticated
|
|
// senders, so it cannot sit behind requireToken. The handler is owned
|
|
// by internal/infrastructure/captureintake.Receiver; this package only
|
|
// mounts the route and reads the rows back. The UI process composes
|
|
// it from the cutover change (archie-core-8cda.5.4) -- it is the only
|
|
// dashboard listener left, and a capture POST answered by the
|
|
// token-gated mux would leave intake with no owner. Nil removes the
|
|
// route, which is what a store without the capture contract gets:
|
|
// two listeners with the same intake authority is what the boundary
|
|
// forbids (docs/prds/ui-service-boundary.md:30-33).
|
|
CaptureIntake http.Handler
|
|
|
|
// Mappings persists payload field mappings (docs/prds/payload-field-mapping.md).
|
|
// Optional: nil makes every /api/mappings route answer 503 rather than
|
|
// the dashboard failing to start.
|
|
Mappings storecontract.MappingStore
|
|
|
|
// Bindings persists playbook bindings: matcher + mapping + workflow
|
|
// triples that turn a captured webhook into an archie task
|
|
// (docs/prds/webhook-intake-security.md). Optional: nil makes every
|
|
// /api/bindings route answer 503 rather than the dashboard failing to start.
|
|
Bindings storecontract.BindingStore
|
|
|
|
// TelegramUpdateReportPath and TelegramUpdateChatID let a dashboard-
|
|
// initiated update use the same post-restart notification route as a
|
|
// Telegram-initiated update. The web UI has no durable chat identity, so
|
|
// composition supplies an authorized Telegram recipient when one exists.
|
|
// When either value is empty, UpdateReportPath remains in use.
|
|
TelegramUpdateReportPath string
|
|
TelegramUpdateChatID int64
|
|
|
|
// UpdateReportPath is where the update watchdog leaves the phase-2
|
|
// outcome of a dashboard-initiated install for this process to relay on
|
|
// its next boot -- the webui counterpart of
|
|
// channels/telegram.Gateway.UpdateReportPath. Empty (the default unless
|
|
// composition wires it) means dashboard-initiated updates get no
|
|
// phase-2 report (archie-core-nln7): the operator only sees the
|
|
// synchronous install result, never restart/health/version outcome.
|
|
UpdateReportPath string
|
|
|
|
// RunningVersions reports, per component ID (see releaseupdate.Report.Verify),
|
|
// the version that component reports for itself right now. Optional:
|
|
// nil leaves every claim in a relayed update report Unverified rather
|
|
// than Confirmed.
|
|
RunningVersions func() map[string]string
|
|
|
|
// TrustForwardedHeaders controls whether X-Forwarded-Proto and
|
|
// X-Forwarded-Host are trusted when validating Origin on mutating
|
|
// requests. When false, Origin scheme must match the direct connection (r.TLS).
|
|
// When Cfg is present, Cfg.Get().Web.TrustForwardedHeaders is also checked.
|
|
TrustForwardedHeaders bool
|
|
|
|
mu sync.Mutex
|
|
conns map[chan events.Event]struct{}
|
|
}
|
|
|
|
func (s *Server) trustForwardedHeaders() bool {
|
|
if s == nil {
|
|
return false
|
|
}
|
|
if s.TrustForwardedHeaders {
|
|
return true
|
|
}
|
|
if s.Cfg == nil {
|
|
return false
|
|
}
|
|
return s.Cfg.Get().Web.TrustForwardedHeaders
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// EventPublisher accepts events for the store and the live stream. The bus
|
|
// in cmd/archied satisfies it.
|
|
type EventPublisher interface {
|
|
Publish(events.Event)
|
|
}
|
|
|
|
// 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) registerCoreRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("GET /api/summary", s.handleSummary)
|
|
mux.HandleFunc("GET /api/setup", s.handleSetup)
|
|
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/curators", s.handleCurators)
|
|
mux.HandleFunc("GET /api/captures", s.handleCaptures)
|
|
mux.HandleFunc("GET /api/channels", s.handleChannels)
|
|
mux.HandleFunc("POST /api/channels/{id}/reload", s.handleChannelReload)
|
|
mux.HandleFunc("GET /api/version", s.handleVersion)
|
|
mux.HandleFunc("GET /api/memory", s.handleMemory)
|
|
mux.HandleFunc("GET /api/capabilities", s.handleCapabilities)
|
|
}
|
|
|
|
func (s *Server) registerTaskRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("GET /api/tasks", s.handleTasks)
|
|
mux.HandleFunc("GET /api/task-meta", s.handleTaskMeta)
|
|
mux.HandleFunc("POST /api/tasks/{id}/action", s.handleTaskAction)
|
|
mux.HandleFunc("GET /api/tasks/{id}", s.handleTask)
|
|
mux.HandleFunc("GET /api/tasks/{id}/logs", s.handleTaskLogs)
|
|
}
|
|
|
|
func (s *Server) registerMappingAndBindingRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("GET /api/mappings", s.handleMappingsList)
|
|
mux.HandleFunc("POST /api/mappings", s.handleMappingCreate)
|
|
mux.HandleFunc("GET /api/mappings/{id}", s.handleMappingGet)
|
|
mux.HandleFunc("PATCH /api/mappings/{id}", s.handleMappingUpdate)
|
|
mux.HandleFunc("DELETE /api/mappings/{id}", s.handleMappingDelete)
|
|
mux.HandleFunc("POST /api/mappings/preview", s.handleMappingPreview)
|
|
mux.HandleFunc("GET /api/bindings", s.handleBindingsList)
|
|
mux.HandleFunc("POST /api/bindings", s.handleBindingCreate)
|
|
mux.HandleFunc("GET /api/bindings/{id}", s.handleBindingGet)
|
|
mux.HandleFunc("PATCH /api/bindings/{id}", s.handleBindingUpdate)
|
|
mux.HandleFunc("DELETE /api/bindings/{id}", s.handleBindingDelete)
|
|
mux.HandleFunc("POST /api/bindings/{id}/approve", s.handleBindingApprove)
|
|
}
|
|
|
|
func (s *Server) registerConfigAndLogRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("GET /api/config", s.handleConfig)
|
|
mux.HandleFunc("PATCH /api/config", s.handleConfigUpdate)
|
|
mux.HandleFunc("POST /api/config/reset", s.handleConfigReset)
|
|
mux.HandleFunc("PATCH /api/config/repos/{owner}/{name}", s.handleConfigRepoUpdate)
|
|
mux.HandleFunc("GET /api/logs", s.handleLogs)
|
|
mux.HandleFunc("GET /api/logs/stream", s.handleLogStream)
|
|
}
|
|
|
|
func (s *Server) registerChatRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("GET /api/chat/sessions", s.handleChatSessions)
|
|
mux.HandleFunc("GET /api/chat/sessions/{id}/messages", s.handleChatMessages)
|
|
mux.HandleFunc("GET /api/chat/sessions/{id}/turns", s.handleChatTurns)
|
|
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)
|
|
}
|
|
|
|
func (s *Server) Handler() http.Handler {
|
|
mux := http.NewServeMux()
|
|
|
|
s.registerCoreRoutes(mux)
|
|
s.registerTaskRoutes(mux)
|
|
s.registerMappingAndBindingRoutes(mux)
|
|
s.registerConfigAndLogRoutes(mux)
|
|
s.registerChatRoutes(mux)
|
|
|
|
mux.HandleFunc("GET /health/detailed", s.handleHealthDetailed)
|
|
mux.HandleFunc("GET /events", s.handleSSE)
|
|
mux.Handle("GET /", s.assets())
|
|
|
|
top := http.NewServeMux()
|
|
top.HandleFunc("GET /healthz", s.handleHealthz)
|
|
top.HandleFunc("GET /health", s.handleHealth)
|
|
if s.CaptureIntake != nil {
|
|
top.Handle(captureIntakeRoute, s.CaptureIntake)
|
|
}
|
|
top.Handle("/", s.requireToken(mux))
|
|
return top
|
|
}
|
|
|
|
// captureIntakeRoute is the bypass-mux route the host process's capture
|
|
// receiver mounts on. captureintake.Path is the authority for the route's
|
|
// semantics; this literal exists so webui can mount an http.Handler without
|
|
// depending on the receiver's concrete package.
|
|
const captureIntakeRoute = "POST /webhooks/capture/{source}"
|
|
|
|
// handleHealthz is a liveness probe for local, unauthenticated callers --
|
|
// most notably the update watchdog script, which polls it after restarting
|
|
// archied to decide whether the new version came up or the update needs to
|
|
// be rolled back (see scripts/archie-update-watchdog). It deliberately
|
|
// bypasses requireToken: the token protects the dashboard from remote
|
|
// access, not this process's own local restart tooling.
|
|
func (s *Server) handleHealthz(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write([]byte("ok"))
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
func writeJSON(w http.ResponseWriter, v any) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_ = json.NewEncoder(w).Encode(v)
|
|
}
|