The configuration page had exactly one source: this process's own config.Holder. The UI process has no holder and is not permitted one, so the page was empty there and the shared-holder assumption was the thing blocking the cutover. GET /api/config now reads a ConfigViewSource. The daemon builds the projection from the configuration it owns, as before, and publishes that same document to the State Store on boot and on every republish -- reload, a dashboard edit, a repository field change -- since those are exactly the moments it changes. The UI process renders what it reads there and nothing else; an unknown schema is refused rather than half-rendered, and nothing published yet is the documented empty response, not an error. Editable is a property of the process, not of the configuration, so each source sets it: the daemon holds the update path, the reader does not. The settings page honours it, rendering values where it would otherwise offer controls whose PATCH would answer 503 -- the deliberate feature reduction archie-core-ymut recorded, made visible instead of discovered by clicking. A failed publish is logged and degrades to a stale page. It must never fail the reload or the edit that produced the configuration, both of which have already taken effect.
566 lines
20 KiB
Go
566 lines
20 KiB
Go
package webui
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"maps"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/channels"
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/overlay"
|
|
"github.com/samcharles93/archie-core/internal/secret"
|
|
"github.com/samcharles93/archie-core/internal/store"
|
|
)
|
|
|
|
// 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
|
|
}
|
|
if s.Cfg == nil {
|
|
writeJSON(w, map[string]any{"channels": []ChannelView{}})
|
|
return
|
|
}
|
|
|
|
chat := s.Cfg.Get().Chat
|
|
views := []ChannelView{
|
|
telegramChannelView(chat.Telegram),
|
|
webhookChannelView(chat.WebhookAddr),
|
|
emailChannelView(chat.Email),
|
|
}
|
|
|
|
writeJSON(w, map[string]any{"channels": views})
|
|
}
|
|
|
|
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 *channels.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 channels.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 channels.State, configured bool) string {
|
|
if !configured {
|
|
return "Not configured."
|
|
}
|
|
switch state {
|
|
case channels.StateConfigured:
|
|
return "Configured; waiting for the daemon to start it."
|
|
case channels.StateStarting:
|
|
return "Starting."
|
|
case channels.StateRunning:
|
|
return "Running."
|
|
case channels.StateDegraded:
|
|
return "Running with a degraded capability."
|
|
case channels.StateFailed:
|
|
return "Failed to start."
|
|
default:
|
|
return "Stopped."
|
|
}
|
|
}
|
|
|
|
func telegramChannelView(t config.TelegramConfig) ChannelView {
|
|
configured := t.Token != (secret.SecretRef{}) || strings.TrimSpace(t.TokenEnv) != ""
|
|
detail := "Not configured."
|
|
if configured {
|
|
n := len(t.AllowedUserIDs)
|
|
switch n {
|
|
case 0:
|
|
detail = "Token set, but the allowlist is empty -- the bot answers nobody."
|
|
case 1:
|
|
detail = "1 user allowed."
|
|
default:
|
|
detail = strconv.Itoa(n) + " users allowed."
|
|
}
|
|
}
|
|
return ChannelView{
|
|
ID: "telegram",
|
|
Name: "Telegram",
|
|
Configured: configured,
|
|
Detail: detail,
|
|
Description: "Talk to Archie and approve its work from your phone.",
|
|
State: string(channels.StateConfigured),
|
|
ReloadSupported: true,
|
|
}
|
|
}
|
|
|
|
func webhookChannelView(addr string) ChannelView {
|
|
configured := strings.TrimSpace(addr) != ""
|
|
detail := "Not configured."
|
|
if configured {
|
|
detail = "Listening for inbound chat requests."
|
|
}
|
|
return ChannelView{
|
|
ID: "webhook",
|
|
Name: "Webhook gateway",
|
|
Configured: configured,
|
|
Detail: detail,
|
|
Description: "Lets another service (e.g. a Telegram webhook, a custom front-end) push messages to Archie over HTTP instead of long-polling.",
|
|
State: staticChannelState(configured),
|
|
}
|
|
}
|
|
|
|
func emailChannelView(e config.EmailConfig) ChannelView {
|
|
configured := strings.TrimSpace(e.ListenAddr) != ""
|
|
detail := "Not configured."
|
|
if configured {
|
|
detail = "Archie accepts inbound mail and can reply through the configured relay."
|
|
}
|
|
return ChannelView{
|
|
ID: "email",
|
|
Name: "Email",
|
|
Configured: configured,
|
|
Detail: detail,
|
|
Description: "Email Archie a task and it replies from its own inbound SMTP listener.",
|
|
State: staticChannelState(configured),
|
|
}
|
|
}
|
|
|
|
func staticChannelState(configured bool) string {
|
|
if configured {
|
|
return string(channels.StateConfigured)
|
|
}
|
|
return string(channels.StateStopped)
|
|
}
|
|
|
|
// 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"`
|
|
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"`
|
|
// Overridden lists the dotted config keys currently set by the
|
|
// runtime overlay, so the UI can mark those rows (their file value
|
|
// is shadowed until reset) and offer a per-row reset.
|
|
Overridden []string `json:"overridden,omitempty"`
|
|
// Editable reports whether this process can apply configuration
|
|
// changes. False makes the page render values without edit controls,
|
|
// which is what a process that only displays a published snapshot can
|
|
// honestly offer -- its write routes answer 503.
|
|
Editable bool `json:"editable"`
|
|
// 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"`
|
|
}
|
|
|
|
// 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"`
|
|
DBPath string `json:"db_path"`
|
|
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.
|
|
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 secret.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)
|
|
|
|
func (s *Server) configSource() ConfigViewSource {
|
|
if s.ConfigSource != nil {
|
|
return s.ConfigSource
|
|
}
|
|
return s.LocalConfigView
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
// LocalConfigView builds the projection from the configuration this process
|
|
// holds. It is what the daemon serves and, byte for byte, what it publishes
|
|
// for the UI process to render (see store.ConfigSnapshot).
|
|
//
|
|
// Every value here is read from one config snapshot taken up front: under the
|
|
// Holder a reload swaps the whole value, which is what a read-only view
|
|
// always wanted.
|
|
func (s *Server) LocalConfigView(ctx context.Context) (ConfigView, bool, error) {
|
|
if s.Cfg == nil {
|
|
return ConfigView{}, false, nil
|
|
}
|
|
cfg := s.Cfg.Get()
|
|
|
|
var provenance []ConfigOrigin
|
|
if p := s.ConfigProvenance.Load(); p != nil {
|
|
provenance = append([]ConfigOrigin(nil), (*p)...)
|
|
}
|
|
|
|
view := ConfigView{
|
|
Identity: IdentityView{
|
|
BotUser: cfg.BotUser,
|
|
BotEmail: cfg.BotEmail,
|
|
Label: cfg.Label,
|
|
ForgeType: cfg.Forge.Type,
|
|
ForgeHost: cfg.Forge.Host,
|
|
DiffCapLines: cfg.DiffCapLines,
|
|
},
|
|
Repositories: reposView(cfg.Repos),
|
|
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,
|
|
DBPath: cfg.DBPath,
|
|
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,
|
|
},
|
|
Provenance: provenance,
|
|
Locked: lockedConfigKeys(),
|
|
// Editable is a property of this process, not of the
|
|
// configuration, so it is set by the source rather than carried
|
|
// in a published document: the writer is whoever holds the
|
|
// update path.
|
|
Editable: s.UpdateConfig != nil,
|
|
}
|
|
if s.ConfigOverrides != nil {
|
|
if overridden, err := s.ConfigOverrides(ctx); err == nil {
|
|
view.Overridden = overridden
|
|
}
|
|
// A failed read omits the list rather than failing the whole
|
|
// view; the reload status carries the overlay degrade reason.
|
|
}
|
|
if s.LastReload != nil {
|
|
rs := s.LastReload()
|
|
view.Reload = &rs
|
|
}
|
|
view.Schema = buildConfigSchema(view)
|
|
return view, true, nil
|
|
}
|
|
|
|
// 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.
|
|
func RemoteConfigView(snapshots store.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)
|
|
}
|
|
view.Editable = false
|
|
return view, true, nil
|
|
}
|
|
}
|
|
|
|
// handleConfigReset deletes one runtime-overlay row via ResetConfig,
|
|
// restoring the file value for that key. The dashboard offers this on
|
|
// overridden rows so it can remove an override it created.
|
|
func (s *Server) handleConfigReset(w http.ResponseWriter, r *http.Request) {
|
|
if s.ResetConfig == nil {
|
|
http.Error(w, ErrConfigUpdateUnavailable.Error(), http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
var body struct {
|
|
Key string `json:"key"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
http.Error(w, "invalid request body: "+err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
if body.Key == "" {
|
|
http.Error(w, "key required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err := s.ResetConfig(r.Context(), body.Key); err != nil {
|
|
switch {
|
|
case errors.Is(err, ErrConfigUpdateUnavailable):
|
|
http.Error(w, err.Error(), http.StatusServiceUnavailable)
|
|
case errors.Is(err, ErrConfigUpdateInvalid):
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
default:
|
|
http.Error(w, "config reset failed: "+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return
|
|
}
|
|
writeJSON(w, map[string]any{"ok": true})
|
|
}
|
|
|
|
// lockedConfigKeys returns the dotted config keys the overlay refuses
|
|
// to set, with the reason shown in the UI. These are the daemon's own
|
|
// bootstrap inputs; changing them from the dashboard could break the
|
|
// next boot.
|
|
func lockedConfigKeys() map[string]string {
|
|
out := make(map[string]string, len(overlay.DeniedKeys))
|
|
maps.Copy(out, overlay.DeniedKeys)
|
|
return out
|
|
}
|
|
|
|
// handleConfigUpdate applies a set of dotted-path config updates via
|
|
// UpdateConfig, which the composition root wires to the same
|
|
// validate-persist-publish path as reload. The dashboard can then
|
|
// change runtime-tunable settings without hand-editing TOML.
|
|
func (s *Server) handleConfigUpdate(w http.ResponseWriter, r *http.Request) {
|
|
if s.UpdateConfig == nil {
|
|
http.Error(w, ErrConfigUpdateUnavailable.Error(), http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
var body struct {
|
|
Updates map[string]any `json:"updates"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
http.Error(w, "invalid request body: "+err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
if len(body.Updates) == 0 {
|
|
http.Error(w, "no updates provided", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err := s.UpdateConfig(r.Context(), body.Updates); err != nil {
|
|
switch {
|
|
case errors.Is(err, ErrConfigUpdateUnavailable):
|
|
http.Error(w, err.Error(), http.StatusServiceUnavailable)
|
|
case errors.Is(err, ErrConfigUpdateInvalid):
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
default:
|
|
http.Error(w, "config update failed: "+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return
|
|
}
|
|
writeJSON(w, map[string]any{"ok": true})
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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
|
|
}
|