Files
archie/internal/app/archieui/compose.go
T
sam e7b21b9e5d feat(state-store): ListSteps, dashboard run detail reads it; drop tasks.stage
docs/prds/execution-tree-state-machine.md: step_executions (0017) is now the
durable per-step record; the dashboard's run detail (GET /api/tasks/{id}/
attempts) still folded stage_start/stage_finish events into a rail by hand,
and tasks.stage duplicated what StartStep/FinishStep already record properly.

Added the missing read:
- ListSteps(execution_id, attempt) -- attempt 0 lists every attempt of the
  execution, oldest first, so the rail renders every attempt from one call.
  New storecontract.StepReader (separate from StepRecorder: this is a
  dashboard/API/dispatch action per the PRD's wire contract, never
  task-scoped-grant callable), postgresdb.ListStepExecutions, staterpc
  client/server/values.go plumbing, wired through state_store.go's Deps and
  archieui/compose.go's Server.Steps the same optional-capability pattern
  every other dashboard read uses.
- internal/webui/api_tasks_attempts.go: stageViewsFromSteps replaces
  foldStages/finishStage/stageOutcome. Attempt bounds, event_count and which
  attempt numbers exist stay sourced from events (an attempt can carry
  events -- agent calls -- with no step), only the stage list itself moves.
  The wire JSON contract is unchanged, so no frontend change was needed;
  `task ui` confirms ui/dist still matches a fresh build.
