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, Recovery: s.taskRecovery(r, &tasks[i])} } 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"` // Recovery is the page that fixes what a parked task lacks, present only // when the viewer may make that fix. Recovery *taskRecoveryView `json:"recovery,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...) }