Files
archie/internal/app/archieui/compose.go
T
sam cf7cc9d891 feat(webui): read a task's log through the State Store and let it be downloaded
The dashboard's attempt-log panel answered every read with "task logging is
optional and was not enabled for this run". That message was false: logging is
wired unconditionally in the daemon, and the log files exist. The dashboard
process simply had no reader -- composition left TaskLogs absent because no
contract carried it -- so the handler saw a nil registry and reported the
disabled shape, which the page rendered as a claim about configuration.

internal/logging now answers whether an attempt has a log at all: Tail sets
Result.Found, so "this attempt has no log" is a value rather than an empty
list indistinguishable from a read that never happened. Its registry gains
TaskLog (a decoded page) and TaskLogContent (the file verbatim, streamed,
because a log is unbounded input), and an absent reader reports
ErrTaskLogsUnavailable rather than an empty page -- a process that cannot read
logs must not implicate the attempt.

Those two answers travel the State Store contract as storecontract.TaskLogStore
(ReadTaskLog, StreamTaskLogContent) and are rehydrated on the client by
(Unavailable, canonical message), so archie-ui composes the reader from its own
store client instead of opening another process's files. The daemon's registry
is wired as the server-side reader in the State Store process only.

On top of that read, GET /api/tasks/{id}/logs/download serves the attempt's log
as a Content-Disposition attachment named task-<id>-attempt-<n>.log, and the
panel offers it. The JSON route keeps its shape and gains found, so the page
states the attempt has no log instead of blaming a setting.

Task log files stay owned by their directory's owner: archiving still removes a
task's log directory, and that removal is the daemon's, not the dashboard's.
2026-09-17 12:12:43 +00:00

165 lines
7.1 KiB
Go

package archieui
import (
"context"
"log/slog"
"time"
"github.com/samcharles93/archie-core/internal/domain/health"
"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
}
// 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,
TrustForwardedHeaders: d.Options.trustForwardedHeaders(),
Health: d.Health,
}
if snapshots, ok := d.Store.(storecontract.ConfigSnapshotStore); ok {
srv.ConfigSource = webui.RemoteConfigView(snapshots)
}
// 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 mappings, ok := d.Store.(storecontract.MappingStore); ok {
srv.Mappings = mappings
}
if bindings, ok := d.Store.(storecontract.BindingStore); ok {
srv.Bindings = bindings
}
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.
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 and the intake receiver.
// Both resolve from d.Store's contracts: CaptureStore backs the inspector's
// list and the mapping preview's scan window, BindingDispatcher resolves the
// armed binding whose secret HMAC-verifies a source. 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)
bindings, hasBindings := d.Store.(storecontract.BindingDispatcher)
if !hasCaptures {
d.Log.Warn("capture storage unavailable: state store does not implement CaptureStore")
return
}
if !hasBindings {
d.Log.Warn("binding dispatcher unavailable: state store does not implement BindingDispatcher")
}
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),
Bindings: bindings,
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