Files
archie/internal/webui/api_setup.go
T
sam 812d9004a7
Quality / check (push) Successful in 4m40s
deploy / gate (push) Successful in 6m15s
deploy / archied-image (push) Successful in 2m57s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
feat(webui): keep the Model setup step open until the provider credential resolves (#1045)
2026-10-31 20:04:06 +11:00

231 lines
8.7 KiB
Go

package webui
import (
"context"
"encoding/json"
"fmt"
"maps"
"net/http"
"slices"
"strings"
"github.com/samcharles93/archie-core/internal/config"
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// SetupStep is one item in the dashboard's getting-started checklist. Path is
// the page that owns the configuration the step is about, so an operator can
// follow the step to where it is fixed rather than guess a settings page.
type SetupStep struct {
Title string `json:"title"`
Detail string `json:"detail,omitempty"`
Done bool `json:"done"`
Path string `json:"path,omitempty"`
}
// ModelReader reads the model aliases the calling principal's org may use.
type ModelReader interface {
CallerModels(ctx context.Context) (org string, aliases map[string]string, err error)
}
// The control-plane resources the effective-model read layers: the org's own
// providers and the credential bindings that carry their keys. Spelled here
// rather than imported so the dashboard package stays a leaf, as
// api_harness.go does for "credential-bindings".
const (
providerSettingsKind = "provider-settings"
credentialBindingsKind = "credential-bindings"
)
// providerDoc is the part of one provider-settings entry the read needs: where
// the provider's key comes from.
type providerDoc struct {
Class string `json:"class"`
APIKeyEnv string `json:"api_key_env,omitempty"`
APIKeyRef config.SecretRef `json:"api_key_ref"`
}
// credentialBindingDoc is the part of one credential-bindings entry the read
// needs: the org secret the service's key resolves through.
type credentialBindingDoc struct {
Service string `json:"service"`
Secret config.SecretRef `json:"secret"`
}
// effectiveModel is one model alias the caller's org may use, with the state
// of the provider credential it runs on. An alias whose provider's credential
// is missing or does not resolve cannot run a task, so the Model setup step
// stays open and names it.
type effectiveModel struct {
Alias string
Model string
Provider string
// Credential reports that the provider's credential is present and
// resolves; Detail names what is missing when it does not.
Credential bool
Detail string
}
// handleSetup reports which setup steps are still missing in the caller's
// organisation, from live state. Optional capabilities (a chat channel, a
// repository) are set up where they are used, not listed here.
func (s *Server) handleSetup(w http.ResponseWriter, r *http.Request) {
steps := []SetupStep{}
if s.Store == nil {
writeJSON(w, map[string]any{"steps": steps})
return
}
if done, ok := s.hasActiveAgent(r); ok {
steps = append(steps, SetupStep{Title: "Agent identity", Done: done, Path: "/org/agents"})
}
if count, err := s.Store.StatusCounts(r.Context()); err == nil {
total := 0
for _, n := range count {
total += n
}
steps = append(steps, SetupStep{Title: "First task", Done: total > 0, Path: "/tasks"})
}
if s.Models != nil {
// Shown only while the org has no runnable model, so a working setup
// carries no extra step: an alias whose provider credential does not
// resolve is no more runnable than no alias at all.
if models, err := s.callerEffectiveModels(r.Context()); err == nil {
if step, open := modelSetupStep(models); open {
steps = append(steps, step)
}
}
}
writeJSON(w, map[string]any{"steps": steps})
}
// modelSetupStep is the Model checklist step for the caller's effective
// models. The step stays open until every alias's provider credential
// resolves; its detail names the credential that does not.
func modelSetupStep(models []effectiveModel) (SetupStep, bool) {
if len(models) == 0 {
return SetupStep{Title: "Model", Path: "/org/models", Detail: "no model alias configured"}, true
}
for _, model := range models {
if !model.Credential {
return SetupStep{Title: "Model", Path: "/org/models", Detail: model.Detail}, true
}
}
return SetupStep{}, false
}
// callerEffectiveModels reads the caller's effective models: the aliases the
// org may use, each with the validity of the provider credential it runs on.
// The credential surfaces are optional; without them the read reports the
// aliases alone with every credential taken as valid.
func (s *Server) callerEffectiveModels(ctx context.Context) ([]effectiveModel, error) {
_, aliases, err := s.Models.CallerModels(ctx)
if err != nil {
return nil, err
}
models := make([]effectiveModel, 0, len(aliases))
for _, alias := range slices.Sorted(maps.Keys(aliases)) {
provider, _, _ := strings.Cut(aliases[alias], "/")
models = append(models, effectiveModel{Alias: alias, Model: aliases[alias], Provider: provider, Credential: true})
}
if s.ControlPlane == nil || s.CheckSecret == nil || len(models) == 0 {
return models, nil
}
orgID := string(org.OrgFromContext(ctx))
var providers map[string]providerDoc
if err := s.queryResourceValue(ctx, providerSettingsKind, &providers); err != nil {
return nil, err
}
if providers == nil {
providers = map[string]providerDoc{}
}
var bindings []credentialBindingDoc
if err := s.queryResourceValue(ctx, credentialBindingsKind, &bindings); err != nil {
return nil, err
}
for i := range models {
models[i].Credential, models[i].Detail = s.providerCredential(ctx, orgID, models[i].Provider, providers, bindings)
}
return models, nil
}
// queryResourceValue decodes one control-plane resource of the caller's org
// into into; an absent resource leaves into untouched.
func (s *Server) queryResourceValue(ctx context.Context, kind string, into any) error {
response, err := s.ControlPlane.Query(ctx, &controlpb.QueryRequest{Kind: kind})
if err != nil {
return err
}
if response.Resource == nil || len(response.Resource.ValueJson) == 0 {
return nil
}
return json.Unmarshal(response.Resource.ValueJson, into)
}
// providerCredential reports whether provider's credential is present and
// resolves for orgID, and names what is missing when it does not. The key
// comes from the provider's own api_key_ref, or from the org's credential
// binding named after the provider, or from its api_key_env; a binding with no
// secret is OAuth, whose credential is the captured token set. A provider
// that is not the org's own and has no binding is an instance provider: its
// credential is the instance admin's, not this org's to configure.
func (s *Server) providerCredential(ctx context.Context, orgID, provider string, providers map[string]providerDoc, bindings []credentialBindingDoc) (bool, string) {
doc, own := providers[provider]
if own && doc.APIKeyRef != (config.SecretRef{}) {
return s.secretCredential(ctx, provider, doc.APIKeyRef)
}
for _, binding := range bindings {
if binding.Service != provider {
continue
}
if binding.Secret != (config.SecretRef{}) {
return s.secretCredential(ctx, provider, binding.Secret)
}
if s.HarnessSecrets != nil {
if token, err := s.HarnessSecrets.GetHarnessSecret(ctx, orgID, provider); err == nil && token.Validate() == nil {
return true, ""
}
return false, fmt.Sprintf("provider %q has no captured sign-in for credential binding %q", provider, provider)
}
return false, fmt.Sprintf("credential binding %q names no secret and no sign-in is captured", provider)
}
if own {
if doc.APIKeyEnv != "" {
return s.secretCredential(ctx, provider, config.SecretRef{Engine: "env", Key: doc.APIKeyEnv})
}
return false, fmt.Sprintf("provider %q declares no credential: set its api_key_ref or add a credential binding named %q", provider, provider)
}
return true, ""
}
// secretCredential reports whether ref resolves through the gateway's secret
// engines, naming the reference when it does not.
func (s *Server) secretCredential(ctx context.Context, provider string, ref config.SecretRef) (bool, string) {
resolved, err := s.CheckSecret(ctx, ref)
if err == nil && resolved {
return true, ""
}
return false, fmt.Sprintf("provider %q credential %s:%s does not resolve", provider, ref.Engine, ref.Key)
}
// hasActiveAgent reports whether the caller's org has an active bot or
// service account assigned; ok is false when that cannot be read.
func (s *Server) hasActiveAgent(r *http.Request) (done, ok bool) {
reader, isReader := s.Orgs.(org.AgentAssignments)
if !isReader || s.Identities == nil {
return false, false
}
assignments, err := reader.ListOrgAgents(r.Context(), policyOrg(r))
if err != nil {
return false, false
}
for _, assignment := range assignments {
value, err := s.Identities.Get(r.Context(), assignment.IdentityID)
if err == nil && value.Kind.Agent() && value.Lifecycle == identity.LifecycleActive {
return true, true
}
}
return false, true
}