package webui import ( "context" "encoding/json" "errors" "fmt" "io" "log/slog" "net/http" "strings" "unicode/utf8" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" "github.com/samcharles93/archie-core/internal/config" controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1" "github.com/samcharles93/archie-core/internal/domain/access" "github.com/samcharles93/archie-core/internal/domain/org" "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/domain/workflow" "github.com/samcharles93/archie-core/internal/domain/workflow/task" "github.com/samcharles93/archie-core/internal/events" ) const workflowDefinitionsKind = "workflow-definitions" // workflowsAPI owns the workflow catalogue, per-org enablement, the // repository list and manual work requests. Its definition readers also back // the bindings and audit modules. type workflowsAPI struct { controlPlane controlpb.ControlPlaneServiceClient store storecontract.TaskStore log *slog.Logger emit func(context.Context, events.Event) authorize func(http.ResponseWriter, *http.Request) bool } func newWorkflowsAPI(s *Server) *workflowsAPI { return &workflowsAPI{controlPlane: s.ControlPlane, store: s.Store, log: s.Log, emit: s.emit, authorize: s.authorizeTaskMutation} } func (a *workflowsAPI) logf(msg string, args ...any) { warnf(a.log, msg, args...) } func (a *workflowsAPI) register(mux *http.ServeMux) { mux.HandleFunc("GET /api/workflows", a.handleWorkflows) mux.HandleFunc("PUT /api/workflows/{id}/enabled", a.handleWorkflowEnabled) mux.HandleFunc("POST /api/work-requests", a.handleWorkRequest) mux.HandleFunc("GET /api/repositories", a.handleRepositories) } // 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 (a *workflowsAPI) handleWorkflows(w http.ResponseWriter, r *http.Request) { ctx := r.Context() workflows, err := a.store.WorkflowStats(ctx) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } stages, err := a.store.StageStats(ctx) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } definitions, err := a.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 { 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 Inputs map[string]any `json:"inputs"` // Draft is an unsaved definition of Workflow to test-run instead of the // stored one. The stored definition is untouched and the run writes // nothing to a forge. Draft string `json:"draft"` } func (a *workflowsAPI) handleWorkRequest(w http.ResponseWriter, r *http.Request) { if !a.authorize(w, r) { return } principal, ok := access.PrincipalFromContext(r.Context()) if !ok || principal.IdentityID == "" { http.Error(w, "authenticated requester required", http.StatusUnauthorized) 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.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.Workflow == "" || request.Title == "" { http.Error(w, "workflow and title are required", http.StatusBadRequest) return } if utf8.RuneCountInString(request.Title) > 80 { http.Error(w, "title must be 80 characters or fewer; put details in instructions", http.StatusBadRequest) return } iface, code, err := a.workRequestInterface(r.Context(), request) if err != nil { http.Error(w, status.Convert(err).Message(), code) return } if err := iface.CheckInputs(request.Inputs); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } owner, repo, status, err := a.workRequestRepository(r.Context(), iface.RepositoryMode(), request.Repository) if err != nil { http.Error(w, err.Error(), status) return } created, err := a.store.EnqueueChatTask(r.Context(), owner, repo, request.Title, request.Instructions, request.Workflow, string(principal.IdentityID), "", request.Draft, request.Inputs) if err != nil { a.logf("work request enqueue failed", "err", err) http.Error(w, "work request rejected", http.StatusBadRequest) return } a.emit(r.Context(), events.Event{ Kind: events.KindWorkRequestSubmitted, TaskID: created.ID, Repo: request.Repository, Workflow: request.Workflow, Detail: request.Title, ActorID: string(principal.IdentityID), ActorKind: string(principal.Kind), PrincipalID: string(principal.IdentityID), }) w.WriteHeader(http.StatusCreated) writeJSON(w, map[string]any{"ok": true, "task_id": created.ID}) } // workRequestInterface returns the interface a request runs against: the // draft's when it carries one, else the stored definition's. The workflow must // be defined and enabled either way. func (a *workflowsAPI) workRequestInterface(ctx context.Context, request workRequest) (task.WorkflowInterface, int, error) { iface, enabled, err := a.enabledWorkflowInterface(ctx, request.Workflow) switch { case err != nil: return iface, http.StatusServiceUnavailable, errors.New("workflow definitions unavailable") case !enabled: return iface, http.StatusConflict, errors.New("workflow is not enabled") case request.Draft != "": return a.checkDraft(ctx, request.Workflow, request.Draft) } return iface, 0, nil } // checkDraft refuses a draft a save of the same document would refuse, and // returns the interface the draft declares. func (a *workflowsAPI) checkDraft(ctx context.Context, id, draft string) (task.WorkflowInterface, int, error) { if declared, err := workflow.DefinitionID(draft); err != nil || declared != id { return task.WorkflowInterface{}, http.StatusBadRequest, errors.New("the draft must be a definition of the workflow being run") } collection, err := a.workflowCollection(ctx) if err != nil { return task.WorkflowInterface{}, http.StatusServiceUnavailable, errors.New("workflow definitions unavailable") } replaced := collection.Definitions[:0:0] for _, entry := range collection.Definitions { if entry.ID == id { entry.YAML = draft } replaced = append(replaced, entry) } value, err := json.Marshal(task.WorkflowDefinitionCollection{Definitions: replaced}) if err != nil { return task.WorkflowInterface{}, http.StatusInternalServerError, err } if _, err := a.controlPlane.Command(ctx, &controlpb.CommandRequest{Kind: workflowDefinitionsKind, Command: "validate", ValueJson: value}); err != nil { if status.Code(err) == codes.InvalidArgument { return task.WorkflowInterface{}, http.StatusBadRequest, err } return task.WorkflowInterface{}, http.StatusServiceUnavailable, errors.New("workflow definitions unavailable") } iface, err := task.ParseWorkflowInterface(draft) if err != nil { return task.WorkflowInterface{}, http.StatusBadRequest, err } return iface, 0, nil } // workRequestRepository checks a requested "owner/name" against the // workflow's repository mode and the configured repositories, and returns it // split. A workflow that takes none refuses one; one that requires it refuses // its absence. func (a *workflowsAPI) workRequestRepository(ctx context.Context, mode task.RepositoryMode, requested string) (owner, repo string, status int, err error) { switch { case requested == "" && mode == task.RepositoryRequired: return "", "", http.StatusBadRequest, errors.New("this workflow needs a repository") case requested == "": return "", "", 0, nil case mode == task.RepositoryNone: return "", "", http.StatusBadRequest, errors.New("this workflow takes no repository") } owner, repo, ok := strings.Cut(requested, "/") if !ok || owner == "" || repo == "" || strings.Contains(repo, "/") { return "", "", http.StatusBadRequest, errors.New("repository must be owner/name") } repos, err := a.configuredRepositories(ctx) if err != nil { return "", "", http.StatusServiceUnavailable, err } found := false for _, r := range repos { if strings.EqualFold(r.Owner, owner) && strings.EqualFold(r.Name, repo) { found = true break } } if !found { return "", "", http.StatusBadRequest, fmt.Errorf("repository %s/%s is not configured", owner, repo) } return owner, repo, 0, nil } // handleRepositories lists configured names without requiring permission to // read or edit the organisation's full settings document. func (a *workflowsAPI) handleRepositories(w http.ResponseWriter, r *http.Request) { repos, err := a.configuredRepositories(r.Context()) if err != nil { http.Error(w, "Configured repositories are unavailable.", http.StatusServiceUnavailable) return } type repositoryName struct { Owner string `json:"owner"` Name string `json:"name"` } names := make([]repositoryName, 0, len(repos)) for _, repo := range repos { names = append(names, repositoryName{Owner: repo.Owner, Name: repo.Name}) } writeJSON(w, names) } func (a *workflowsAPI) configuredRepositories(ctx context.Context) ([]config.Repo, error) { if a.controlPlane == nil { return nil, errors.New("configured repositories unavailable") } response, err := a.controlPlane.Query(ctx, &controlpb.QueryRequest{Kind: "repository-policies"}) if err != nil || response.Resource == nil { return nil, errors.New("configured repositories unavailable") } var repos []config.Repo if err := json.Unmarshal(response.Resource.ValueJson, &repos); err != nil { return nil, errors.New("configured repositories unavailable") } return repos, nil } // enabledWorkflowInterface returns a workflow's declared interface and whether // it is defined and enabled for the caller's org. func (a *workflowsAPI) enabledWorkflowInterface(ctx context.Context, id string) (task.WorkflowInterface, bool, error) { entry, found, err := a.workflowEntry(ctx, id) if err != nil || !found { return task.WorkflowInterface{}, false, err } enablement, _, err := a.workflowEnablement(ctx) if err != nil || !enablement.Enabled(org.OrgFromContext(ctx), 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 (a *workflowsAPI) hasWorkflowDefinition(ctx context.Context, id string) (bool, error) { _, found, err := a.workflowEntry(ctx, id) return found, err } // workflowEntry returns the stored definition of workflow id. func (a *workflowsAPI) workflowEntry(ctx context.Context, id string) (task.WorkflowDefinitionEntry, bool, error) { collection, err := a.workflowCollection(ctx) if err != nil { return task.WorkflowDefinitionEntry{}, false, err } entry, found := collection.DefinitionByID(id) return entry, found, nil } func (a *workflowsAPI) workflowCollection(ctx context.Context) (task.WorkflowDefinitionCollection, error) { if a.controlPlane == nil { return task.WorkflowDefinitionCollection{}, nil } response, err := a.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 (a *workflowsAPI) workflowDefinitions(ctx context.Context) ([]task.Definition, error) { if a.controlPlane == nil { return nil, nil } collection, err := a.workflowCollection(ctx) if err != nil { return nil, err } enablement, _, err := a.workflowEnablement(ctx) if err != nil { return nil, err } sources := make(map[string]string, len(collection.Definitions)) for _, entry := range collection.Definitions { sources[entry.ID] = entry.YAML } startedBy := workflow.StartedBy(sources) 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.OrgFromContext(ctx), entry.ID), Repository: task.RepositoryRequired, StartedBy: startedBy[entry.ID]} if iface, err := task.ParseWorkflowInterface(entry.YAML); err == nil { definition.Inputs, definition.Repository = iface.Inputs, iface.RepositoryMode() } definitions = append(definitions, definition) } return definitions, nil }