Files
pipelines/internal/server/session_export_repair.go
alan bd07abcde8 Run pipeline stages on Claude Code (harness=claude)
A model stage with harness=claude, provider=anthropic and a Claude model id
runs one claude -p process per visit with the server user's Claude sign-in.
Only the declared tools exist (--tools) and nothing else is approved
(--permission-mode dontAsk); edits are approved only below the run directory
and the stage's artifacts directory. A permissions block, run write paths,
delivery=true and reasoning_effort none/minimal are refused, not widened.

Usage comes from the CLI's final result and counts toward budgets. Failures
are fixed text; billing, quota and rate-limit refusals map to
ErrProviderQuota. The redacted stream is the session export and evidence.
provider-check --harness claude and model overrides are covered.
2026-11-11 10:30:37 +00:00

183 lines
7.5 KiB
Go

package server
import (
"context"
"crypto/rand"
"encoding/hex"
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/stage"
)
// repairSessionExport is runtime-owned and read-only to OpenCode. It never
// resumes a session, runs a stage, changes a definition, or overwrites evidence.
func (r *runner) repairSessionExport(ctx context.Context, id int64, sequence int) (*protocol.RunDetail, error) {
return r.repairSessionExportOwned(ctx, id, sequence, nil)
}
func (r *runner) repairSessionExportOwned(ctx context.Context, id int64, sequence int, expected *pipeline.SessionOwner) (*protocol.RunDetail, error) {
r.exportRepairMu.Lock()
defer r.exportRepairMu.Unlock()
if id <= 0 || sequence <= 0 {
return nil, fmt.Errorf("positive run ID and export_sequence are required")
}
r.mu.Lock()
_, executing := r.active[id]
r.mu.Unlock()
if executing {
return nil, fmt.Errorf("run execution cleanup is still active; repair deferred")
}
d, err := r.store.GetRun(ctx, id)
if err != nil {
return nil, err
}
pendingGate, gateErr := r.store.PendingSessionExportGate(ctx, id, sequence)
if gateErr != nil {
return nil, gateErr
}
if d.Status == "running" || d.Status == "queued" || (d.Status == "waiting" && !pendingGate) {
return nil, fmt.Errorf("session export repair requires a settled run")
}
var step *protocol.RunStep
for i := range d.Steps {
if d.Steps[i].Sequence == sequence {
step = &d.Steps[i]
break
}
}
if step == nil || step.AgentActive {
return nil, fmt.Errorf("no settled recorded session for this visit")
}
if len(step.SessionExportRepairs) >= 20 {
return nil, fmt.Errorf("repair attempt limit reached for this visit")
}
owner, err := r.store.RepairSessionOwner(ctx, id, sequence)
if err != nil {
return nil, fmt.Errorf("exact original session ownership metadata unavailable: %w", err)
}
if expected != nil && (owner.ID != expected.ID || owner.Backend != expected.Backend || owner.Directory != expected.Directory || owner.Reference != expected.Reference) {
return nil, fmt.Errorf("original session ownership differs from durable recovery snapshot; export refused")
}
active, err := r.store.ActiveSessionOwners(ctx)
if err != nil {
return nil, err
}
for _, current := range active {
if current.ID == owner.ID {
return nil, fmt.Errorf("original session is still active; export repair deferred")
}
}
evidence := &protocol.SessionExport{SessionID: owner.ID, Backend: owner.Backend, Directory: owner.Directory, RecordedAt: time.Now().UTC().Format(time.RFC3339), Source: "native_export"}
// Capture and retain failures too. The diagnostic is evidence, not a new
// run outcome, and cannot change the original stage/run success status.
recordFailure := func(message string) (*protocol.RunDetail, error) {
recordCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
defer cancel()
evidence.Status = "failed"
evidence.Diagnostic = stage.RedactEvidence(message)
if err := r.store.RecordSessionExportRepair(recordCtx, id, sequence, evidence); err != nil {
return nil, err
}
return r.sessionExportUpdatedDetail(recordCtx, id)
}
if owner.Backend != "v1" && owner.Backend != "v2" && owner.Backend != "pi" && owner.Backend != stage.ClaudeBackend {
return recordFailure("native export unavailable for original harness")
}
root, err := os.OpenRoot(r.artifactsRoot)
if err != nil {
return recordFailure(err.Error())
}
defer root.Close()
run := strconv.FormatInt(id, 10)
if step.Stage == "" || step.Stage == "." || step.Stage == ".." || strings.ContainsAny(step.Stage, "/\\") {
return recordFailure("invalid recorded stage key")
}
visit := filepath.Join(run, "stages", fmt.Sprintf("%02d-%s", sequence, step.Stage))
legacy := filepath.Join(run, strconv.Itoa(sequence))
if !containedDirectory(root, filepath.ToSlash(visit)) && containedDirectory(root, filepath.ToSlash(legacy)) {
visit = legacy
}
// Audit records belong to this visit, never shared public/: the next stage
// must not receive the previous agent's private tool/transcript contents.
for _, dir := range []string{run, filepath.Dir(visit), visit} {
info, err := root.Lstat(dir)
if os.IsNotExist(err) {
if err := root.Mkdir(dir, 0700); err != nil {
return recordFailure(err.Error())
}
continue
}
if err != nil {
return recordFailure(err.Error())
}
if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
return recordFailure("repair directory is not a normal directory")
}
}
var nonce [16]byte
if _, err := rand.Read(nonce[:]); err != nil {
return recordFailure(err.Error())
}
name := fmt.Sprintf("session-repair-%d-%s.html", sequence, hex.EncodeToString(nonce[:]))
// Stage.ExportSession is a runtime rendering helper, not a model stage.
// No prompts/configs/definitions are involved. Export uses original owner.
exportCtx, cancel := context.WithTimeout(ctx, stage.SessionExportTimeout)
defer cancel()
export := r.exportSession
if export == nil {
export = stage.ExportSession
}
result, err := export(exportCtx, stage.SessionExportRequest{SessionID: owner.ID, Backend: owner.Backend, Reference: owner.Reference, Directory: owner.Directory, ArtifactsDir: filepath.Join(r.artifactsRoot, visit), FileName: name, RunID: id, Sequence: sequence, Stage: step.Stage, Provider: step.Provider, Model: step.Model})
persistCtx, persistCancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
defer persistCancel()
evidence.Attempts = result.Attempts
if err != nil {
return recordFailure(err.Error())
}
evidence.Status = result.Status
evidence.Source = result.Source
evidence.Messages = result.Messages
evidence.Truncated = result.Truncated
evidence.Diagnostic = result.Diagnostic
if result.HTML != "" {
if result.HTML != name {
return recordFailure("repair exporter returned an unexpected filename")
}
info, err := root.Lstat(filepath.Join(visit, name))
if err != nil {
return recordFailure(err.Error())
}
if !info.Mode().IsRegular() || info.Size() <= 0 || info.Size() > stage.SessionExportFileLimit || result.Messages <= 0 || info.Size() != result.HTMLBytes {
return recordFailure("repair export missing, empty, non-normal or oversized")
}
// Mandatory audit repair has its own bounded allowance: at most twenty
// attempts, each capped by SessionExportFileLimit. A full ordinary file
// inventory (count OR bytes) must not prevent recovery of the handoff.
evidence.HTML = name
evidence.HTMLBytes = info.Size()
if err := r.store.RecordDeliverable(persistCtx, id, sequence, protocol.StageArtifact{Name: evidence.HTML, SizeBytes: info.Size(), ContentType: "text/html; charset=utf-8", URL: artifactURL(id, sequence, evidence.HTML)}); err != nil {
return recordFailure(err.Error())
}
}
classifySessionExport(evidence)
if err := r.store.RecordSessionExportRepair(persistCtx, id, sequence, evidence); err != nil {
return nil, err
}
return r.sessionExportUpdatedDetail(persistCtx, id)
}
func (r *runner) sessionExportUpdatedDetail(ctx context.Context, id int64) (*protocol.RunDetail, error) {
detail, err := r.store.GetRun(ctx, id)
if err == nil {
r.emitRun(protocol.RunEventFrame{RunID: id, PipelineID: detail.PipelineID, Name: detail.Name, Title: detail.Title, Version: detail.Version, Workspace: detail.Workspace, Status: detail.Status, ExportPendingSequence: detail.ExportPendingSequence, CurrentStage: detail.CurrentStage, CompletedSteps: detail.CompletedSteps, SessionExportUpdated: true}, true)
}
return detail, err
}