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/access" "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/infrastructure/configuration" "github.com/samcharles93/archie-core/internal/secret" ) // 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(r.Context()))) for _, status := range s.Channels.Snapshot(r.Context()) { 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(r.Context()) { 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 = "Chat and approvals." 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 daemon's secret-free snapshot for dashboard handlers. // Only catalog and reload are exposed by /api/config. type ConfigView struct { SecretEngines []secret.EngineInfo `json:"secret_engines"` Identity IdentityView `json:"identity"` Repositories []ForgeRepoView `json:"repositories"` Chat ChatView `json:"chat"` Catalog []CatalogProviderView `json:"catalog"` Reload *config.ReloadStatus `json:"reload,omitempty"` MultiIdentity bool `json:"multi_identity,omitempty"` Identities []ForgeIdentityView `json:"identities,omitempty"` } // IdentityView supplies setup and task forge coordinates. type IdentityView struct { BotUser string `json:"bot_user"` ForgeType string `json:"forge_type"` ForgeHost string `json:"forge_host"` } // 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 an identity's repositories. type ForgeIdentityView struct { Name string `json:"name"` Repos []ForgeRepoView `json:"repos,omitempty"` } // 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"` } // ConfigViewSchema names ConfigView's JSON shape; it changes on incompatible // changes. const ConfigViewSchema = "webui.ConfigView/1" // ConfigViewSource supplies the configuration view. found is false when there // is none. 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, struct { Catalog []CatalogProviderView `json:"catalog"` Reload *config.ReloadStatus `json:"reload,omitempty"` Bootstrap map[string]string `json:"bootstrap"` }{Catalog: view.Catalog, Reload: view.Reload, Bootstrap: maps.Clone(configuration.DeniedKeys)}) } // 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 { SecretEngines []secret.EngineInfo // 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 // 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 secret-free configuration view from an explicit // allowlist of fields. func BuildConfigView(in ConfigViewInput) ConfigView { cfg := in.Config return ConfigView{ SecretEngines: append([]secret.EngineInfo{}, in.SecretEngines...), Identity: IdentityView{BotUser: cfg.BotUser, ForgeType: cfg.Forge.Type, ForgeHost: cfg.Forge.Host}, Repositories: reposView(cfg.Repos), MultiIdentity: len(cfg.Identities) > 0, Identities: identityForgesView(cfg.Identities), Catalog: append([]CatalogProviderView{}, in.Catalog...), Chat: ChatView{ShowToolCalls: cfg.Chat.ShowToolCalls, Operator: strings.TrimSpace(cfg.Chat.Operator), ChannelConfigured: chatChannelConfigured(cfg.Chat)}, Reload: in.Reload, } } // chatChannelConfigured reports whether any chat front-end is configured. 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(ctx context.Context) []status.Status } // RemoteChannelStatus reads channel state from the State Store; unreachable // reports none. func RemoteChannelStatus(channels storecontract.ChannelStatusStore) ChannelStatusSource { return remoteChannelStatus{channels: channels} } type remoteChannelStatus struct { channels storecontract.ChannelStatusStore } func (r remoteChannelStatus) Snapshot(ctx context.Context) []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(ctx) 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) { // The published config is instance state: the dashboard reads it as // itself, and each handler decides what of it a caller may see. snapshot, found, err := snapshots.ConfigSnapshot(access.WithoutPrincipal(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 } } func reposView(repos []config.Repo) []ForgeRepoView { out := make([]ForgeRepoView, 0, len(repos)) for _, r := range repos { out = append(out, ForgeRepoView{Owner: r.Owner, Name: r.Name}) } return out } // identityForgesView returns each identity's repository names. 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, Repos: repos}) } return out }