Files
archie/internal/webui/api_workflows.go
T
sam e16f4c8f57 feat(webui): name a workflow's declared inputs on the work-request form
The dashboard could not name a workflow's declared inputs, so POST
/api/work-requests admitted a pr-review task with no pr_number, which then
failed at the workflow's intake stage (archie-core-06nq). The handler now takes
`inputs`, checks it against the workflow's declared interface before admitting
the task, and carries it through SpawnRequest.Inputs -> EnqueueChatTaskRequest;
the form renders one field per declared input, sends a declared number as a
number, and keeps Start disabled while a required input is empty.

Item 2 of the lane brief -- archie-core-afbk.12, review.precision_gate /
review.approve_before_post in the dashboard Config tab -- is deliberately NOT in
this commit. The surface it describes no longer exists in this tree; the
supervisor's decision was to stop it and re-scope it as its own lane, and the
facts it must start from belong in the branch's record:

* The Config-tab components were deleted by becb0b5e (2026-09-25, "the legacy
  config catalog stops advertising fields the control plane owns"): ConfigSections.vue,
  ConfigRow.vue, ConfigControl.vue, ConfigList.vue, ConfigNotices.vue,
  ConfigUnavailable.vue, config-field.ts and sections.ts all went, because no
  page used them. Descriptor entries in internal/webui/config_schema.go would
  therefore change nothing a person can see: the only consumer of GET /api/config
  is SystemModelsPage reading `catalog`; the per-field `schema` has no renderer.
* The config write seams went earlier, in 31622ec5 (2026-09-21, "delete the
  runtime config overlay"): UpdateConfig, ResetConfig and UpdateRepoField are
  gone and internal/webui/server.go serves only GET /api/config. Configuration
  is written through the control plane.
* No control-plane resource carries review settings. executionSettingsDocument
  (internal/app/controlplane/workflow_settings.go) and workflow.ExecutionSettings
  carry only the four budget fields, and runtimeConfigFrom never layers
  cfg.Review. That is exactly why the budget descriptors survive in the catalog
  and review.* cannot: budgets are saved through workflow-execution-settings,
  edited on the Task-execution page, so those entries match a real write path.
* The brief's precedent name is wrong: TestToolSettingsProjectionCarriesEveryMCPServerField
  does not exist. The precedent is TestToolSettingsProjectionCarriesEveryMirroredField
  (internal/app/controlplane/runtime_config_test.go:349).

Making review.* genuinely editable needs a carrying control-plane resource
(extend workflow-execution-settings or add a review-settings kind), a layering
step in internal/app/archied/control_plane.go, and the round-trip test that
precedent sets -- an unsettled design decision spanning packages this lane does
not own.
2026-09-30 04:00:31 +10:00

197 lines
7.1 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/org"
"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"`
// Inputs assigns the inputs the named workflow declares -- pr-review's
// pr_number, for instance. The handler checks the assignment against the
// declaration before the task is admitted, so a request that could only
// fail at the workflow's first stage is refused here instead
// (archie-core-06nq).
Inputs map[string]any `json:"inputs"`
}
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
}
iface, enabled, err := s.enabledWorkflowInterface(r.Context(), request.Workflow)
if err != nil {
http.Error(w, "workflow definitions unavailable", http.StatusServiceUnavailable)
return
}
if !enabled {
http.Error(w, "workflow is not enabled", http.StatusConflict)
return
}
if err := iface.CheckInputs(request.Inputs); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
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, Inputs: request.Inputs,
})
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})
}
// enabledWorkflowInterface returns the interface workflow id declares, and
// whether it is defined and enabled for the default org -- the org every
// dashboard caller acts in until access resolves a caller's own. The interface
// is what the work-request handler checks a request's inputs against, so a task
// whose workflow declaration the request cannot satisfy is refused before it is
// admitted.
func (s *Server) enabledWorkflowInterface(ctx context.Context, id string) (task.WorkflowInterface, bool, error) {
entry, found, err := s.workflowEntry(ctx, id)
if err != nil || !found {
return task.WorkflowInterface{}, false, err
}
enablement, _, err := s.workflowEnablement(ctx)
if err != nil || !enablement.Enabled(org.DefaultOrgID, id) {
return task.WorkflowInterface{}, false, err
}
iface, err := task.ParseWorkflowInterface(entry.YAML)
if err != nil {
return task.WorkflowInterface{}, false, err
}
return iface, true, nil
}
func (s *Server) hasWorkflowDefinition(ctx context.Context, id string) (bool, error) {
_, found, err := s.workflowEntry(ctx, id)
return found, err
}
// workflowEntry returns the stored definition of workflow id.
func (s *Server) workflowEntry(ctx context.Context, id string) (task.WorkflowDefinitionEntry, bool, error) {
collection, err := s.workflowCollection(ctx)
if err != nil {
return task.WorkflowDefinitionEntry{}, false, err
}
entry, found := collection.DefinitionByID(id)
return entry, found, nil
}
func (s *Server) workflowCollection(ctx context.Context) (task.WorkflowDefinitionCollection, error) {
if s.ControlPlane == nil {
return task.WorkflowDefinitionCollection{}, nil
}
response, err := s.ControlPlane.Query(ctx, &controlpb.QueryRequest{Kind: workflowDefinitionsKind})
if err != nil {
return task.WorkflowDefinitionCollection{}, err
}
if response.Resource == nil {
return task.WorkflowDefinitionCollection{}, errors.New("workflow definitions missing")
}
var collection task.WorkflowDefinitionCollection
if err := json.Unmarshal(response.Resource.ValueJson, &collection); err != nil {
return task.WorkflowDefinitionCollection{}, err
}
return collection, nil
}
func (s *Server) workflowDefinitions(ctx context.Context) ([]task.Definition, error) {
if s.ControlPlane == nil {
return nil, nil
}
collection, err := s.workflowCollection(ctx)
if err != nil {
return nil, err
}
enablement, _, err := s.workflowEnablement(ctx)
if err != nil {
return nil, err
}
definitions := make([]task.Definition, 0, len(collection.Definitions))
for _, entry := range collection.Definitions {
definition := task.Definition{ID: entry.ID, Name: entry.ID, Origin: "database", Enabled: enablement.Enabled(org.DefaultOrgID, entry.ID), Repository: task.RepositoryRequired}
if iface, err := task.ParseWorkflowInterface(entry.YAML); err == nil {
definition.Inputs, definition.Repository = iface.Inputs, iface.RepositoryMode()
}
definitions = append(definitions, definition)
}
return definitions, nil
}