Files
archie/internal/webui/api_config.go
T
sam 230280a6e0 feat(webui): Models picks from the provider catalog, and enables available providers
archied already finds usable providers (key set in the environment, or
configured) through the model catalog; the published config view now
carries that catalog, providers with their model ids. Settings > Models
offers role models only from configured providers, lists the catalog's
unconfigured providers as available, and adding one carries its class, key
variable and endpoint. Roles and providers are two accordions, each ending
in an add row.
2026-09-25 18:04:46 +10:00

562 lines
22 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"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"
)
// 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
}
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"`
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, 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"`
}
// 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"`
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"`
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).
//
// Editable is not set here. It describes the rendering process's own write
// path, so handleConfig decides it -- see ConfigView.Editable.
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,
},
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,
ReviewEnabled: r.ReviewEnabled,
})
}
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
}