Files
pipelines/internal/stage/stage.go
T
alan 0f5a188c6a Record and serve per-stage artifacts
Every agent stage now writes into a per-run/step artifacts directory under
the data dir (<data>/artifacts/<run>/<step>), passed to Pi as
PIPELINES_ARTIFACTS_DIR, exposed on the OpenCode client env seam, and stated
in the agent prompt boilerplate so agents save images, screenshots, reports
and logs there.

After each step the server scans that directory with a bounded, symlink- and
traversal-safe inventory (os.OpenRoot + Lstat + O_NOFOLLOW) recording name,
size_bytes, content type (extension then 512-byte sniff fallback) and URL,
enforcing max files, per-file bytes and total bytes while counting skipped
and truncated entries. A missing, unreadable or oversized directory yields
only a best-effort diagnostic and never changes the step outcome.

The list is carried on protocol.RunStep as Artifacts []StageArtifact plus
skipped/truncated counters (omitempty, backwards compatible), persisted in a
new step_artifacts table keyed (run_id, sequence) alongside the
notifications/file-changes tables and loaded by GetRun.

GET /artifacts/{run}/{step}/{name} on the existing handler serves the bytes
with http.ServeContent, so Content-Type, Content-Length, HEAD and Range
(206/416) come from the stdlib; unknown runs/steps, absolute paths,
traversal, symlink escapes and non-regular files are refused.

The TUI lists each selected step's artifacts (name + human size) in the
retained-evidence section and adds an artifacts summary in the style of the
file-changes summary. Adds docs/stage-artifacts.md linked from README and an
artifacts subsection to the packaged operations skill reference.

Tests cover the scan records and caps, missing/oversized directories,
HTTP HEAD/Range/traversal/symlink/unknown refusals and protocol round-trips.
2026-10-15 17:51:18 +01:00

96 lines
2.7 KiB
Go

// Package stage owns type-specific validation and execution. Pipeline parsing,
// graph routing, persistence, and presentation belong to their respective layers.
package stage
import (
"context"
"fmt"
)
// Values are runtime data, not the prose output contract in a definition.
type Values map[string]any
type Definition struct {
ReportFileArtifacts bool
Key string
Type string
// ArtifactsDir is the per-run/step directory the runtime created for this
// visit; empty when the runner did not provide one (for example in tests).
ArtifactsDir string
Blocks map[string]string
Configs map[string]string
Edges map[string]string
}
// Result selects one declared outcome. The future graph runner owns resolving
// its destination and routing execution errors through the mandatory error edge.
type Result struct {
Outcome string `json:"outcome"`
Output Values `json:"output"`
}
// Stage implementations must be safe to share between concurrent runs. Definitions
// and input maps are caller-owned: validation and execution must not mutate them.
// Run returns an error for execution failures, not a fabricated success result.
type Stage interface {
Validate(Definition) error
Run(context.Context, Definition, Values) (Result, error)
}
// Registry is immutable after construction. Adding a type requires an implementation
// here, not another branch in the Markdown parser or graph validator.
type Registry struct {
types map[string]Stage
}
func NewRegistry(types map[string]Stage) *Registry {
copy := make(map[string]Stage, len(types))
for name, implementation := range types {
copy[name] = implementation
}
return &Registry{types: copy}
}
func DefaultRegistry() *Registry {
return NewRegistry(map[string]Stage{ModelType: ModelStage{}, NtfyType: NtfyStage{}})
}
func EffectiveType(name string) string {
if name == "" {
return ModelType
}
return name
}
func (r *Registry) Resolve(name string) (Stage, error) {
name = EffectiveType(name)
if r != nil {
if implementation := r.types[name]; implementation != nil {
return implementation, nil
}
}
return nil, fmt.Errorf("unsupported stage type %q", name)
}
func (r *Registry) Validate(def Definition) error {
implementation, err := r.Resolve(def.Type)
if err != nil {
return err
}
return implementation.Validate(def)
}
func (r *Registry) Run(ctx context.Context, def Definition, input Values) (Result, error) {
if err := ctx.Err(); err != nil {
return Result{}, err
}
implementation, err := r.Resolve(def.Type)
if err != nil {
return Result{}, err
}
if err := implementation.Validate(def); err != nil {
return Result{}, err
}
return implementation.Run(ctx, def, input)
}