- A running step past the task's own current attempt reads interrupted, not
  running: RecoverStale (archie-core, still open per #1214) is what corrects
  a crashed run's stale "running" row, and until it does this is the honest
  read rather than trusting a row that may be stale.

Dropped tasks.stage and every reader, no fallback:
- Migration 0018 drops the column; tasks.sql's INSERT/UPDATE/RETURNING lists
  and the sqlc-generated code no longer carry it.
- workflow.Task.Stage is gone; workflow.Run's in-flight "which stage is this"
  bookkeeping moves to TaskContext.Stage (execution-time only, never
  persisted -- park/finish's event tagging is its only reader).
- pb.Task.stage (wire field 10) is `[deprecated = true]`, not deleted (never
  reuse a field number); staterpc's taskProto/taskValue no longer map it.
- taskactions.Task.Stage and the retry event's "previous_stage" data field
  are gone: the operator-action package had no reader for the column beyond
  echoing it.
- The chat /tasks command's per-task "workflow/stage" display drops to
  workflow-only (ChatTaskSummary.Stage removed, workflowStage() deleted):
  it was a genuine reader with no replacement in scope for this change.

Read the archie-web-ui skill and the state-store/daemon docs/development
pages first, per instruction. Stayed out of cancel/stop code throughout
(Pi's concurrent CancelExecution work); the only shared files touched
(workflow.go, daemon-adjacent SQL) got the smallest possible diff.
2026-09-27 06:57:47 +10:00

211 lines
9.1 KiB
Go

package archieui
import (
"context"
"log/slog"
"time"
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/health"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/infrastructure/captureintake"
"github.com/samcharles93/archie-core/internal/webhookguard"
"github.com/samcharles93/archie-core/internal/webui"
)
// deps are the resolved inputs the dashboard is built from: two remote
// contracts, the process's own logger and options, and the readiness registry
// assembled over those same contracts.
type deps struct {
Options Options
Log *slog.Logger
Store storecontract.TaskStore
Chat messaging.ChatContract
Health *health.Registry
ControlPlane controlpb.ControlPlaneServiceClient
Identities identity.Repository
// Authenticate resolves a presented credential to the identity that may
// act. Nil when no provider is configured, which keeps the shared token.
Authenticate func(context.Context, string) (identity.Identity, error)
// Login drives the browser sign-in flow, or nil when no provider is
// configured for it.
Login identity.LoginFlow
// Access evaluates the policy chain; Principals assembles the request
// principal; Denials records refusals
// (docs/prds/orgs-and-access.md). Wired together or not at all.
Access access.Authorizer
Principals access.PrincipalSource
Denials access.DenialStore
}
// compose builds the dashboard server for the UI process. It sets exactly the
// fields a contract already carries plus this process's own settings, and
// leaves every remaining field at its zero value on purpose: each one is a
// daemon-local runtime handle with no contract behind it, and the handlers
// already degrade to a documented 501/503/empty response rather than panicking
// (docs/prds/ui-service-boundary.md:130-131).
//
// What is deliberately absent, and which bead fills it:
//
// - Cfg, LastReload, UpdateConfig, ConfigOverrides, ResetConfig,
// UpdateRepoField: the configuration owner stays the daemon. The read
// crosses as the snapshot ConfigSource renders; the write routes answer
// 503 and the page hides their controls (archie-core-ymut).
// - LogFeed, Events, Channels, ReloadChannel, Curators, Memory,
// Workflows, WorkRequests, RunningVersions, Chat.Updates,
// UpdateReportPath: no contract exists for these yet.
// Defining one amends the owning service's contract first
// (docs/prds/ui-service-boundary.md:205-207); the route migration is
// archie-core-8cda.5.3.
// - TaskLogs: wired below from the store client's TaskLogStore contract.
// Task log files live in the state directory the State Store owns, so this
// process reads one attempt's log over that contract rather than opening
// the file itself -- which would only work on a single host and is exactly
// what the boundary forbids (archie-core-iaqx).
// - Captures, CaptureIntake, CaptureMaxEvents: wired below. From the
// cutover change (archie-core-8cda.5.4) this process is the only
// listener serving POST /webhooks/capture/{source}: the receiver is a
// persistence shim over the State Store contract, and the daemon's
// binding-dispatch loop keeps consuming captures from the same store,
// so the HTTP front door moved here without moving the owner of work
// intake. Mounting it before the daemon's listener was gone would have
// given two listeners the same intake authority, which the PRD forbids
// (docs/prds/ui-service-boundary.md:30-33).
func compose(d deps) *webui.Server {
srv := &webui.Server{
Store: d.Store,
Log: d.Log,
Token: d.Options.Token,
Authenticate: d.Authenticate,
Login: d.Login,
TrustForwardedHeaders: d.Options.trustForwardedHeaders(),
Health: d.Health,
ControlPlane: d.ControlPlane,
Identities: d.Identities,
}
if snapshots, ok := d.Store.(storecontract.ConfigSnapshotStore); ok {
srv.ConfigSource = webui.RemoteConfigView(snapshots)
}
if steps, ok := d.Store.(storecontract.StepReader); ok {
srv.Steps = steps
}
// Channel lifecycle follows the same split as the config view: the process
// hosting the channels publishes, this one reads. Withholding it left
// /api/channels answering with nothing while channels were running
// (archie-core-8cda.6.8).
if channels, ok := d.Store.(storecontract.ChannelStatusStore); ok {
srv.Channels = webui.RemoteChannelStatus(channels)
}
// Mappings and bindings are ratified State Store contracts, and the same
// client already carries them: withholding them would degrade two pages
// that have an owner, which is a different thing from the intake surfaces
// below.
if applyStatus, ok := d.Store.(storecontract.ApplyStatusStore); ok {
srv.ApplyStatus = applyStatus
}
if mappings, ok := d.Store.(storecontract.MappingStore); ok {
srv.Mappings = mappings
}
if bindings, ok := d.Store.(storecontract.BindingStore); ok {
srv.Bindings = bindings
}
if eventTypes, ok := d.Store.(storecontract.EventTypeStore); ok {
srv.EventTypes = eventTypes
}
if d.Chat != nil {
srv.Chat = &webui.ChatService{Contract: d.Chat}
}
// The task-log read crosses the State Store contract: the files live in
// the state directory that process owns, so this one asks for the log
// rather than opening a path (docs/prds/ui-service-boundary.md). Withholding
// it would degrade a page that has an owner, and would leave the dashboard
// claiming task logging was not enabled -- see wireTaskLogs.
// The policy chain: wired together or not at all
// (docs/prds/orgs-and-access.md, "Where it lives").
srv.Access = d.Access
srv.Principals = d.Principals
srv.Denials = d.Denials
wireTaskLogs(d, srv)
wireCaptureSurfaces(d, srv)
return srv
}
// wireTaskLogs attaches the task-log read when the store client carries the
// contract, and logs the absence when it does not: a store without it leaves
// the page reporting that this process cannot read logs, which is true, rather
// than that the attempt has none, which it cannot know.
func wireTaskLogs(d deps, srv *webui.Server) {
logs, ok := d.Store.(storecontract.TaskLogStore)
if !ok {
if d.Store != nil {
d.Log.Warn("task logs unavailable: state store does not implement TaskLogStore")
}
return
}
srv.TaskLogs = logs
}
// wireCaptureSurfaces attaches the capture read, the source editor and the
// intake receiver. All resolve from d.Store's contracts: CaptureStore backs
// the inspector's list and the mapping preview's scan window, SourceStore
// resolves the source whose signing setting verifies an event. A store that
// does not implement one degrades that half with a warning rather than
// aborting the process, mirroring the daemon's own adapter selection.
func wireCaptureSurfaces(d deps, srv *webui.Server) {
captures, hasCaptures := d.Store.(storecontract.CaptureStore)
sources, hasSources := d.Store.(storecontract.SourceStore)
if !hasCaptures {
d.Log.Warn("capture storage unavailable: state store does not implement CaptureStore")
return
}
var resolver captureintake.SourceResolver
if hasSources {
srv.Sources = sources
resolver = sources
} else {
d.Log.Warn("source store unavailable: state store does not implement SourceStore; no capture will dispatch")
}
capture := d.Options.Capture.withDefaults()
srv.Captures = captures
srv.CaptureMaxEvents = capture.MaxEvents
srv.CaptureIntake = &captureintake.Receiver{
Captures: captures,
Limiter: webhookguard.NewRateLimiter(capture.RatePerSecond, capture.RateBurst, time.Now),
Sources: resolver,
Retention: capture.Retention,
MaxEvents: capture.MaxEvents,
MaxBodyBytes: int64(capture.MaxBodyBytes),
Publish: captureArrivalPublisher(d),
Log: d.Log,
}
}
// captureArrivalPublisher persists a capture's arrival event through the
// State Store, where the daemon's bus drain persists every other activity
// event; the event pump then delivers it to every connected browser. A nil
// store records captures without announcing them (compose's test-only
// shape); an insert failure is logged, not surfaced -- the capture row is
// already durable, and the inspector refetches on its next view.
func captureArrivalPublisher(d deps) func(context.Context, events.Event) {
if d.Store == nil {
return nil
}
return func(ctx context.Context, e events.Event) {
ctx, cancel := context.WithTimeout(ctx, captureEventTimeout)
defer cancel()
if _, err := d.Store.InsertEvent(ctx, e); err != nil {
d.Log.Warn("capture arrival event not published", "err", err)
}
}
}
// captureEventTimeout bounds the synchronous announce of one capture
// arrival. A capture POST already paid the rate limiter and a store insert;
// a hung State Store must not hold the sender's webhook past this.
const captureEventTimeout = 5 * time.Second