Files
archie/internal/webui/api_config.go
T
sam 3a65fd2ee1 feat(controlplane): add the writable review-settings resource
review.precision_gate and review.approve_before_post were file-only, so the
dashboard had no way to write them: no control-plane resource carried them.
Add the review-settings kind (docs/prds/review-settings-resource.md), seed it
from the file's [review] section, layer it field-by-field into cfg.Review,
watch it live, and publish it through ConfigView.Review. The dashboard gets a
Review settings page bound to the kind through PAGE_RESOURCES, showing each
dial beside the value in force.
2026-10-02 11:08:44 +10:00

558 lines
21 KiB
Go

package webui
import (
"context"
"encoding/json"
"fmt"
"maps"
"net/http"
"strings"
"github.com/samcharles93/archie-core/internal/channels/status"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
)
// 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
}
writeJSON(w, map[string]any{"channels": []ChannelView{}})
}
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 *status.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 status.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 status.State, configured bool) string {
if !configured {
return "Not configured."
}
switch state {
case status.StateConfigured:
return "Configured; waiting for the daemon to start it."
case status.StateStarting:
return "Starting."
case status.StateRunning:
return "Running."
case status.StateDegraded:
return "Running with a degraded capability."
case status.StateFailed:
return "Failed to start."
default:
return "Stopped."
}
}
// 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"`
// Review is the layered pr-review policy: what a review may post, and
// whether a human decides. It is a plain projection of the effective
// cfg.Review, so the published snapshot tells a reader which dials are in
// force (docs/prds/review-settings-resource.md).
Review ReviewView `json:"review"`
Storage StorageView `json:"storage"`
Containers ContainersView `json:"containers"`
Web WebView `json:"web"`
// Chat carries the dashboard's own chat-page settings. They are
// daemon configuration the page cannot otherwise see: a process that
// renders a published snapshot has no [chat] section to read.
Chat ChatView `json:"chat"`
// Catalog lists the providers the model catalog found usable (their key
// is set in the environment, or they are configured), with their models,
// so Settings can offer to enable one and pick role models from it.
Catalog []CatalogProviderView `json:"catalog"`
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"`
// MultiIdentity reports that the deployment configures [[identities]],
// so Identity and Repositories describe the default identity alone.
// Identities below carries the rest; a consumer attributing a task to
// its forge reads that, and a document that sets this flag without
// carrying them (one published by an older daemon) must withhold the
// links rather than guess.
MultiIdentity bool `json:"multi_identity,omitempty"`
// Identities publishes each configured identity's forge and the
// repositories it owns, which is everything a process rendering task
// rows needs to answer "which forge owns this task" -- see
// Server.resolveForge (api_tasks.go). Empty for a single-identity
// deployment, whose forge is Identity above.
Identities []ForgeIdentityView `json:"identities,omitempty"`
// Schema is the field-descriptor catalog (archie-core-b6ew) attached to
// this view's own values and locked reasons -- see config_schema.go. It
// carries the labels, sections and types a generic configuration renderer
// needs, instead of making each rendering process hardcode them; 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"`
}
// ForgeRepoView names one repository an identity owns. Owner and name are
// all a reader needs to attribute a task to the identity that polls it, so
// that is all this carries.
type ForgeRepoView struct {
Owner string `json:"owner"`
Name string `json:"name"`
}
// ForgeIdentityView is one configured identity's forge coordinates plus the
// repositories it owns. It is deliberately narrower than IdentityView and
// RepoView: the task board needs to locate a repository, not to render the
// configuration page, and an identity's token -- or any of its other
// settings -- must not travel to the browser for either purpose.
type ForgeIdentityView struct {
Name string `json:"name"`
ForgeType string `json:"forge_type"`
ForgeHost string `json:"forge_host"`
Repos []ForgeRepoView `json:"repos,omitempty"`
}
// 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"`
}
// 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"`
}
// ReviewView mirrors config.Review, neither field of which is secret. It
// carries the value in force after the review-settings resource is layered over
// the file's [review] section.
type ReviewView struct {
PrecisionGate bool `json:"precision_gate"`
ApproveBeforePost bool `json:"approve_before_post"`
}
// StorageView is where archied keeps its state on disk. All paths, no
// secrets.
type StorageView struct {
WorkDir string `json:"work_dir"`
StateDir string `json:"state_dir"`
DatabaseURL string `json:"database_url"`
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.
// ChatView carries the chat page's own settings and the facts the setup
// checklist needs. Secret-free by construction: whether a channel has
// credentials, never the credentials.
type ChatView struct {
ShowToolCalls bool `json:"show_tool_calls"`
// Operator is the name the dashboard greets, configured once in
// [chat]. Empty when unset, which the page renders as no greeting
// rather than a hardcoded name.
Operator string `json:"operator,omitempty"`
// ChannelConfigured reports that at least one conversational
// front-end has credentials.
ChannelConfigured bool `json:"channel_configured"`
}
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 config.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)
// configSource returns the projection source, or an empty one when
// composition wired none: this process then renders no configuration rather
// than inventing any.
func (s *Server) configSource() ConfigViewSource {
if s.ConfigSource != nil {
return s.ConfigSource
}
return func(context.Context) (ConfigView, bool, error) { return ConfigView{}, false, nil }
}
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)
}
// ConfigViewInput is everything BuildConfigView needs. The configuration
// owner assembles it: the config snapshot plus the display data it holds
// alongside, already resolved, so building the view is pure and cannot fail.
type ConfigViewInput struct {
// Config is one snapshot, read once. Under a Holder a reload swaps the
// whole value, which is what a read-only view always wanted.
Config config.Config
// Provenance is the file chain that produced Config, in precedence
// order.
Provenance []ConfigOrigin
// Reload is the most recent reload outcome, or nil when unavailable.
Reload *config.ReloadStatus
// Catalog is the usable-provider catalog the configuration owner loaded.
Catalog []CatalogProviderView
}
// CatalogProviderView is one usable provider from the model catalog. It
// names the environment variable its key was found in, never the key.
type CatalogProviderView struct {
ID string `json:"id"`
Name string `json:"name"`
Class string `json:"class"`
APIKeyEnv string `json:"api_key_env,omitempty"`
BaseURL string `json:"base_url,omitempty"`
Models []string `json:"models"`
}
// BuildConfigView renders the dashboard's secret-free configuration
// projection. The configuration owner calls it -- the daemon publishes the
// result as a snapshot (storecontract.ConfigSnapshot) and a process that only
// displays configuration reads that snapshot back through RemoteConfigView.
//
// It is deliberately a function, not a method: rendering the view is not a
// property of an HTTP server, and the process that owns configuration is not
// the process that serves this page (archie-core-ml30).
func BuildConfigView(in ConfigViewInput) ConfigView {
cfg := in.Config
provenance := append([]ConfigOrigin(nil), in.Provenance...)
view := ConfigView{
Identity: IdentityView{
BotUser: cfg.BotUser,
BotEmail: cfg.BotEmail,
Label: cfg.Label,
ForgeType: cfg.Forge.Type,
ForgeHost: cfg.Forge.Host,
DiffCapLines: cfg.DiffCap(),
},
Repositories: reposView(cfg.Repos),
MultiIdentity: len(cfg.Identities) > 0,
Identities: identityForgesView(cfg.Identities),
Models: cfg.Models,
Providers: providersView(cfg.Providers),
Budgets: BudgetsView{
MaxSteps: cfg.Budgets.MaxSteps,
WallClock: cfg.Budgets.WallClock.Std().String(),
GateMaxFailures: cfg.Budgets.GateMaxFailures,
},
Review: ReviewView{
PrecisionGate: cfg.Review.PrecisionGate,
ApproveBeforePost: cfg.Review.ApproveBeforePost,
},
Storage: StorageView{
WorkDir: cfg.WorkDir,
StateDir: cfg.StateDir,
DatabaseURL: cfg.DatabaseURL,
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,
},
Catalog: append([]CatalogProviderView{}, in.Catalog...),
Chat: ChatView{
ShowToolCalls: cfg.Chat.ShowToolCalls,
Operator: strings.TrimSpace(cfg.Chat.Operator),
ChannelConfigured: chatChannelConfigured(cfg.Chat),
},
Provenance: provenance,
Reload: in.Reload,
Locked: lockedConfigKeys(),
}
view.Schema = buildConfigSchema(view)
return view
}
// chatChannelConfigured reports whether any conversational front-end is
// configured. The setup checklist needs the answer, not the tokens, so the
// projection carries the boolean.
//
// The definition lives in config.ChatConfig.FrontEnds, not here: the daemon's
// channel status manager answers the same question on /api/channels, and
// deciding it twice is how the two answers drifted apart (GitHub #821).
func chatChannelConfigured(chat config.ChatConfig) bool {
return chat.AnyFrontEndConfigured()
}
// 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.
// ChannelStatusSource reports the live state of each configured channel.
type ChannelStatusSource interface {
Snapshot() []status.Status
}
// RemoteChannelStatus reads channel state from the State Store, where the
// process hosting the channels publishes it. It is the reader half of the same
// split RemoteConfigView serves: the writer is another process and the reader is
// this one, so a reader that cannot reach the store reports nothing rather than
// inventing a state, and the page shows no channels instead of wrong ones.
func RemoteChannelStatus(channels storecontract.ChannelStatusStore) ChannelStatusSource {
return remoteChannelStatus{channels: channels}
}
type remoteChannelStatus struct {
channels storecontract.ChannelStatusStore
}
func (r remoteChannelStatus) Snapshot() []status.Status {
// The handler has no error to return, so a failed read is an empty report.
// That is the honest answer: the dashboard must not show a stale "running"
// for a channel it cannot currently ask about.
rows, err := r.channels.ChannelStatus(context.Background())
if err != nil {
return nil
}
out := make([]status.Status, 0, len(rows))
for _, row := range rows {
out = append(out, status.Status{
ID: row.ID,
Name: row.Name,
Configured: row.Configured,
ReloadSupported: row.ReloadSupported,
Detail: row.Detail,
State: status.State(row.State),
})
}
return out
}
func RemoteConfigView(snapshots storecontract.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)
}
return view, true, nil
}
}
// lockedConfigKeys returns the dotted config keys that stay bootstrap-owned,
// with the reason shown in the UI. These are the daemon's own startup inputs,
// which the control plane deliberately does not manage.
func lockedConfigKeys() map[string]string {
out := make(map[string]string, len(configuration.DeniedKeys))
maps.Copy(out, configuration.DeniedKeys)
return out
}
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,
})
}
return out
}
// identityForgesView renders each configured identity's forge coordinates and
// the repositories it owns. This is the half of a multi-identity deployment's
// configuration the task board needs: a process that holds no configuration
// answers "which forge owns this task" from here (api_tasks.go's
// resolveForge). Only the coordinates and the repository names cross -- an
// identity's token is a secret reference and must not, and nothing else on
// IdentityConfig is needed to locate a repository.
func identityForgesView(identities []config.IdentityConfig) []ForgeIdentityView {
out := make([]ForgeIdentityView, 0, len(identities))
for _, id := range identities {
repos := make([]ForgeRepoView, 0, len(id.Repos))
for _, r := range id.Repos {
repos = append(repos, ForgeRepoView{Owner: r.Owner, Name: r.Name})
}
out = append(out, ForgeIdentityView{
Name: id.Name,
ForgeType: id.Forge.Type,
ForgeHost: id.Forge.Host,
Repos: repos,
})
}
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
}