* fix(postgres): scope OpenPRs to the caller's org A principal-carrying caller read every org's pr_open tasks. The query now honours the request scope; the daemon's unscoped review scan still sees all orgs. Issue: archie-core-kgxw.23 * fix(statestore): serve task logs only to the task's org ReadTaskLog and StreamTaskLogContent took a task ID and read the file with no org check. The State Store's task-log reader now confirms the task is visible under the caller's scope first; unscoped services read as before. Issue: archie-core-kgxw.24 * fix(postgres): scope ListPolicies to the caller's org Every org's policy text reached any principal-carrying caller. A scoped read now sees its own org's policies, plus instance policies when scoped to the system org. The engines and the lockout guard decide for every org, so they read the full chain unscoped: the dashboard engine loads without the request's principal and the guard lifts the caller's scope. Issue: archie-core-kgxw.25 * fix(postgres): scope identity reads to the caller's org ListIdentities and GetIdentity (and its alias fallback) returned every identity to any caller. A caller scoped to an org now sees only that org's members and assigned agents; the system org and unscoped services still see the whole instance. Issue: archie-core-kgxw.26 * fix(postgres): hide instance status from other orgs ListPresence, ListChannelStatus, ListApplyStatus and GetConfigSnapshot answered any org principal with instance-wide state. They now return nothing unless the request is unscoped or scoped to the system org. The dashboard reads the published config as itself, since its handlers project it for callers of every org. Issue: archie-core-kgxw.27 * feat(postgres): assign new agents an org and role at creation A bot or service account created through the API served no org until the next State Store boot granted it one. Create now assigns it to the org the request acts in with the developer role in the same transaction, so it is authorized immediately. Issue: archie-core-kgxw.14 * feat(edastore): create event records in a chosen workspace Sources are created in a workspace of the caller's org, the default one when none is named; event types and bindings take their source's workspace and mappings their event type's, the same rule the org backfill applied. The binding, mapping and event type contracts carry the workspace, the four list endpoints accept ?workspace=, and the Events page has a workspace selector that filters every step and picks where a new source goes. Issue: archie-core-kgxw.11 * feat(webui): authorize a record in its workspace The API built every access request with no workspace, so workspace policies and per-workspace roles never applied. A request naming a source, binding, mapping, event type or task now reads the record's workspace under the caller's scope and authorizes in it; tasks carry their workspace on the State Store contract for this. Issue: archie-core-kgxw.9 * feat(access): expose workspace environment to policies Policies can test resource.workspace.environment. The workspace attribute is the workspace entity, which carries its environment; the principal brings its org's workspaces from the State Store, so the dashboard and the daemon's run checks describe a resource's workspace without another lookup, and the daemon now authorizes runs in the task's or binding's workspace. Issue: archie-core-kgxw.10 * fix(webui): ask read_secret when a source secret is read Rotating a source's secret returns its value, but the route asked update, which every developer holds, so no policy could narrow who reads a secret. It now asks read_secret on the secret, which the shipped roles give admins and an object policy can narrow further. Issue: archie-core-kgxw.17 * refactor(org): delete the unused upgrade-incomplete sentinel Nothing returns org.ErrUpgradeIncomplete: the State Store finishes the org upgrade before it serves. Issue: archie-core-kgxw.18
336 lines
12 KiB
Go
336 lines
12 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"
|
|
)
|
|
|
|
// 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 "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, review and reload are exposed by /api/config.
|
|
type ConfigView struct {
|
|
Identity IdentityView `json:"identity"`
|
|
Repositories []ForgeRepoView `json:"repositories"`
|
|
Review ReviewView `json:"review"`
|
|
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 forge coordinates and repositories.
|
|
type ForgeIdentityView struct {
|
|
Name string `json:"name"`
|
|
ForgeType string `json:"forge_type"`
|
|
ForgeHost string `json:"forge_host"`
|
|
Repos []ForgeRepoView `json:"repos,omitempty"`
|
|
}
|
|
|
|
// 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"`
|
|
}
|
|
|
|
// 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"`
|
|
Review ReviewView `json:"review"`
|
|
Reload *config.ReloadStatus `json:"reload,omitempty"`
|
|
Bootstrap map[string]string `json:"bootstrap"`
|
|
}{Catalog: view.Catalog, Review: view.Review, 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 {
|
|
// 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{
|
|
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),
|
|
Review: ReviewView{PrecisionGate: cfg.Review.PrecisionGate, ApproveBeforePost: cfg.Review.ApproveBeforePost},
|
|
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() []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() []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) {
|
|
// 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 forge coordinates and
|
|
// 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,
|
|
ForgeType: id.Forge.Type,
|
|
ForgeHost: id.Forge.Host,
|
|
Repos: repos,
|
|
})
|
|
}
|
|
return out
|
|
}
|