Files
archie/internal/webui/api_workflows.go
T
sam 924b02a1b0 feat(controlplane): runtime administration over the State Store's gRPC server
The Web UI and messaging channels now read and write Archie's runtime
settings through one versioned, audited control-plane API hosted on the
State Store's existing gRPC server: catalog, query, command, watch. Each
feature owns its resource, validation and commands; storage only writes
versions and audit records.

Workflows move with it. Definitions become portable YAML compiled through
a closed, typed step registry and stored as a control-plane resource, so
the yaegi interpretation paths (internal/gate, wfeval, wfextract,
gateeval, gateextract, skillbuild) are deleted rather than carried.

The UI process reads definitions as data: the JSON projection lives in
internal/domain/workflow/task so a dashboard decodes the stored
collection without linking the workflow engine, which cmd/archie-ui's
deletion gate forbids. Shipped definitions ride the catalog descriptor
rather than a bespoke REST route, keeping the API to its four operations.

archie-messaging gains -state-store-target/-state-store-token and reads
channel settings from the database, failing closed when the State Store
is unreachable: the database is authoritative for those settings.
2026-09-21 08:17:42 +10:00

143 lines
4.7 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"strings"
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
)
const workflowDefinitionsKind = "workflow-definitions"
// handleWorkflows returns per-workflow and per-stage statistics: run counts,
// outcome breakdowns and spend per workflow, plus duration and failure counts
// per stage -- "where does it get stuck" for the workflows page.
func (s *Server) handleWorkflows(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
workflows, err := s.Store.WorkflowStats(ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
stages, err := s.Store.StageStats(ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
definitions, err := s.workflowDefinitions(ctx)
if err != nil {
http.Error(w, "workflow definitions unavailable", http.StatusServiceUnavailable)
return
}
writeJSON(w, map[string]any{
"workflows": workflows,
"stages": stages,
"definitions": definitions,
})
}
type workRequest struct {
Identity string `json:"identity"`
Repository string `json:"repository"`
Workflow string `json:"workflow"`
Title string `json:"title"`
Instructions string `json:"instructions"`
}
func (s *Server) handleWorkRequest(w http.ResponseWriter, r *http.Request) {
if !s.authorizeTaskMutation(w, r) {
return
}
if s.WorkRequests == nil {
http.Error(w, "work intake unavailable", http.StatusServiceUnavailable)
return
}
r.Body = http.MaxBytesReader(w, r.Body, 32<<10)
var request workRequest
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&request); err != nil {
if _, ok := errors.AsType[*http.MaxBytesError](err); ok {
http.Error(w, "work request body too large", http.StatusRequestEntityTooLarge)
return
}
http.Error(w, "invalid work request", http.StatusBadRequest)
return
}
if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
http.Error(w, "invalid work request", http.StatusBadRequest)
return
}
request.Identity = strings.TrimSpace(request.Identity)
request.Repository = strings.TrimSpace(request.Repository)
request.Workflow = strings.TrimSpace(request.Workflow)
request.Title = strings.TrimSpace(request.Title)
request.Instructions = strings.TrimSpace(request.Instructions)
if request.Identity == "" || request.Repository == "" || request.Workflow == "" || request.Title == "" || request.Instructions == "" {
http.Error(w, "identity, repository, workflow, title, and instructions are required", http.StatusBadRequest)
return
}
available, err := s.hasWorkflow(r.Context(), request.Workflow)
if err != nil {
http.Error(w, "workflow definitions unavailable", http.StatusServiceUnavailable)
return
}
if !available {
http.Error(w, "workflow is not enabled", http.StatusConflict)
return
}
taskID, err := s.WorkRequests.CreateTask(r.Context(), messaging.SpawnRequest{
Identity: request.Identity, Repo: request.Repository, Workflow: request.Workflow,
Title: request.Title, Body: request.Instructions,
})
if err != nil {
http.Error(w, "work request rejected", http.StatusBadRequest)
return
}
s.emit(r.Context(), events.Event{Kind: events.KindWorkRequestSubmitted, TaskID: taskID, Repo: request.Repository, Workflow: request.Workflow, Detail: request.Title})
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]any{"ok": true, "task_id": taskID})
}
func (s *Server) hasWorkflow(ctx context.Context, id string) (bool, error) {
definitions, err := s.workflowDefinitions(ctx)
if err != nil {
return false, err
}
for _, definition := range definitions {
if definition.ID == id {
return true, nil
}
}
return false, nil
}
func (s *Server) workflowDefinitions(ctx context.Context) ([]task.Definition, error) {
if s.ControlPlane == nil {
return nil, nil
}
response, err := s.ControlPlane.Query(ctx, &controlpb.QueryRequest{Kind: workflowDefinitionsKind})
if err != nil {
return nil, err
}
if response.Resource == nil {
return nil, errors.New("workflow definitions missing")
}
var collection task.WorkflowDefinitionCollection
if err := json.Unmarshal(response.Resource.ValueJson, &collection); err != nil {
return nil, err
}
definitions := make([]task.Definition, 0, len(collection.Definitions))
for _, entry := range collection.Definitions {
definitions = append(definitions, task.Definition{ID: entry.ID, Name: entry.ID, Origin: "database", Enabled: true})
}
return definitions, nil
}