Files
archie/internal/webui/api_tasks.go
T
sam f2b8681611 refactor(workflow): stop assuming a human decides
An approval, ask or park can be resolved by an operator, a rule, a
classifier or automatically, so the vocabulary stops naming a person:

- step type human.approve -> workflow.approve
- park class needs_human -> needs_decision (ParkNeedsDecision)
- event kinds human_* -> operator_*
- alert kind task.needs_human -> task.needs_decision
- status grouping "needs you" -> "needs attention"

0061 rewrites the stored values, including the approval step type in the
workflow-definitions resource and each task's pinned definition, with the
digest recomputed so resumed tasks still match.
2026-10-25 17:31:16 +11:00

390 lines
13 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"mime"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/taskactions"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/taskstate"
)
func (s *Server) handleSummary(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
statuses, err := s.Store.StatusCounts(ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
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
}
days, err := s.Store.TokensByDay(ctx, 14)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
needsAttention := 0
for _, id := range needsAttentionStatuses() {
needsAttention += statuses[id]
}
writeJSON(w, map[string]any{
"statuses": statuses, "needs_attention": needsAttention, "workflows": workflows,
"stages": stages, "tokens_by_day": days,
})
}
// needsAttentionStatuses are the statuses the "needs you" filter and count group.
func needsAttentionStatuses() []string {
var ids []string
for _, meta := range taskstate.Statuses() {
if meta.NeedsAttention {
ids = append(ids, meta.ID)
}
}
return ids
}
// handleTasks serves one page of tasks, most recently updated first. ?status
// narrows it (needs_attention is the grouped filter), ?limit sizes it, and ?cursor
// resumes after the previous page; a full page answers the next cursor in the
// X-Next-Cursor header.
func (s *Server) handleTasks(w http.ResponseWriter, r *http.Request) {
page, err := taskPageFrom(r.URL.Query())
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
tasks, err := s.Store.TasksPage(r.Context(), page)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if len(tasks) == page.Limit {
last := tasks[len(tasks)-1]
w.Header().Set("X-Next-Cursor", fmt.Sprintf("%d.%d", last.UpdatedAt.UnixNano(), last.ID))
}
forge := s.resolveForge(r.Context())
views := make([]taskView, len(tasks))
for i := range tasks {
repoURL, issueURL, prURL := taskURLs(tasks[i], forge(tasks[i]))
views[i] = taskView{Task: tasks[i], Actions: taskstate.Actions(tasks[i].Status), Approval: taskstate.ApprovalKind(tasks[i].Status, tasks[i].ReviewGate), RepoURL: repoURL, IssueURL: issueURL, PRURL: prURL}
}
writeJSON(w, views)
}
const defaultTaskPage = 100
// taskPageFrom reads the task list's query parameters.
func taskPageFrom(q url.Values) (storecontract.TaskPage, error) {
page := storecontract.TaskPage{Limit: defaultTaskPage, Workflow: q.Get("workflow")}
switch status := q.Get("status"); status {
case "":
case "needs_attention":
page.Statuses = needsAttentionStatuses()
default:
page.Statuses = []string{status}
}
if raw := q.Get("limit"); raw != "" {
limit, err := strconv.Atoi(raw)
if err != nil || limit < 1 || limit > 500 {
return page, fmt.Errorf("limit must be 1 to 500")
}
page.Limit = limit
}
if raw := q.Get("cursor"); raw != "" {
nanos, id, ok := strings.Cut(raw, ".")
n, nerr := strconv.ParseInt(nanos, 10, 64)
i, ierr := strconv.ParseInt(id, 10, 64)
if !ok || nerr != nil || ierr != nil || i <= 0 {
return page, fmt.Errorf("invalid cursor")
}
page.After = storecontract.TaskCursor{UpdatedAt: time.Unix(0, n), ID: i}
}
return page, nil
}
type taskView struct {
task.Task
Actions []taskstate.Action `json:"actions"`
Approval string `json:"approval,omitempty"`
RepoURL string `json:"repo_url,omitempty"`
IssueURL string `json:"issue_url,omitempty"`
PRURL string `json:"pr_url,omitempty"`
}
// forgeCoordinates locate a repository on its forge: the base URL, and the
// forge type that decides the pull-request path segment.
type forgeCoordinates struct {
host string
forgeType string
}
// resolveForge returns a function mapping a task to the instance forge. A
// multi-identity install withholds links: its tasks reach forges through
// organisation connections this projection does not carry.
func (s *Server) resolveForge(ctx context.Context) func(task.Task) forgeCoordinates {
unlinked := func(task.Task) forgeCoordinates { return forgeCoordinates{} }
view, ok, err := s.configSource()(ctx)
if err != nil || !ok || view.MultiIdentity {
return unlinked
}
published := forgeCoordinates{host: view.Identity.ForgeHost, forgeType: view.Identity.ForgeType}
return func(task.Task) forgeCoordinates { return published }
}
func taskURLs(task task.Task, forge forgeCoordinates) (repoURL, issueURL, prURL string) {
if forge.host == "" || task.Owner == "" || task.Repo == "" {
return "", "", ""
}
repoURL = strings.TrimRight(forge.host, "/") + "/" + url.PathEscape(task.Owner) + "/" + url.PathEscape(task.Repo)
if task.IsForgeBacked() && task.IssueNumber > 0 {
issueURL = repoURL + "/issues/" + strconv.Itoa(task.IssueNumber)
}
if task.PRNumber > 0 {
segment := "pull"
if forge.forgeType == "gitea" {
segment = "pulls"
}
prURL = repoURL + "/" + segment + "/" + strconv.Itoa(task.PRNumber)
}
return repoURL, issueURL, prURL
}
func (s *Server) handleTask(w http.ResponseWriter, r *http.Request) {
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
if err != nil {
http.Error(w, "bad id", http.StatusBadRequest)
return
}
evs, err := s.Store.TaskEvents(r.Context(), id)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
writeJSON(w, evs)
}
type taskActionRequest struct {
Action string `json:"action"`
// Instructions is the re-review's focus, required by the rereview action
// and ignored by every other one. The dashboard is the authoritative
// surface that carries operators' instructions; chat is a shortcut with no
// instruction syntax.
Instructions string `json:"instructions"`
// Findings are the keys of the offered findings an approve posts; an
// absent selection means all of them. It is ignored by every other
// action.
Findings []string `json:"findings"`
// RetryMode is the worktree mode for a retry; empty means refresh_onto_base.
RetryMode string `json:"retry_mode"`
// ResumeFrom is the step a retry starts at; empty runs every step.
ResumeFrom string `json:"resume_from"`
// CurrentDefinition moves a retry onto the workflow's current stored
// definition.
CurrentDefinition bool `json:"current_definition"`
}
func (s *Server) handleTaskAction(w http.ResponseWriter, r *http.Request) {
if !s.authorizeTaskMutation(w, r) {
return
}
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
if err != nil {
http.Error(w, "bad id", http.StatusBadRequest)
return
}
action, res, ok := decodeTaskAction(w, r)
if !ok {
return
}
if err := s.applyOperatorTaskAction(r.Context(), id, action, res); err != nil {
switch {
case errors.Is(err, taskactions.ErrNotFound):
http.Error(w, "task not found", http.StatusNotFound)
case errors.Is(err, taskactions.ErrConflict), errors.Is(err, storecontract.ErrStaleTransition),
errors.Is(err, storecontract.ErrRereviewCapReached):
http.Error(w, err.Error(), http.StatusConflict)
case errors.Is(err, taskactions.ErrUnavailable):
http.Error(w, err.Error(), http.StatusServiceUnavailable)
default:
s.logf("task action failed", "task", id, "err", err)
http.Error(w, "task action failed", http.StatusInternalServerError)
}
return
}
writeJSON(w, map[string]any{"ok": true, "action": action, "task_id": id})
}
func decodeTaskAction(w http.ResponseWriter, r *http.Request) (taskstate.Action, taskactions.ActionPayload, bool) {
r.Body = http.MaxBytesReader(w, r.Body, 4096)
var req taskActionRequest
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&req); err != nil {
if _, ok := errors.AsType[*http.MaxBytesError](err); ok {
http.Error(w, "action body too large", http.StatusRequestEntityTooLarge)
return "", taskactions.ActionPayload{}, false
}
http.Error(w, "invalid action", http.StatusBadRequest)
return "", taskactions.ActionPayload{}, false
}
if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
http.Error(w, "invalid action", http.StatusBadRequest)
return "", taskactions.ActionPayload{}, false
}
action := taskstate.Action(req.Action)
if !taskMutation(action) {
http.Error(w, "unknown action", http.StatusBadRequest)
return "", taskactions.ActionPayload{}, false
}
// A re-review without instructions is not a request the gate can honour,
// and refusing it here keeps the refusal the operator's to read rather
// than a round trip's conflict. The service re-checks it for the surfaces
// that do not pass through this handler.
if action == taskstate.ActionRereview && strings.TrimSpace(req.Instructions) == "" {
http.Error(w, "a re-review needs instructions", http.StatusBadRequest)
return "", taskactions.ActionPayload{}, false
}
return action, taskactions.ActionPayload{Instructions: req.Instructions, Findings: req.Findings, RetryMode: taskstate.RetryMode(req.RetryMode), ResumeFrom: req.ResumeFrom, CurrentDefinition: req.CurrentDefinition}, true
}
func taskMutation(action taskstate.Action) bool {
switch action {
case taskstate.ActionCancel, taskstate.ActionStop, taskstate.ActionApprove,
taskstate.ActionReject, taskstate.ActionRereview, taskstate.ActionRetry,
taskstate.ActionAbandon, taskstate.ActionArchive, taskstate.ActionMerge:
return true
default:
return false
}
}
// authorizeTaskMutation requires JSON, a custom header and, when present, a
// same-origin Origin. Forwarded headers are trusted only with
// TrustForwardedHeaders.
func (s *Server) authorizeTaskMutation(w http.ResponseWriter, r *http.Request) bool {
if r.Header.Get("X-Archie-CSRF") != "1" {
http.Error(w, "missing CSRF header", http.StatusForbidden)
return false
}
mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil || mediaType != "application/json" {
http.Error(w, "Content-Type must be application/json", http.StatusUnsupportedMediaType)
return false
}
origin := r.Header.Get("Origin")
if origin == "" {
return true
}
u, err := url.Parse(origin)
if err != nil {
http.Error(w, "cross-origin mutation refused", http.StatusForbidden)
return false
}
wantScheme, wantHost := s.expectedOrigin(r)
if !validOrigin(u, wantScheme, wantHost) {
http.Error(w, "cross-origin mutation refused", http.StatusForbidden)
return false
}
return true
}
func (s *Server) expectedOrigin(r *http.Request) (scheme, host string) {
scheme = "http"
if r.TLS != nil {
scheme = "https"
}
host = r.Host
if s == nil || !s.trustForwardedHeaders() {
return scheme, host
}
if proto := firstForwardedValue(r.Header.Get("X-Forwarded-Proto")); proto != "" {
scheme = strings.ToLower(proto)
}
if fHost := firstForwardedValue(r.Header.Get("X-Forwarded-Host")); fHost != "" {
host = fHost
}
return scheme, host
}
func firstForwardedValue(raw string) string {
raw = strings.TrimSpace(raw)
if raw == "" {
return ""
}
if first, _, ok := strings.Cut(raw, ","); ok {
raw = first
}
return strings.TrimSpace(raw)
}
func validOrigin(u *url.URL, wantScheme, wantHost string) bool {
if u == nil || u.User != nil || u.Path != "" || u.RawQuery != "" || u.Fragment != "" {
return false
}
return strings.EqualFold(u.Scheme, wantScheme) && strings.EqualFold(u.Host, wantHost)
}
// applyOperatorTaskAction sends an operator's task action to the Gateway.
func (s *Server) applyOperatorTaskAction(ctx context.Context, id int64, action taskstate.Action, res taskactions.ActionPayload) error {
if s.Chat == nil || s.Chat.Contract == nil {
return fmt.Errorf("%w: no gateway contract is wired", taskactions.ErrUnavailable)
}
// The actor comes from the credential the middleware resolved and never from
// the request, so a caller cannot claim to be someone it did not authenticate
// as. An unauthenticated request (the shared-token gate) carries no identity,
// and the action is then recorded unattributed rather than as an operator's.
actor := taskactions.Actor{}
if value, ok := ActingIdentity(ctx); ok {
actor = taskactions.ActorFor(value)
}
_, err := s.Chat.Contract.ApplyOperatorTaskAction(ctx, actor, id, action, res)
return err
}
// emit publishes an operator action so it reaches the task timeline and the
// live activity stream. A nil publisher is not an error: the action is still
// recorded in the store.
func (s *Server) emit(ctx context.Context, e events.Event) {
if e.Kind == "" {
return
}
if e.ID == 0 {
id, err := s.Store.InsertEvent(ctx, e)
if err != nil {
s.logf("operator activity persistence failed", "kind", e.Kind, "task", e.TaskID, "err", err)
} else {
e.ID = id
}
}
if s.Events != nil {
s.Events.Publish(e)
}
}
func (s *Server) logf(msg string, args ...any) {
if s.Log == nil {
return
}
s.Log.Warn(msg, args...)
}