313 lines
11 KiB
Go
313 lines
11 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/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"`
|
|
}
|
|
|
|
// 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)},
|
|
Reload: in.Reload,
|
|
}
|
|
}
|
|
|
|
// 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
|
|
}
|