diff --git a/docs/stage-artifacts.md b/docs/stage-artifacts.md index f1dc8969..d1ab20c3 100644 --- a/docs/stage-artifacts.md +++ b/docs/stage-artifacts.md @@ -52,6 +52,36 @@ return `206 Partial Content` with the exact slice (or `416` when unsatisfiable), so images and video can stream. `http.ServeContent` streams from the opened file, so a request never loads the whole file into memory. +## Session export + +When a model stage that ran against an OpenCode harness finishes, the server also +exports the session the harness actually produced and writes it into the same +`///` directory in markdown (`session.md`) and html +(`session.html`). They are ordinary artifacts: the bounded inventory lists them +and `GET /artifacts///session.md` (or `.html`) serves them with no +special casing. + +- Source: the read-only native export path. The native v1 CLI exposes it as + `opencode export `; the installed v2 CLI exposes it as + `opencode session export `. Both reuse the same invocation helper and + session-ID/messages validation as the transcript readback. The files are the + harness's real session, never a reconstruction. +- Bounds: the source read is capped at 8 MiB and each rendered file at 2 MiB. When + either the source or the rendered output is cut, both files carry a visible + truncation banner near the start and the end and the step records + `truncated: true`; a truncated export is never described as whole. +- Evidence: the step records `session_export` (`session_id`, `backend`, `source`, + `markdown`, `html`, `markdown_bytes`, `html_bytes`, `messages`, `truncated`, + `diagnostic`), so `pipelines inspect RUN_ID --json` shows what was written + without reading the files. +- Isolation: exporting never changes the stage's status, outcome, target or + result validation, never waits for the session, never mutates, resumes or + interrupts it, and a failure records a sanitized diagnostic and continues. An + existing `session.md`/`session.html` is never overwritten and the skip reason is + recorded. +- Pi limitation: a Pi stage has no native session export path, so the step records + `source: "unavailable"` with an explicit diagnostic and writes no files. + ## Removal with run history Run artifacts live under `//` and last as long as the run does. diff --git a/internal/author/skill/references/delivery.md b/internal/author/skill/references/delivery.md index ff95884c..46922a67 100644 --- a/internal/author/skill/references/delivery.md +++ b/internal/author/skill/references/delivery.md @@ -17,6 +17,11 @@ with its own rules. oversized file records nothing and never changes the verdict. Never invent an artifact or claim a stage produced one — the server observes the directory after the stage. +- An OpenCode-harness stage also gets its real session exported as `session.md` and + `session.html` in the same directory: bounded (8 MiB source, 2 MiB per file), with + a visible truncation banner and `session_export.truncated` when cut; the step's + `session_export` records the files. Export failures and Pi (no native export path) + record a diagnostic and never fail the run or change the stage result. ## Publish a build to the LAN diff --git a/internal/author/skill/references/operations.md b/internal/author/skill/references/operations.md index fad5e9af..ab000c95 100644 --- a/internal/author/skill/references/operations.md +++ b/internal/author/skill/references/operations.md @@ -224,6 +224,21 @@ traversal, absolute paths, symlink escapes and unknown runs/steps. - Do not invent artifact files or claim a stage produced one without the recorded evidence; the server observes the directory after the stage. +### Session export + +- When an OpenCode-harness model stage finishes, the server exports its real + session read-only (v1 `opencode export `, v2 `opencode session export `) + and writes `session.md` and `session.html` into the same `/` artifacts + directory; they list and serve like any other artifact. +- The source read is capped at 8 MiB and each file at 2 MiB; a cut source or a cut + rendered file carries a visible truncation banner at both ends and + `session_export.truncated: true`, and a truncated export is never called whole. +- The step records `session_export` (`session_id`, `backend`, `source`, file names, + sizes, `messages`, `truncated`, `diagnostic`) in `inspect RUN_ID --json`. +- A failed export, or a Pi stage with no native export path, records a diagnostic + (Pi: `source: "unavailable"`) and never fails the run or changes the stage result. + An existing `session.md`/`session.html` is never overwritten. + ### Operator-only retention Run history and its artifacts are never pruned automatically. The operator-only diff --git a/internal/opencode/chat.go b/internal/opencode/chat.go index f71a9dfe..e91efe0f 100644 --- a/internal/opencode/chat.go +++ b/internal/opencode/chat.go @@ -515,7 +515,10 @@ type nativeChatModel struct { ID string `json:"id"` } -// nativeChatPart is one content element shared by both message envelopes. +// nativeChatPart is one content element shared by both message envelopes. Raw +// keeps the element's original JSON so the session exporter can render an +// unrecognised part type (file, patch, step, ...) instead of dropping it; it is +// ignored when a part is re-encoded. type nativeChatPart struct { Type string `json:"type"` ID string `json:"id"` @@ -524,6 +527,21 @@ type nativeChatPart struct { Executed bool `json:"executed"` State *protocol.ChatToolState `json:"state"` Time *protocol.ChatTime `json:"time"` + Raw json.RawMessage `json:"-"` +} + +// UnmarshalJSON decodes one content part and retains its raw JSON alongside the +// decoded fields, so a part type the decoder does not model is still available +// verbatim to the session exporter. +func (p *nativeChatPart) UnmarshalJSON(data []byte) error { + type part nativeChatPart + var decoded part + if err := json.Unmarshal(data, &decoded); err != nil { + return err + } + *p = nativeChatPart(decoded) + p.Raw = append(p.Raw[:0], data...) + return nil } // role, parts and the accessor methods below read the V2 top-level fields first diff --git a/internal/opencode/export.go b/internal/opencode/export.go new file mode 100644 index 00000000..52e0e9ce --- /dev/null +++ b/internal/opencode/export.go @@ -0,0 +1,236 @@ +package opencode + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// MaxSessionExport bounds the native session readback used for the stage session +// export. A larger session is read as a bounded prefix and reported truncated, +// never presented as the whole session. +const MaxSessionExport = 8 << 20 + +// nativeExportResult is one bounded `opencode export` readback. envelope is the +// stdout prefix the CLI wrote, capped at the caller's limit; truncated is true +// when the CLI wrote more than the cap, so the prefix is not valid whole JSON. +type nativeExportResult struct { + envelope []byte + truncated bool +} + +// exportNative runs the read-only session export CLI once with stdout capped at +// limit bytes. It is the single export invocation shared by Connection.Messages +// and ExportSession; the returned envelope is validated by the one +// validNativeExport check both call. The subcommand follows the backend's +// published interface: the native v1 CLI exposes top-level `export `, while +// the installed v2 CLI exposes it as `session export `. It never writes to, +// resumes or mutates the session, and it does not wait for session idleness. +func exportNative(ctx context.Context, executable, directory, backend, id string, limit int) (nativeExportResult, error) { + if !sessionID.MatchString(id) { + return nativeExportResult{}, fmt.Errorf("invalid session ID") + } + args := []string{"export", id} + if backend == "v2" { + args = []string{"session", "export", id} + } + cmd := CommandContext(ctx, executable, args...) + cmd.Dir = directory + stdout := &boundedOutput{limit: limit} + stderr := &boundedOutput{limit: 8 << 10} + cmd.Stdout = stdout + cmd.Stderr = stderr + if err := cmd.Run(); err != nil { + return nativeExportResult{envelope: stdout.Bytes(), truncated: stdout.overflow}, err + } + return nativeExportResult{envelope: stdout.Bytes(), truncated: stdout.overflow}, nil +} + +// validNativeExport is the exact-ID and messages-array validation +// Connection.Messages and ExportSession share: the envelope must parse, carry an +// info.id equal to wantID and a non-empty JSON messages array. +func validNativeExport(data []byte, wantID string) (json.RawMessage, bool) { + var envelope struct { + Info struct { + ID string `json:"id"` + } `json:"info"` + Messages json.RawMessage `json:"messages"` + } + if json.Unmarshal(data, &envelope) != nil || envelope.Info.ID != wantID || len(envelope.Messages) == 0 || envelope.Messages[0] != '[' { + return nil, false + } + return envelope.Messages, true +} + +// ExportedPart is one decoded content element of an exported session. Raw keeps +// the part's original JSON so an unrecognised type is rendered rather than +// silently dropped; State carries a tool call's status, input, result and error. +type ExportedPart struct { + Type string + ID string + Text string + Name string + State *protocol.ChatToolState + Time *protocol.ChatTime + Raw json.RawMessage +} + +// ExportedMessage is one decoded turn. Every role is kept, not only +// user/assistant, so the export is the session the harness stored. +type ExportedMessage struct { + ID string + Role string + Model string + Agent string + CreatedAt int64 + Parts []ExportedPart +} + +// ExportedSession is one bounded native session readback for the stage session +// export. Truncated is true when the source exceeded MaxSessionExport; Messages +// then covers the complete turns decoded before the cut. +type ExportedSession struct { + ID string + Backend string + Messages []ExportedMessage + Truncated bool +} + +// ExportSession reads the session's native export read-only and decodes it into +// ExportedSession. It reuses the shared export invocation and exact-ID check, +// decodes the v1/v2 message and part shapes through chatMessageRecords and, when +// the source exceeded MaxSessionExport, streams the complete turns decoded from +// the bounded prefix and reports Truncated instead of failing. It performs no +// writes, no resumption, no idleness wait and no retries. +func ExportSession(ctx context.Context, executable, directory, backend, id string) (ExportedSession, error) { + if !sessionID.MatchString(id) { + return ExportedSession{}, fmt.Errorf("invalid session ID") + } + exported, err := exportNative(ctx, executable, directory, backend, id, MaxSessionExport) + if err != nil { + if ctx.Err() != nil { + return ExportedSession{}, ctx.Err() + } + return ExportedSession{}, fmt.Errorf("native session export failed: %w", err) + } + session := ExportedSession{ID: id, Backend: backend} + if !exported.truncated { + messages, ok := validNativeExport(exported.envelope, id) + if !ok { + return ExportedSession{}, fmt.Errorf("native export returned invalid or mismatched session evidence") + } + records, err := chatMessageRecords(messages) + if err != nil { + return ExportedSession{}, err + } + session.Messages = exportedMessages(records) + return session, nil + } + // The source exceeded the cap, so the session is larger than what was read + // and must never be presented as whole. The prefix still yields every turn + // that decoded before the cut. + records, _, err := decodeExportPrefix(exported.envelope, id) + if err != nil { + return ExportedSession{}, err + } + session.Messages = exportedMessages(records) + session.Truncated = true + return session, nil +} + +// exportedMessages maps decoded native turns onto ExportedMessage, preserving +// every role and each part's raw JSON for unknown types. +func exportedMessages(records []nativeChatMessage) []ExportedMessage { + messages := make([]ExportedMessage, 0, len(records)) + for _, record := range records { + message := ExportedMessage{ + ID: record.messageID(), + Role: record.role(), + Model: record.modelID(), + Agent: record.agent(), + CreatedAt: record.createdAt(), + } + for _, part := range record.contentParts() { + message.Parts = append(message.Parts, ExportedPart{ + Type: part.Type, ID: part.ID, Text: part.Text, Name: part.Name, + State: part.State, Time: part.Time, Raw: part.Raw, + }) + } + // A v2 user turn carries its prompt text as a message-level string rather + // than a content array, so surface it as the turn's single text part. + if len(message.Parts) == 0 && message.Role == protocol.ChatRoleUser && record.Text != "" { + message.Parts = append(message.Parts, ExportedPart{Type: protocol.ChatPartText, Text: record.Text}) + } + messages = append(messages, message) + } + return messages +} + +// decodeExportPrefix streams the messages of a bounded export prefix. Complete +// turns decoded before the cut are returned with truncated=true; a mismatched +// info.id is an error so an unrelated session is never exported. +func decodeExportPrefix(data []byte, wantID string) ([]nativeChatMessage, bool, error) { + decoder := json.NewDecoder(bytes.NewReader(data)) + open, err := decoder.Token() + if err != nil { + return nil, false, fmt.Errorf("native export returned invalid session evidence") + } + if delim, ok := open.(json.Delim); !ok || delim != '{' { + return nil, false, fmt.Errorf("native export returned invalid session evidence") + } + var messages []nativeChatMessage + sawMessages := false + for decoder.More() { + keyToken, err := decoder.Token() + if err != nil { + return messages, true, nil + } + key, _ := keyToken.(string) + switch key { + case "info": + var info struct { + ID string `json:"id"` + } + if err := decoder.Decode(&info); err != nil { + return messages, true, nil + } + if info.ID != "" && info.ID != wantID { + return nil, false, fmt.Errorf("native export session id mismatch") + } + case "messages": + sawMessages = true + open, err := decoder.Token() + if err != nil { + return messages, true, nil + } + if delim, ok := open.(json.Delim); !ok || delim != '[' { + return nil, false, fmt.Errorf("native export returned invalid session evidence") + } + for decoder.More() { + var message nativeChatMessage + if err := decoder.Decode(&message); err != nil { + return messages, true, nil + } + messages = append(messages, message) + } + if _, err := decoder.Token(); err != nil { + return messages, true, nil + } + default: + var skip json.RawMessage + if err := decoder.Decode(&skip); err != nil { + return messages, true, nil + } + } + } + if !sawMessages { + return nil, false, fmt.Errorf("native export returned no session messages") + } + if _, err := decoder.Token(); err != nil { + return messages, true, nil + } + return messages, false, nil +} diff --git a/internal/opencode/export_test.go b/internal/opencode/export_test.go new file mode 100644 index 00000000..e90f141c --- /dev/null +++ b/internal/opencode/export_test.go @@ -0,0 +1,159 @@ +package opencode + +import ( + "context" + "path/filepath" + "strings" + "testing" +) + +// exportFixture writes a fake `opencode` CLI that answers only the session +// export invocation with the given JSON body, accepting both the v1 top-level +// `export ` and the v2 `session export ` forms, so the native export +// path is exercised without a real service. +func exportFixture(t *testing.T, id, body string) string { + t.Helper() + script := "#!/bin/sh\n" + + "[ \"$1\" = export ] && shift || { [ \"$1\" = session ] && [ \"$2\" = export ] && shift 2 || exit 8; }\n" + + "[ \"$1\" = " + id + " ] || exit 9\n" + + "cat <<'EOF'\n" + body + "\nEOF\n" + return writeFixture(t, script) +} + +func TestExportSessionDecodesRolesPartsAndUnknownTypes(t *testing.T) { + id := "ses_ok" + body := `{"info":{"id":"ses_ok"},"messages":[` + + `{"info":{"id":"m1","role":"assistant","modelID":"gpt"},"parts":[` + + `{"type":"text","text":"hello"},` + + `{"type":"reasoning","text":"because"},` + + `{"type":"tool","name":"read","state":{"status":"completed","input":{"path":"a.go"},"content":[{"type":"text","text":"ok"}]}},` + + `{"type":"file","uri":"file:///tmp/x"}]},` + + `{"info":{"id":"m2","role":"user"},"text":"hi"}]}` + bin := exportFixture(t, id, body) + session, err := ExportSession(context.Background(), bin, t.TempDir(), "v2", id) + if err != nil { + t.Fatal(err) + } + if session.ID != id || session.Backend != "v2" || session.Truncated { + t.Fatalf("unexpected session: %+v", session) + } + if len(session.Messages) != 2 { + t.Fatalf("messages = %d, want 2", len(session.Messages)) + } + assistant := session.Messages[0] + if assistant.Role != "assistant" || assistant.ID != "m1" || assistant.Model != "gpt" { + t.Fatalf("assistant metadata wrong: %+v", assistant) + } + if len(assistant.Parts) != 4 { + t.Fatalf("assistant parts = %d, want 4 (unknown type kept)", len(assistant.Parts)) + } + if assistant.Parts[0].Type != "text" || assistant.Parts[0].Text != "hello" { + t.Fatalf("text part wrong: %+v", assistant.Parts[0]) + } + if assistant.Parts[1].Type != "reasoning" || assistant.Parts[1].Text != "because" { + t.Fatalf("reasoning part wrong: %+v", assistant.Parts[1]) + } + tool := assistant.Parts[2] + if tool.Type != "tool" || tool.Name != "read" || tool.State == nil || tool.State.Status != "completed" { + t.Fatalf("tool part wrong: %+v", tool) + } + if len(tool.State.Input) == 0 || string(tool.State.Input) != `{"path":"a.go"}` { + t.Fatalf("tool input lost: %s", tool.State.Input) + } + if len(tool.State.Content) != 1 || tool.State.Content[0].Text != "ok" { + t.Fatalf("tool output lost: %+v", tool.State.Content) + } + unknown := assistant.Parts[3] + if unknown.Type != "file" || !strings.Contains(string(unknown.Raw), "file:///tmp/x") { + t.Fatalf("unknown part raw JSON lost: %+v", unknown) + } + user := session.Messages[1] + if user.Role != "user" || len(user.Parts) != 1 || user.Parts[0].Text != "hi" { + t.Fatalf("user message-level text not surfaced: %+v", user) + } +} + +func TestExportSessionRejectsMismatchedOrInvalidID(t *testing.T) { + bin := exportFixture(t, "ses_other", `{"info":{"id":"ses_other"},"messages":[{"info":{"role":"assistant"}}]}`) + if _, err := ExportSession(context.Background(), bin, t.TempDir(), "v2", "ses_want"); err == nil { + t.Fatal("mismatched session export accepted") + } + if _, err := ExportSession(context.Background(), bin, t.TempDir(), "v2", "not-a-session"); err == nil { + t.Fatal("invalid session id accepted without running the CLI") + } +} + +func TestExportSessionFailsSanitizedWhenCLIUnavailable(t *testing.T) { + bin := filepath.Join(t.TempDir(), "absent-opencode") + if _, err := ExportSession(context.Background(), bin, t.TempDir(), "v2", "ses_ok"); err == nil { + t.Fatal("missing CLI must fail the export") + } +} + +func TestExportNativeReportsBoundedOverflow(t *testing.T) { + id := "ses_ok" + body := `{"info":{"id":"ses_ok"},"messages":[{"info":{"role":"assistant"},"parts":[{"type":"text","text":"` + strings.Repeat("x", 256) + `"}]}]}` + bin := exportFixture(t, id, body) + res, err := exportNative(context.Background(), bin, t.TempDir(), "v2", id, 32) + if err != nil { + t.Fatal(err) + } + if !res.truncated { + t.Fatal("bounded stdout overflow was not reported") + } + if len(res.envelope) != 32 { + t.Fatalf("bounded prefix = %d bytes, want 32", len(res.envelope)) + } +} + +func TestExportNativeUsesBackendSubcommand(t *testing.T) { + id := "ses_ok" + body := `{"info":{"id":"ses_ok"},"messages":[{"info":{"role":"assistant"},"parts":[{"type":"text","text":"hello"}]}]}` + bin := exportFixture(t, id, body) + // Both a v1 (top-level export) and a v2 (session export) CLI accept the one + // shared invocation. + for _, backend := range []string{"v1", "v2"} { + session, err := ExportSession(context.Background(), bin, t.TempDir(), backend, id) + if err != nil || len(session.Messages) != 1 { + t.Fatalf("backend %s export failed: %v %+v", backend, err, session) + } + } +} + +func TestExportSessionKeepsCompleteTurnsFromOverCapSource(t *testing.T) { + id := "ses_ok" + huge := strings.Repeat("x", MaxSessionExport+(1<<20)) + body := `{"info":{"id":"ses_ok"},"messages":[` + + `{"info":{"role":"assistant"},"parts":[{"type":"text","text":"first"}]},` + + `{"info":{"role":"user"},"parts":[{"type":"text","text":"` + huge + `"}]}]}` + bin := exportFixture(t, id, body) + session, err := ExportSession(context.Background(), bin, t.TempDir(), "v2", id) + if err != nil { + t.Fatal(err) + } + if !session.Truncated { + t.Fatal("an over-cap source must be reported truncated") + } + if len(session.Messages) != 1 || session.Messages[0].Parts[0].Text != "first" { + t.Fatalf("complete turn before the cut was lost: %+v", session.Messages) + } +} + +func TestDecodeExportPrefixRejectsMismatchedID(t *testing.T) { + id := "ses_ok" + full := `{"info":{"id":"ses_ok"},"messages":[` + + `{"info":{"role":"assistant"},"parts":[{"type":"text","text":"first"}]},` + + `{"info":{"role":"user"},"parts":[{"type":"text","text":"second"}]}]}` + // Cut mid-way through the second message so only the first is complete. + cut := strings.Index(full, `"second"`) + len(`"second"`) - 3 + records, truncated, err := decodeExportPrefix([]byte(full[:cut]), id) + if err != nil { + t.Fatal(err) + } + if !truncated || len(records) != 1 || records[0].role() != "assistant" { + t.Fatalf("prefix decode = %d records, truncated=%v", len(records), truncated) + } + if _, _, err := decodeExportPrefix([]byte(full), "ses_other"); err == nil { + t.Fatal("mismatched prefix session accepted") + } +} diff --git a/internal/opencode/messages.go b/internal/opencode/messages.go index 71318c3b..db7105b5 100644 --- a/internal/opencode/messages.go +++ b/internal/opencode/messages.go @@ -3,9 +3,9 @@ package opencode import ( "bytes" "context" - "encoding/json" "errors" "fmt" + "io" "strings" ) @@ -26,6 +26,30 @@ func (b *boundedOutput) Write(p []byte) (int, error) { return n, nil } +// ReadFrom reads through the bounded Write so the cap applies even when +// os/exec's io.Copy selects a ReadFrom on the destination: without this the +// embedded bytes.Buffer's promoted ReadFrom would bypass Write and buffer the +// whole output without bound, making overflow (and the truncation path) dead. +func (b *boundedOutput) ReadFrom(r io.Reader) (int64, error) { + var total int64 + buffer := make([]byte, 32<<10) + for { + n, err := r.Read(buffer) + if n > 0 { + if _, writeErr := b.Write(buffer[:n]); writeErr != nil { + return total, writeErr + } + total += int64(n) + } + if err != nil { + if errors.Is(err, io.EOF) { + return total, nil + } + return total, err + } + } +} + // Messages preserves old sessions with native OutputFormat readback failures: // the CLI export reads the local stored data without that HTTP encoder. It does // not regenerate, repair the database, delete history or change conversations. @@ -48,12 +72,8 @@ func (c *Connection) Messages(ctx context.Context, id string) ([]byte, error) { if executable == "" { executable = Executable() } - cmd := CommandContext(ctx, executable, "export", id) - cmd.Dir = c.Directory - stdout, stderr := &boundedOutput{limit: MaxResponse}, &boundedOutput{limit: 8 << 10} - cmd.Stdout = stdout - cmd.Stderr = stderr - if exportErr := cmd.Run(); exportErr != nil { + res, exportErr := exportNative(ctx, executable, c.Directory, c.Backend, id, MaxResponse) + if exportErr != nil { if ctx.Err() != nil { return data, ctx.Err() } @@ -61,18 +81,13 @@ func (c *Connection) Messages(ctx context.Context, id string) ([]byte, error) { // preserving exec.ErrWaitDelay from a descendant-held output pipe. return data, errors.Join(err, fmt.Errorf("read-only native export fallback failed: %w", exportErr)) } - if stdout.overflow { + if res.truncated { return data, fmt.Errorf("%w; native export exceeds 1 MiB evidence limit", err) } - var exported struct { - Info struct { - ID string `json:"id"` - } `json:"info"` - Messages json.RawMessage `json:"messages"` - } - if json.Unmarshal(stdout.Bytes(), &exported) != nil || exported.Info.ID != id || len(exported.Messages) == 0 || exported.Messages[0] != '[' { + messages, ok := validNativeExport(res.envelope, id) + if !ok { return data, fmt.Errorf("%w; native export returned invalid or mismatched session evidence", err) } c.MessageReadbackDiagnostic = "Native HTTP message readback rejected stored OutputFormat (HTTP 400); read-only CLI export recovered the original messages without modifying the session." - return exported.Messages, nil + return messages, nil } diff --git a/internal/pipeline/retention.go b/internal/pipeline/retention.go index 26a0c533..56226ed3 100644 --- a/internal/pipeline/retention.go +++ b/internal/pipeline/retention.go @@ -625,6 +625,7 @@ func deleteRetentionRows(ctx context.Context, tx *sql.Tx, ids []int64) error { {"step_control", "run_id"}, {"step_artifacts", "run_id"}, {"step_verdicts", "run_id"}, + {"step_session_exports", "run_id"}, {"run_session_owners", "run_id"}, {"run_steps", "run_id"}, } { diff --git a/internal/pipeline/runs.go b/internal/pipeline/runs.go index 783ced52..01cdbc0d 100644 --- a/internal/pipeline/runs.go +++ b/internal/pipeline/runs.go @@ -47,6 +47,9 @@ PRIMARY KEY(run_id,sequence), FOREIGN KEY(run_id,sequence) REFERENCES run_steps( CREATE TABLE IF NOT EXISTS step_verdicts ( run_id INTEGER NOT NULL, sequence INTEGER NOT NULL, verdict_json TEXT NOT NULL, PRIMARY KEY(run_id,sequence), FOREIGN KEY(run_id,sequence) REFERENCES run_steps(run_id,sequence)); +CREATE TABLE IF NOT EXISTS step_session_exports ( +run_id INTEGER NOT NULL, sequence INTEGER NOT NULL, export_json TEXT NOT NULL, +PRIMARY KEY(run_id,sequence), FOREIGN KEY(run_id,sequence) REFERENCES run_steps(run_id,sequence)); CREATE TABLE IF NOT EXISTS run_session_owners ( run_id INTEGER NOT NULL, sequence INTEGER NOT NULL, backend TEXT NOT NULL, reference TEXT NOT NULL DEFAULT '', PRIMARY KEY(run_id,sequence), FOREIGN KEY(run_id,sequence) REFERENCES run_steps(run_id,sequence)); @@ -343,6 +346,7 @@ COALESCE((SELECT receipts_json FROM step_notifications n WHERE n.run_id=run_step COALESCE((SELECT changes_json FROM step_file_changes f WHERE f.run_id=run_steps.run_id AND f.sequence=run_steps.sequence),'null'), COALESCE((SELECT artifacts_json FROM step_artifacts a WHERE a.run_id=run_steps.run_id AND a.sequence=run_steps.sequence),'null'), COALESCE((SELECT verdict_json FROM step_verdicts v WHERE v.run_id=run_steps.run_id AND v.sequence=run_steps.sequence),''), +COALESCE((SELECT export_json FROM step_session_exports x WHERE x.run_id=run_steps.run_id AND x.sequence=run_steps.sequence),''), strftime('%Y-%m-%dT%H:%M:%SZ',started_at),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',finished_at),'') FROM run_steps WHERE run_id=? ORDER BY sequence`, id) if err != nil { return nil, err @@ -351,8 +355,8 @@ strftime('%Y-%m-%dT%H:%M:%SZ',started_at),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ' for rows.Next() { var step protocol.RunStep var notifications string - var fileChanges, artifacts, storedVerdict string - if err := rows.Scan(&step.Sequence, &step.Stage, &step.Status, &step.Outcome, &step.Target, &input, &output, &step.Diagnostic, &step.SessionID, &step.AgentActive, &step.Transcript, &step.Provider, &step.Model, ¬ifications, &fileChanges, &artifacts, &storedVerdict, &step.StartedAt, &step.FinishedAt); err != nil { + var fileChanges, artifacts, storedVerdict, sessionExport string + if err := rows.Scan(&step.Sequence, &step.Stage, &step.Status, &step.Outcome, &step.Target, &input, &output, &step.Diagnostic, &step.SessionID, &step.AgentActive, &step.Transcript, &step.Provider, &step.Model, ¬ifications, &fileChanges, &artifacts, &storedVerdict, &sessionExport, &step.StartedAt, &step.FinishedAt); err != nil { rows.Close() return nil, err } @@ -394,6 +398,12 @@ strftime('%Y-%m-%dT%H:%M:%SZ',started_at),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ' } } step.Verdict = protocol.NewStageVerdict(step.Outcome, step.Target, step.Output, step.Artifacts, stored.Reason, stored.Source) + if sessionExport != "" { + if err := json.Unmarshal([]byte(sessionExport), &step.SessionExport); err != nil { + rows.Close() + return nil, err + } + } // Loaded below after the rows cursor closes to preserve SQLite connection use. r.Steps = append(r.Steps, step) } @@ -634,6 +644,15 @@ WHERE run_id=? AND sequence=? AND status='running'`, step.Status, step.Outcome, return err } } + if step.SessionExport != nil { + data, err := json.Marshal(step.SessionExport) + if err != nil { + return err + } + if _, err := tx.ExecContext(ctx, "INSERT INTO step_session_exports(run_id,sequence,export_json) VALUES(?,?,?)", id, step.Sequence, string(data)); err != nil { + return err + } + } return tx.Commit() } diff --git a/internal/pipeline/runs_test.go b/internal/pipeline/runs_test.go index b18c5194..043dcfd6 100644 --- a/internal/pipeline/runs_test.go +++ b/internal/pipeline/runs_test.go @@ -446,3 +446,63 @@ func TestOwnedSessionsListsRecordedWithActiveFlag(t *testing.T) { t.Fatalf("ActiveSessionOwners = %+v %v, want both now-active sessions", active, err) } } + +// TestSessionExportRoundTripAndAbsentEvidence proves a recorded session export +// survives FinishStep/GetRun and that a step with no export row (an old database +// that gained the empty table on Open) loads with no export evidence. +func TestSessionExportRoundTripAndAbsentEvidence(t *testing.T) { + ctx := context.Background() + store, err := Open(filepath.Join(t.TempDir(), "session-exports.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if _, err := store.Submit(ctx, "exports", Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := store.List(ctx) + definition, _ := store.Get(ctx, items[0].ID, 1) + withExport, _, err := store.CreateRun(ctx, definition, "with-export", "workspace", false, nil, map[string]any{"prompt": "task"}) + if err != nil { + t.Fatal(err) + } + withoutExport, _, err := store.CreateRun(ctx, definition, "without-export", "workspace", false, nil, map[string]any{"prompt": "task"}) + if err != nil { + t.Fatal(err) + } + for _, id := range []int64{withExport, withoutExport} { + if err := store.BeginStep(ctx, id, 1, "one", map[string]any{"prompt": "task"}); err != nil { + t.Fatal(err) + } + } + want := &protocol.SessionExport{ + SessionID: "ses_recorded", Backend: "v2", Source: "native_export", + Markdown: "session.md", HTML: "session.html", + MarkdownBytes: 1234, HTMLBytes: 2345, Messages: 9, Truncated: true, + Diagnostic: "kept", + } + if err := store.FinishStep(ctx, withExport, protocol.RunStep{Sequence: 1, Stage: "one", Status: "completed", Outcome: "success", Output: map[string]any{}, Transcript: strings.Repeat("x", 40<<10), SessionExport: want}); err != nil { + t.Fatal(err) + } + if err := store.FinishStep(ctx, withoutExport, protocol.RunStep{Sequence: 1, Stage: "one", Status: "completed", Outcome: "success", Output: map[string]any{}}); err != nil { + t.Fatal(err) + } + got, err := store.GetRun(ctx, withExport) + if err != nil { + t.Fatal(err) + } + if len(got.Steps) != 1 || got.Steps[0].SessionExport == nil || *got.Steps[0].SessionExport != *want { + t.Fatalf("session export did not round-trip: %+v", got.Steps[0].SessionExport) + } + // The export evidence must not change how the transcript is bounded. + if len(got.Steps[0].Transcript) > 32<<10 || !strings.Contains(got.Steps[0].Transcript, "truncated") { + t.Fatalf("transcript bound changed by export: %d bytes", len(got.Steps[0].Transcript)) + } + plain, err := store.GetRun(ctx, withoutExport) + if err != nil { + t.Fatal(err) + } + if plain.Steps[0].SessionExport != nil { + t.Fatalf("absent export evidence was fabricated: %+v", plain.Steps[0].SessionExport) + } +} diff --git a/internal/protocol/runs.go b/internal/protocol/runs.go index 4c229b9c..3be505e1 100644 --- a/internal/protocol/runs.go +++ b/internal/protocol/runs.go @@ -100,6 +100,23 @@ type SessionEvidence struct { Diagnostic string `json:"diagnostic,omitempty"` } +// SessionExport is the recorded evidence of one stage's session file export: +// the file names written under the step's artifacts directory, their byte sizes, +// the decoded message count, the source, whether the export was truncated and a +// sanitized diagnostic. It is observed server-side evidence, not a model claim. +type SessionExport struct { + SessionID string `json:"session_id,omitempty"` + Backend string `json:"backend,omitempty"` + Source string `json:"source,omitempty"` + Markdown string `json:"markdown,omitempty"` + HTML string `json:"html,omitempty"` + MarkdownBytes int64 `json:"markdown_bytes,omitempty"` + HTMLBytes int64 `json:"html_bytes,omitempty"` + Messages int `json:"messages"` + Truncated bool `json:"truncated,omitempty"` + Diagnostic string `json:"diagnostic,omitempty"` +} + type RunSummary struct { ID int64 `json:"id"` PipelineID int64 `json:"pipeline_id"` @@ -142,6 +159,7 @@ type RunStep struct { Control *ControlEvidence `json:"control,omitempty"` FileChanges *StageFileChanges `json:"file_changes,omitempty"` Verdict *StageVerdict `json:"verdict,omitempty"` + SessionExport *SessionExport `json:"session_export,omitempty"` Notifications []NotificationReceipt `json:"notifications,omitempty"` Artifacts []StageArtifact `json:"artifacts,omitempty"` Sequence int `json:"sequence"` diff --git a/internal/server/runner.go b/internal/server/runner.go index 09131e4a..3df08bf1 100644 --- a/internal/server/runner.go +++ b/internal/server/runner.go @@ -46,9 +46,13 @@ type runner struct { verdict func(context.Context, map[string]any) string // events pushes run state deltas to subscribed clients. When nil (tests that // build a runner directly) emits are dropped, so nothing else changes. - events *runEventHub - wg sync.WaitGroup - schedulerWG sync.WaitGroup + events *runEventHub + // exportSession writes a finished stage's session into its own artifacts + // directory. It defaults to stage.ExportSession; a failure is best-effort and + // never changes the stage's status, outcome, target or result validation. + exportSession func(context.Context, stage.SessionExportRequest) (stage.SessionExportResult, error) + wg sync.WaitGroup + schedulerWG sync.WaitGroup // attentionMu guards attentionSent, the per-run set of run-attention events // already delivered — by a stage's own notify policy or by the run-level // default — so neither republishes the same genuine event. @@ -78,7 +82,7 @@ func newRunner(ctx context.Context, s *pipeline.Store) (*runner, error) { return nil, err } root := filepath.Join(s.Directory(), "artifacts") - return &runner{ctx: ctx, store: s, artifactsRoot: root, active: map[int64]activeRun{}, attentionSent: map[int64]map[string]bool{}}, nil + return &runner{ctx: ctx, store: s, artifactsRoot: root, active: map[int64]activeRun{}, attentionSent: map[int64]map[string]bool{}, exportSession: stage.ExportSession}, nil } func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.RunDetail, error) { @@ -956,8 +960,19 @@ func (r *runner) runLoop(ctx context.Context, id int64, graph protocol.Graph, na changes.Status = "partial" changes.Diagnostic = "Agent cleanup was not confirmed; files may still be changing." } + // Export the stage's session into its own artifacts directory before the + // bounded scan, so the existing listing and serving paths find the files + // with no special casing. This is bounded, best-effort evidence: it never + // waits for session idleness and a failure never changes the stage's + // status, outcome, target or result validation. + var sessionExport *protocol.SessionExport + if artifactsDir != "" { + if owner, ownerErr := r.store.RunSessionOwner(ctx, id, sequence); ownerErr == nil && owner.ID != "" { + sessionExport = r.exportStageSession(ctx, owner, artifactsDir, id, sequence, key, modelConfig) + } + } artifacts, artifactsSkipped, artifactsTruncated := r.scanArtifacts(id, sequence, artifactsDir) - step := protocol.RunStep{Sequence: sequence, Stage: key, Status: "completed", Outcome: result.Outcome, Output: result.Output, Transcript: operations.Transcript(client.Transcript), SessionID: stageSession, FileChanges: changes, Artifacts: artifacts, ArtifactsSkipped: artifactsSkipped, ArtifactsTruncated: artifactsTruncated} + step := protocol.RunStep{Sequence: sequence, Stage: key, Status: "completed", Outcome: result.Outcome, Output: result.Output, Transcript: operations.Transcript(client.Transcript), SessionID: stageSession, FileChanges: changes, SessionExport: sessionExport, Artifacts: artifacts, ArtifactsSkipped: artifactsSkipped, ArtifactsTruncated: artifactsTruncated} // Stamp the effective provider/model this visit actually ran with for every // model stage, including failures, so the app/TUI evidence reflects any // override. Non-model stages keep empty values. @@ -1058,6 +1073,53 @@ func (r *runner) runLoop(ctx context.Context, id int64, graph protocol.Graph, na finish("failed", "error", "total stage budget exceeded") } +// exportStageSession writes the finished stage's session into its own artifacts +// directory and returns the evidence for the step. A non-OpenCode harness (pi) +// has no native export path, so it records that limitation and writes no files. +// Any export error is recorded as a sanitized diagnostic and never returned to +// the stage: the export is read-only, bounded and best-effort. +func (r *runner) exportStageSession(ctx context.Context, owner pipeline.SessionOwner, artifactsDir string, runID int64, sequence int, key string, modelConfig stage.ModelConfig) *protocol.SessionExport { + evidence := &protocol.SessionExport{SessionID: owner.ID, Backend: owner.Backend} + if owner.Backend != "v1" && owner.Backend != "v2" { + evidence.Source = "unavailable" + evidence.Diagnostic = "session export unavailable: harness has no native export path" + return evidence + } + export := r.exportSession + if export == nil { + export = stage.ExportSession + } + // A canceled stage still gets one bounded, non-blocking attempt; the export + // never consumes the stage timeout and never waits for the session. + exportCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), stage.SessionExportTimeout) + defer cancel() + result, err := export(exportCtx, stage.SessionExportRequest{ + SessionID: owner.ID, + Backend: owner.Backend, + Directory: owner.Directory, + ArtifactsDir: artifactsDir, + RunID: runID, + Sequence: sequence, + Stage: key, + Provider: modelConfig.Provider, + Model: modelConfig.Model, + }) + if err != nil { + evidence.Source = "native_export" + evidence.Diagnostic = stage.RedactEvidence(err.Error()) + return evidence + } + evidence.Source = result.Source + evidence.Markdown = result.Markdown + evidence.HTML = result.HTML + evidence.MarkdownBytes = result.MarkdownBytes + evidence.HTMLBytes = result.HTMLBytes + evidence.Messages = result.Messages + evidence.Truncated = result.Truncated + evidence.Diagnostic = result.Diagnostic + return evidence +} + // setTitle renames a run: it replaces the stored operator-facing title without // touching the run's input, steps or execution, then returns the updated detail. func (r *runner) setTitle(id int64, title string) (*protocol.RunDetail, error) { diff --git a/internal/server/session_export_live_test.go b/internal/server/session_export_live_test.go new file mode 100644 index 00000000..f6a73fe0 --- /dev/null +++ b/internal/server/session_export_live_test.go @@ -0,0 +1,168 @@ +package server + +import ( + "context" + "fmt" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" + "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" +) + +// sessionExportLiveSource is a one-stage pipeline that declares the read tool so +// the stage runs as an agent (the V2 path that persists session messages) while +// the prompt tells it not to use any tool. +func sessionExportLiveSource(provider, model string) string { + return "# stage one\n\n```output\n{ summary }\n```\n\n" + + "```prompt\nReturn success with summary exactly: session export live check. Do not use any tool.\n```\n\n" + + "```tools\nread\n```\n\n" + + "```configs\nprovider=" + provider + "\nmodel=" + model + "\nretries=0\ntimeout=2m\n```\n\n" + + "```edges\nsuccess -> #success\nerror -> #failure\n```\n\n" +} + +// TestSessionExportLive is an opt-in live check: it runs one real OpenCode stage +// on a temporary store and artifacts root using the configured host harness, +// then proves the real session.md/session.html are written, listed and served +// 200. It is gated so the default suite never spends inference. +func TestSessionExportLive(t *testing.T) { + if os.Getenv("PIPELINES_SESSION_EXPORT_LIVE") != "1" { + t.Skip("set PIPELINES_SESSION_EXPORT_LIVE=1 and PIPELINES_SESSION_EXPORT_MODEL to run chargeable session-export inference") + } + model := os.Getenv("PIPELINES_SESSION_EXPORT_MODEL") + provider, id, ok := strings.Cut(model, "/") + if !ok || !stage.ValidModel(provider, id) { + t.Fatal("explicit valid PIPELINES_SESSION_EXPORT_MODEL required") + } + // Isolate notifications from the operator's real ntfy service. + endpoint := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"id":"session-export-live-receipt","event":"message"}`) + })) + defer endpoint.Close() + t.Setenv("PIPELINES_NTFY_URL", endpoint.URL+"/live") + t.Setenv("PIPELINES_NTFY_TOKEN", "") + t.Setenv("PIPELINES_NTFY_TOKEN_FILE", "") + + ctx, cancel := context.WithTimeout(context.Background(), 6*time.Minute) + defer cancel() + root := t.TempDir() + store, err := pipeline.Open(filepath.Join(root, "runs.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if _, err := store.Submit(ctx, "session-export-live", sessionExportLiveSource(provider, id)); err != nil { + t.Fatal(err) + } + items, err := store.List(ctx) + if err != nil { + t.Fatal(err) + } + handler := Handler(ctx, store).(*runHandler) + handler.runner.artifactsRoot = filepath.Join(root, "artifacts") + defer func() { cancel(); WaitRuns(handler) }() + workspace := filepath.Join(root, "ws") + if err := os.Mkdir(workspace, 0700); err != nil { + t.Fatal(err) + } + run, err := handler.runner.start(protocol.Message{ + PipelineID: items[0].ID, Version: 1, RequestKey: "session-export-live", + Workspace: workspace, Input: map[string]any{"prompt": "Return the fixed session export live check."}, + }) + if err != nil { + t.Fatal(err) + } + handler.runner.wg.Wait() + detail, err := store.GetRun(context.Background(), run.ID) + if err != nil { + t.Fatal(err) + } + if detail.Status != "succeeded" || len(detail.Steps) != 1 { + t.Fatalf("live run did not succeed: %+v", detail) + } + step := detail.Steps[0] + if step.SessionExport == nil || step.SessionExport.Source != "native_export" || step.SessionExport.MarkdownBytes == 0 || step.SessionExport.HTMLBytes == 0 { + t.Fatalf("live session export evidence missing: %+v", step.SessionExport) + } + if step.SessionExport.Messages == 0 || step.SessionExport.Truncated { + t.Fatalf("live session export was empty or truncated: %+v", step.SessionExport) + } + srv := httptest.NewServer(handler) + defer srv.Close() + for _, name := range []string{"session.md", "session.html"} { + artifact, ok := artifactNamed(step.Artifacts, name) + if !ok { + t.Fatalf("%s not in live artifact listing: %+v", name, step.Artifacts) + } + resp, err := http.Get(srv.URL + artifact.URL) + if err != nil { + t.Fatal(err) + } + body, _ := io.ReadAll(resp.Body) + resp.Body.Close() + if resp.StatusCode != http.StatusOK { + t.Fatalf("%s served HTTP %d", name, resp.StatusCode) + } + path := filepath.Join(handler.runner.artifactsRoot, fmt.Sprint(run.ID), "1", name) + if evidenceDir := os.Getenv("PIPELINES_SESSION_EXPORT_LIVE_DIR"); evidenceDir != "" { + if err := os.MkdirAll(evidenceDir, 0700); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(evidenceDir, name), body, 0600); err != nil { + t.Fatal(err) + } + } + first := string(body) + if idx := strings.IndexByte(first, '\n'); idx >= 0 { + first = first[:idx] + } + t.Logf("live export %s: path=%s size=%d messages=%d url=%s http=%d first_line=%q", name, path, len(body), step.SessionExport.Messages, artifact.URL, resp.StatusCode, first) + } +} + +// TestSessionExportRecorded is the fallback evidence path: with no chargeable +// inference, it exports one real recorded session read-only through the same +// code path, clearly labelled as not produced by a fresh runner stage. +func TestSessionExportRecorded(t *testing.T) { + session := os.Getenv("PIPELINES_SESSION_EXPORT_RECORDED_ID") + if session == "" { + t.Skip("set PIPELINES_SESSION_EXPORT_RECORDED_ID and _DIR to export a recorded session read-only (no inference)") + } + dir := os.Getenv("PIPELINES_SESSION_EXPORT_RECORDED_DIR") + if dir == "" { + t.Fatal("PIPELINES_SESSION_EXPORT_RECORDED_DIR required") + } + if err := os.MkdirAll(dir, 0700); err != nil { + t.Fatal(err) + } + result, err := stage.ExportSession(context.Background(), stage.SessionExportRequest{ + SessionID: session, Backend: "v2", Directory: dir, ArtifactsDir: dir, + RunID: 0, Sequence: 0, Stage: "recorded", + }) + if err != nil { + t.Fatalf("recorded session export failed: %v", err) + } + for _, name := range []string{stage.SessionMarkdownFile, stage.SessionHTMLFile} { + info, err := os.Stat(filepath.Join(dir, name)) + if err != nil { + t.Fatal(err) + } + data, _ := os.ReadFile(filepath.Join(dir, name)) + first := string(data) + if idx := strings.IndexByte(first, '\n'); idx >= 0 { + first = first[:idx] + } + t.Logf("recorded export (NOT a fresh runner stage) %s: path=%s size=%d first_line=%q", name, filepath.Join(dir, name), info.Size(), first) + } + if result.MarkdownBytes == 0 || result.HTMLBytes == 0 { + t.Fatalf("recorded export wrote no files: %+v", result) + } +} diff --git a/internal/server/session_export_test.go b/internal/server/session_export_test.go new file mode 100644 index 00000000..fae4ad01 --- /dev/null +++ b/internal/server/session_export_test.go @@ -0,0 +1,222 @@ +package server + +import ( + "context" + "errors" + "fmt" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" + + "git.a-wan.net/alan/pipelines/internal/pipeline" + "git.a-wan.net/alan/pipelines/internal/protocol" + "git.a-wan.net/alan/pipelines/internal/stage" +) + +// sessionExportBody is a minimal native export envelope with a user and an +// assistant turn, used by the fake CLI below. +const sessionExportBody = `{"info":{"id":"ses_run"},"messages":[` + + `{"info":{"id":"m1","role":"user"},"text":"do the task"},` + + `{"info":{"id":"m2","role":"assistant"},"parts":[` + + `{"type":"text","text":"done"},` + + `{"type":"tool","name":"shell","state":{"status":"completed","input":{"cmd":"ls"},"content":[{"type":"text","text":"output here"}]}}]}]}` + +// sessionExportCLI points PIPELINES_OPENCODE at a fake `opencode export` that +// returns sessionExportBody, so the runner's real export path runs. +func sessionExportCLI(t *testing.T) { + t.Helper() + path := filepath.Join(t.TempDir(), "opencode") + script := "#!/bin/sh\n" + + "[ \"$1\" = export ] && shift || { [ \"$1\" = session ] && [ \"$2\" = export ] && shift 2 || exit 8; }\n" + + "[ \"$1\" = ses_run ] || exit 9\n" + + "cat <<'EOF'\n" + sessionExportBody + "\nEOF\n" + if err := os.WriteFile(path, []byte(script), 0700); err != nil { + t.Fatal(err) + } + t.Setenv("PIPELINES_OPENCODE", path) +} + +// sessionExportRunner runs one stage that records a session for the run, so the +// runner's post-stage export has an owner to read. The export seam is supplied by +// the caller; ready gates the stage until the test has captured the run id. +func sessionExportRunner(t *testing.T, backend string, seam func(stage.SessionExportRequest) (stage.SessionExportResult, error)) (*runHandler, *pipeline.Store, int64) { + t.Helper() + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + store, err := pipeline.Open(filepath.Join(t.TempDir(), "session.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { store.Close() }) + if _, err := store.Submit(ctx, "session-export", pipeline.Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, err := store.List(ctx) + if err != nil { + t.Fatal(err) + } + handler := Handler(ctx, store).(*runHandler) + t.Cleanup(func() { cancel(); WaitRuns(handler) }) + handler.runner.artifactsRoot = t.TempDir() + if seam != nil { + handler.runner.exportSession = func(_ context.Context, request stage.SessionExportRequest) (stage.SessionExportResult, error) { + return seam(request) + } + } + ready := make(chan struct{}) + var runID int64 + handler.runner.execute = func(ctx context.Context, _ stage.Definition, _ stage.Values) (stage.Result, error) { + <-ready + if err := handler.runner.store.RunSession(ctx, runID, 1, "ses_run", true, backend, ""); err != nil { + return stage.Result{}, err + } + return stage.Result{Outcome: "success", Output: stage.Values{"summary": "done"}}, nil + } + run, err := handler.runner.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "session", Workspace: t.TempDir(), Input: map[string]any{"prompt": "task"}}) + if err != nil { + t.Fatal(err) + } + runID = run.ID + close(ready) + handler.runner.wg.Wait() + return handler, store, run.ID +} + +// TestRunnerExportsSessionFilesIntoArtifactsAndServesThem proves the real export +// path writes both files into the step's artifacts directory, lists them with +// artifact URLs and serves them 200, without changing the step's status, outcome +// or target. +func TestRunnerExportsSessionFilesIntoArtifactsAndServesThem(t *testing.T) { + sessionExportCLI(t) + handler, store, runID := sessionExportRunner(t, "v2", nil) + detail, err := store.GetRun(context.Background(), runID) + if err != nil { + t.Fatal(err) + } + if detail.Status != "succeeded" || len(detail.Steps) != 1 { + t.Fatalf("unexpected run: %+v", detail) + } + step := detail.Steps[0] + if step.Status != "completed" || step.Outcome != "success" { + t.Fatalf("export changed the stage result: %+v", step) + } + if len(step.Transcript) > 32<<10 || strings.Contains(step.Transcript, "do the task") || strings.Contains(step.Transcript, "session.md") { + t.Fatalf("transcript was changed by the export: %q", step.Transcript) + } + if step.SessionExport == nil || step.SessionExport.SessionID != "ses_run" || step.SessionExport.Source != "native_export" { + t.Fatalf("export evidence missing: %+v", step.SessionExport) + } + if step.SessionExport.Messages != 2 || step.SessionExport.MarkdownBytes == 0 || step.SessionExport.HTMLBytes == 0 { + t.Fatalf("export evidence wrong: %+v", step.SessionExport) + } + for _, name := range []string{"session.md", "session.html"} { + artifact, ok := artifactNamed(step.Artifacts, name) + if !ok { + t.Fatalf("%s not in the artifact listing: %+v", name, step.Artifacts) + } + wantURL := fmt.Sprintf("/artifacts/%d/1/%s", runID, name) + if artifact.URL != wantURL || artifact.SizeBytes == 0 { + t.Fatalf("%s listing wrong: %+v", name, artifact) + } + } + + srv := httptest.NewServer(handler) + defer srv.Close() + for _, name := range []string{"session.md", "session.html"} { + resp, err := http.Get(srv.URL + fmt.Sprintf("/artifacts/%d/1/%s", runID, name)) + if err != nil { + t.Fatal(err) + } + body, _ := io.ReadAll(resp.Body) + resp.Body.Close() + if resp.StatusCode != http.StatusOK || len(body) == 0 { + t.Fatalf("%s served %d (%d bytes)", name, resp.StatusCode, len(body)) + } + contentType := resp.Header.Get("Content-Type") + if name == "session.md" && !strings.HasPrefix(contentType, "text/markdown") && !strings.HasPrefix(contentType, "text/plain") { + t.Fatalf("session.md content type = %q", contentType) + } + if name == "session.html" && !strings.HasPrefix(contentType, "text/html") { + t.Fatalf("session.html content type = %q", contentType) + } + if name == "session.md" && !strings.Contains(string(body), "do the task") { + t.Fatalf("served markdown missing session text") + } + if name == "session.html" && !strings.Contains(string(body), "output here") { + t.Fatalf("served html missing tool output") + } + } +} + +// TestRunnerSessionExportFailureTruncationAndUnavailableHarness proves the three +// non-success export outcomes are recorded as evidence and never fail the run. +func TestRunnerSessionExportFailureTruncationAndUnavailableHarness(t *testing.T) { + cases := []struct { + name string + backend string + seam func(stage.SessionExportRequest) (stage.SessionExportResult, error) + wantSrc string + wantDiag string + wantTrunc bool + }{ + { + name: "failure", + backend: "v2", + seam: func(stage.SessionExportRequest) (stage.SessionExportResult, error) { + return stage.SessionExportResult{}, errors.New("native session export failed") + }, + wantSrc: "native_export", + wantDiag: "native session export failed", + }, + { + name: "truncated", + backend: "v2", + seam: func(stage.SessionExportRequest) (stage.SessionExportResult, error) { + return stage.SessionExportResult{Source: "native_export", Truncated: true, Messages: 3}, nil + }, + wantSrc: "native_export", + wantTrunc: true, + }, + { + name: "unavailable", + backend: "pi", + seam: nil, + wantSrc: "unavailable", + wantDiag: "harness has no native export path", + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + handler, store, runID := sessionExportRunner(t, tc.backend, tc.seam) + detail, err := store.GetRun(context.Background(), runID) + if err != nil { + t.Fatal(err) + } + if detail.Status != "succeeded" { + t.Fatalf("export outcome failed the run: %+v", detail.Status) + } + step := detail.Steps[0] + if step.Status != "completed" || step.Outcome != "success" { + t.Fatalf("export changed the stage result: %+v", step) + } + if step.SessionExport == nil || step.SessionExport.Source != tc.wantSrc { + t.Fatalf("export evidence wrong: %+v", step.SessionExport) + } + if tc.wantDiag != "" && !strings.Contains(step.SessionExport.Diagnostic, tc.wantDiag) { + t.Fatalf("diagnostic %q missing %q", step.SessionExport.Diagnostic, tc.wantDiag) + } + if step.SessionExport.Truncated != tc.wantTrunc { + t.Fatalf("truncated = %v, want %v", step.SessionExport.Truncated, tc.wantTrunc) + } + if tc.wantSrc == "unavailable" { + if artifacts, _, _ := handler.runner.scanArtifacts(runID, 1, filepath.Join(handler.runner.artifactsRoot, fmt.Sprint(runID), "1")); len(artifacts) != 0 { + t.Fatalf("unavailable harness wrote files: %+v", artifacts) + } + } + }) + } +} diff --git a/internal/stage/session_export.go b/internal/stage/session_export.go new file mode 100644 index 00000000..4732e904 --- /dev/null +++ b/internal/stage/session_export.go @@ -0,0 +1,452 @@ +package stage + +import ( + "bytes" + "context" + "fmt" + "html" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + "git.a-wan.net/alan/pipelines/internal/opencode" + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// Session file export bounds. A stage's session is written under its own +// artifacts directory in markdown and html so the existing artifact listing and +// serving paths find it with no special casing. The source read is capped at +// SessionExportSourceLimit and each rendered file at SessionExportFileLimit, so +// the pair adds at most ~4 MiB per step, inside the artifact scan limits. +const ( + SessionMarkdownFile = "session.md" + SessionHTMLFile = "session.html" + // SessionExportSourceLimit is the native session read cap; it is the one + // opencode.MaxSessionExport value, not a second copy. + SessionExportSourceLimit = opencode.MaxSessionExport + SessionExportFileLimit = 2 << 20 + SessionExportTimeout = 10 * time.Second +) + +// SessionExportRequest names the stage session to export and the evidence the +// rendered files carry. Directory is the session's workspace (the directory the +// export CLI runs in); ArtifactsDir is the step's artifacts directory. +type SessionExportRequest struct { + SessionID string + Backend string + Directory string + ArtifactsDir string + RunID int64 + Sequence int + Stage string + Provider string + Model string +} + +// SessionExportResult is the outcome of one session export. Markdown/HTML are +// the written file names, their byte sizes, the decoded message count, the +// source, whether either file or the source was truncated and a sanitized +// diagnostic (for example a skipped overwrite). +type SessionExportResult struct { + Markdown string + HTML string + MarkdownBytes int64 + HTMLBytes int64 + Messages int + Source string + Truncated bool + Diagnostic string +} + +const ( + // sessionExportSource is the recorded source of a native-export readback. + sessionExportSource = "native_export" + // markdownTruncationBanner and htmlTruncationBanner are the visible labels a + // truncated export carries near its start and end so it is never mistaken for + // the whole session. + markdownTruncationBanner = "\n> **TRUNCATED**: this exported session is not the whole session; it was cut at the export size cap.\n" + htmlTruncationBanner = "

TRUNCATED: this exported session is not the whole session; it was cut at the export size cap.

\n" +) + +// ExportSession reads the stage's session read-only through the native export +// path, renders it to bounded markdown and html and writes both files +// atomically into the step's artifacts directory, refusing to overwrite an +// existing file. It returns a sanitized error and writes nothing when the read +// fails; it never mutates, resumes, interrupts or deletes the session. +func ExportSession(ctx context.Context, request SessionExportRequest) (SessionExportResult, error) { + if !opencode.ValidSessionID(request.SessionID) { + return SessionExportResult{}, fmt.Errorf("session export: invalid session ID") + } + if request.ArtifactsDir == "" { + return SessionExportResult{}, fmt.Errorf("session export: no artifacts directory") + } + session, err := opencode.ExportSession(ctx, opencode.Executable(), request.Directory, request.Backend, request.SessionID) + if err != nil { + return SessionExportResult{}, fmt.Errorf("session export: %s", RedactEvidence(err.Error())) + } + markdown, markdownTruncated := renderSessionMarkdown(session, request) + htmlDoc, htmlTruncated := renderSessionHTML(session, request) + result := SessionExportResult{ + Markdown: SessionMarkdownFile, + HTML: SessionHTMLFile, + Messages: len(session.Messages), + Source: sessionExportSource, + Truncated: session.Truncated || markdownTruncated || htmlTruncated, + Diagnostic: "", + } + written, diagnostic, err := writeSessionPair(request.ArtifactsDir, []sessionFile{ + {name: SessionMarkdownFile, data: []byte(markdown)}, + {name: SessionHTMLFile, data: []byte(htmlDoc)}, + }) + if err != nil { + return SessionExportResult{}, fmt.Errorf("session export: %s", RedactEvidence(err.Error())) + } + if written[0] { + result.MarkdownBytes = int64(len(markdown)) + } + if written[1] { + result.HTMLBytes = int64(len(htmlDoc)) + } + result.Diagnostic = diagnostic + return result, nil +} + +// sessionFile is one rendered file to write into the artifacts directory. +type sessionFile struct { + name string + data []byte +} + +// writeSessionPair stages every rendered file to a temporary file, then renames +// each into place, so a failure before the renames leaves no partial session.md +// or session.html behind. An existing target is never overwritten: its file is +// skipped and the reason is returned as a diagnostic. +func writeSessionPair(dir string, files []sessionFile) ([]bool, string, error) { + written := make([]bool, len(files)) + temps := make([]string, len(files)) + cleanup := func() { + for _, tmp := range temps { + if tmp != "" { + _ = os.Remove(tmp) + } + } + } + var skipped []string + for i, file := range files { + target := filepath.Join(dir, file.name) + if _, err := os.Lstat(target); err == nil { + skipped = append(skipped, file.name) + continue + } else if !os.IsNotExist(err) { + cleanup() + return written, "", err + } + tmp, err := os.CreateTemp(dir, "."+file.name+".tmp-*") + if err != nil { + cleanup() + return written, "", err + } + temps[i] = tmp.Name() + if _, err := tmp.Write(file.data); err != nil { + tmp.Close() + cleanup() + return written, "", err + } + if err := tmp.Close(); err != nil { + cleanup() + return written, "", err + } + } + for i, file := range files { + if temps[i] == "" { + continue + } + if err := os.Rename(temps[i], filepath.Join(dir, file.name)); err != nil { + cleanup() + return written, "", err + } + written[i] = true + } + diagnostic := "" + if len(skipped) > 0 { + diagnostic = "existing " + strings.Join(skipped, ", ") + " was not overwritten" + } + return written, diagnostic, nil +} + +// sessionMeta is one metadata row the rendered files carry. +type sessionMeta struct { + label string + value string +} + +// sessionMetadata is the run/step/session identity both renderers show, so a +// file is self-describing without the run record. +func sessionMetadata(session opencode.ExportedSession, request SessionExportRequest) []sessionMeta { + meta := []sessionMeta{ + {"run", strconv.FormatInt(request.RunID, 10)}, + {"step", strconv.Itoa(request.Sequence)}, + {"stage", request.Stage}, + {"session", session.ID}, + {"backend", session.Backend}, + {"messages", strconv.Itoa(len(session.Messages))}, + {"source", sessionExportSource}, + {"truncated", strconv.FormatBool(session.Truncated)}, + {"exported_at", time.Now().UTC().Format(time.RFC3339)}, + } + if request.Provider != "" { + meta = append(meta, sessionMeta{"provider", request.Provider}) + } + if request.Model != "" { + meta = append(meta, sessionMeta{"model", request.Model}) + } + return meta +} + +// renderSessionMarkdown renders the session as bounded markdown. The second +// result reports whether the rendered file itself was cut at the cap. +func renderSessionMarkdown(session opencode.ExportedSession, request SessionExportRequest) (string, bool) { + var header bytes.Buffer + header.WriteString("# Stage session export\n\n") + for _, meta := range sessionMetadata(session, request) { + fmt.Fprintf(&header, "- %s: %s\n", meta.label, meta.value) + } + header.WriteString("\n") + + var body bytes.Buffer + if len(session.Messages) == 0 { + body.WriteString("_No messages were recorded for this session._\n\n") + } + for i, message := range session.Messages { + renderMarkdownMessage(&body, i+1, message) + } + return assembleSessionFile(header.String(), body.String(), session.Truncated, markdownTruncationBanner, markdownTruncationBanner) +} + +// renderMarkdownMessage renders one turn with its role and parts. +func renderMarkdownMessage(out *bytes.Buffer, index int, message opencode.ExportedMessage) { + role := message.Role + if role == "" { + role = "unknown" + } + fmt.Fprintf(out, "## %d. %s\n\n", index, role) + var details bytes.Buffer + if message.ID != "" { + fmt.Fprintf(&details, "- id: %s\n", message.ID) + } + if message.Model != "" { + fmt.Fprintf(&details, "- model: %s\n", message.Model) + } + if message.Agent != "" { + fmt.Fprintf(&details, "- agent: %s\n", message.Agent) + } + if message.CreatedAt != 0 { + fmt.Fprintf(&details, "- created_at: %d\n", message.CreatedAt) + } + if details.Len() > 0 { + out.WriteString(details.String()) + out.WriteString("\n") + } + for _, part := range message.Parts { + renderMarkdownPart(out, part) + } +} + +// renderMarkdownPart renders one content element. Unknown types are rendered as +// their raw JSON rather than dropped. +func renderMarkdownPart(out *bytes.Buffer, part opencode.ExportedPart) { + switch part.Type { + case protocol.ChatPartText: + out.WriteString(part.Text) + out.WriteString("\n\n") + case protocol.ChatPartReasoning: + fmt.Fprintf(out, "_reasoning_\n\n%s\n\n", part.Text) + case protocol.ChatPartTool: + renderMarkdownTool(out, part) + default: + label := part.Type + if label == "" { + label = "unknown" + } + fmt.Fprintf(out, "### %s\n\n", label) + raw := part.Raw + if len(raw) == 0 { + raw = []byte("{}") + } + fence := dynamicFence(string(raw)) + fmt.Fprintf(out, "%sjson\n%s\n%s\n\n", fence, strings.TrimSpace(string(raw)), fence) + } +} + +// renderMarkdownTool renders a tool call with its name, status, input, result +// and error. +func renderMarkdownTool(out *bytes.Buffer, part opencode.ExportedPart) { + name := part.Name + if name == "" { + name = part.ID + } + status := "" + if part.State != nil { + status = part.State.Status + } + fmt.Fprintf(out, "### tool: %s (%s)\n\n", name, status) + if part.State == nil { + return + } + if len(part.State.Input) > 0 { + input := string(part.State.Input) + fence := dynamicFence(input) + fmt.Fprintf(out, "input:\n\n%sjson\n%s\n%s\n\n", fence, strings.TrimSpace(input), fence) + } + for _, content := range part.State.Content { + if content.Text != "" { + out.WriteString(content.Text) + out.WriteString("\n\n") + } else if content.URI != "" { + fmt.Fprintf(out, "- %s (%s)\n", content.URI, content.Mime) + } + } + if part.State.Error != nil { + fmt.Fprintf(out, "error: %s\n\n", part.State.Error.Message) + } +} + +// renderSessionHTML renders the session as bounded html, escaping every session +// text value. The second result reports whether the rendered file was cut. +func renderSessionHTML(session opencode.ExportedSession, request SessionExportRequest) (string, bool) { + var header bytes.Buffer + header.WriteString("\n") + header.WriteString("Stage session export") + header.WriteString("") + header.WriteString("\n

Stage session export

\n
\n") + for _, meta := range sessionMetadata(session, request) { + fmt.Fprintf(&header, "
%s
%s
\n", html.EscapeString(meta.label), html.EscapeString(meta.value)) + } + header.WriteString("
\n") + + var body bytes.Buffer + if len(session.Messages) == 0 { + body.WriteString("

No messages were recorded for this session.

\n") + } + for i, message := range session.Messages { + renderHTMLMessage(&body, i+1, message) + } + body.WriteString("\n") + trailing := htmlTruncationBanner + "\n" + return assembleSessionFile(header.String(), body.String(), session.Truncated, htmlTruncationBanner, trailing) +} + +// renderHTMLMessage renders one turn with its role and parts. +func renderHTMLMessage(out *bytes.Buffer, index int, message opencode.ExportedMessage) { + role := message.Role + if role == "" { + role = "unknown" + } + fmt.Fprintf(out, "

%d. %s

\n", index, html.EscapeString(role)) + fmt.Fprintf(out, "

id: %s | model: %s | agent: %s | created_at: %d

\n", + html.EscapeString(message.ID), html.EscapeString(message.Model), html.EscapeString(message.Agent), message.CreatedAt) + for _, part := range message.Parts { + renderHTMLPart(out, part) + } +} + +// renderHTMLPart renders one content element, escaping all session text. +func renderHTMLPart(out *bytes.Buffer, part opencode.ExportedPart) { + switch part.Type { + case protocol.ChatPartText: + fmt.Fprintf(out, "
%s
\n", html.EscapeString(part.Text)) + case protocol.ChatPartReasoning: + fmt.Fprintf(out, "
reasoning
%s
\n", html.EscapeString(part.Text)) + case protocol.ChatPartTool: + renderHTMLTool(out, part) + default: + label := part.Type + if label == "" { + label = "unknown" + } + raw := part.Raw + if len(raw) == 0 { + raw = []byte("{}") + } + fmt.Fprintf(out, "

%s

\n
%s
\n", html.EscapeString(label), html.EscapeString(strings.TrimSpace(string(raw)))) + } +} + +// renderHTMLTool renders a tool call with its name, status, input, result and +// error, escaping every value. +func renderHTMLTool(out *bytes.Buffer, part opencode.ExportedPart) { + name := part.Name + if name == "" { + name = part.ID + } + status := "" + if part.State != nil { + status = part.State.Status + } + fmt.Fprintf(out, "

tool: %s (%s)

\n", html.EscapeString(name), html.EscapeString(status)) + if part.State == nil { + return + } + if len(part.State.Input) > 0 { + fmt.Fprintf(out, "
%s
\n", html.EscapeString(strings.TrimSpace(string(part.State.Input)))) + } + for _, content := range part.State.Content { + if content.Text != "" { + fmt.Fprintf(out, "
%s
\n", html.EscapeString(content.Text)) + } else if content.URI != "" { + fmt.Fprintf(out, "

%s (%s)

\n", html.EscapeString(content.URI), html.EscapeString(content.Mime)) + } + } + if part.State.Error != nil { + fmt.Fprintf(out, "

error: %s

\n", html.EscapeString(part.State.Error.Message)) + } +} + +// assembleSessionFile joins the metadata header and the rendered body, adding +// the visible truncation banners near the start and the end when the source was +// already truncated or when the rendered output itself had to be cut, and never +// returning more than SessionExportFileLimit bytes. The second result reports +// whether the rendered output was cut. +func assembleSessionFile(header, body string, sourceTruncated bool, leading, trailing string) (string, bool) { + limit := SessionExportFileLimit + rendered := false + truncated := sourceTruncated + if len(header)+len(body)+len(leading)+len(trailing) > limit { + rendered = true + truncated = true + room := limit - len(header) - len(leading) - len(trailing) + if room < 0 { + room = 0 + } + if len(body) > room { + body, _ = truncateRunes(body, room) + } + } + var out strings.Builder + out.Grow(min(limit, len(header)+len(body)+2*len(leading))) + out.WriteString(header) + if truncated { + out.WriteString(leading) + } + out.WriteString(body) + if truncated { + out.WriteString(trailing) + } + result := out.String() + if len(result) > limit { + result, _ = truncateRunes(result, limit) + } + return result, rendered +} + +// dynamicFence returns a run of at least three backticks longer than any run in +// text, so markdown content that itself contains a fence cannot break out. +func dynamicFence(text string) string { + fence := "```" + for strings.Contains(text, fence) { + fence += "`" + } + return fence +} diff --git a/internal/stage/session_export_test.go b/internal/stage/session_export_test.go new file mode 100644 index 00000000..73af47a3 --- /dev/null +++ b/internal/stage/session_export_test.go @@ -0,0 +1,206 @@ +package stage + +import ( + "context" + "os" + "path/filepath" + "strings" + "testing" + + "git.a-wan.net/alan/pipelines/internal/opencode" +) + +// sessionCLI writes a fake `opencode` CLI that answers the session export +// invocation (v1 `export ` or v2 `session export `) with body and points +// PIPELINES_OPENCODE at it, so ExportSession runs without a service. +func sessionCLI(t *testing.T, id, body string) { + t.Helper() + path := filepath.Join(t.TempDir(), "opencode") + script := "#!/bin/sh\n" + + "[ \"$1\" = export ] && shift || { [ \"$1\" = session ] && [ \"$2\" = export ] && shift 2 || exit 8; }\n" + + "[ \"$1\" = " + id + " ] || exit 9\n" + + "cat <<'EOF'\n" + body + "\nEOF\n" + if err := os.WriteFile(path, []byte(script), 0700); err != nil { + t.Fatal(err) + } + t.Setenv("PIPELINES_OPENCODE", path) +} + +func sessionBody() string { + return `{"info":{"id":"ses_ok"},"messages":[` + + `{"info":{"id":"m1","role":"user"},"text":"please run"},` + + `{"info":{"id":"m2","role":"assistant","modelID":"gpt"},"parts":[` + + `{"type":"text","text":"hello &\" world"},` + + `{"type":"reasoning","text":"thinking hard"},` + + `{"type":"tool","name":"read","state":{"status":"completed","input":{"path":"a.go"},"content":[{"type":"text","text":"tool output"}]}},` + + `{"type":"file","uri":"file:///tmp/x"}]}]}` +} + +func sessionRequest(dir string) SessionExportRequest { + return SessionExportRequest{ + SessionID: "ses_ok", Backend: "v2", Directory: dir, ArtifactsDir: dir, + RunID: 7, Sequence: 2, Stage: "implementer", Provider: "prov", Model: "gpt", + } +} + +func TestExportSessionWritesBothFilesWithRealContent(t *testing.T) { + dir := t.TempDir() + sessionCLI(t, "ses_ok", sessionBody()) + result, err := ExportSession(context.Background(), sessionRequest(dir)) + if err != nil { + t.Fatal(err) + } + if result.Markdown != "session.md" || result.HTML != "session.html" { + t.Fatalf("file names wrong: %+v", result) + } + if result.Messages != 2 || result.Source != "native_export" || result.Truncated { + t.Fatalf("evidence wrong: %+v", result) + } + markdown, err := os.ReadFile(filepath.Join(dir, SessionMarkdownFile)) + if err != nil { + t.Fatal(err) + } + htmlDoc, err := os.ReadFile(filepath.Join(dir, SessionHTMLFile)) + if err != nil { + t.Fatal(err) + } + if result.MarkdownBytes != int64(len(markdown)) || result.HTMLBytes != int64(len(htmlDoc)) { + t.Fatalf("sizes wrong: %+v", result) + } + for _, want := range []string{"hello &\" world", "thinking hard", "tool: read (completed)", "tool output", `{"path":"a.go"}`, "please run"} { + if !strings.Contains(string(markdown), want) { + t.Fatalf("markdown missing %q", want) + } + } + if !strings.Contains(string(markdown), "file:///tmp/x") { + t.Fatal("markdown dropped the unknown 'file' part") + } + // HTML must escape session text and still carry the tool detail. + if strings.Contains(string(htmlDoc), "") { + t.Fatal("html rendered unescaped session text") + } + for _, want := range []string{"<b>", "&", "tool: read (completed)", "tool output"} { + if !strings.Contains(string(htmlDoc), want) { + t.Fatalf("html missing %q", want) + } + } + // No temporary file may survive a successful write. + temps, _ := filepath.Glob(filepath.Join(dir, ".*tmp*")) + if len(temps) != 0 { + t.Fatalf("temporary files left behind: %v", temps) + } +} + +func TestExportSessionRenderedTruncationBannerInBothFiles(t *testing.T) { + // A source under the read cap but whose rendering exceeds the file cap. + huge := strings.Repeat("line of text\n", SessionExportFileLimit/7) + session := opencode.ExportedSession{ + ID: "ses_ok", + Backend: "v2", + Messages: []opencode.ExportedMessage{{ + Role: "assistant", + Parts: []opencode.ExportedPart{{Type: "text", Text: huge}}, + }}, + } + markdown, mdTruncated := renderSessionMarkdown(session, sessionRequest(t.TempDir())) + htmlDoc, htmlTruncated := renderSessionHTML(session, sessionRequest(t.TempDir())) + if !mdTruncated || !htmlTruncated { + t.Fatalf("rendered truncation not reported: md=%v html=%v", mdTruncated, htmlTruncated) + } + for name, content := range map[string]string{"markdown": markdown, "html": htmlDoc} { + if len(content) > SessionExportFileLimit { + t.Fatalf("%s exceeds cap: %d", name, len(content)) + } + if strings.Count(content, "TRUNCATED") < 2 { + t.Fatalf("%s lacks a leading and trailing truncation banner", name) + } + } +} + +func TestExportSessionSourceTruncationIsLabelledNotWhole(t *testing.T) { + session := opencode.ExportedSession{ + ID: "ses_ok", + Backend: "v2", + Truncated: true, + Messages: []opencode.ExportedMessage{{Role: "assistant", Parts: []opencode.ExportedPart{{Type: "text", Text: "partial"}}}}, + } + markdown, _ := renderSessionMarkdown(session, sessionRequest(t.TempDir())) + if strings.Count(markdown, "TRUNCATED") < 2 { + t.Fatalf("source truncation must be labelled at both ends:\n%s", markdown) + } + if !strings.Contains(markdown, "truncated: true") { + t.Fatal("metadata must record truncation") + } +} + +func TestExportSessionEmptySessionIsHonest(t *testing.T) { + session := opencode.ExportedSession{ID: "ses_ok", Backend: "v2"} + markdown, _ := renderSessionMarkdown(session, sessionRequest(t.TempDir())) + if !strings.Contains(markdown, "messages: 0") || !strings.Contains(markdown, "No messages were recorded") { + t.Fatalf("empty session must be honest, not fabricated:\n%s", markdown) + } +} + +func TestExportSessionRefusesOverwrite(t *testing.T) { + dir := t.TempDir() + sessionCLI(t, "ses_ok", sessionBody()) + existing := filepath.Join(dir, SessionMarkdownFile) + if err := os.WriteFile(existing, []byte("keep me"), 0600); err != nil { + t.Fatal(err) + } + result, err := ExportSession(context.Background(), sessionRequest(dir)) + if err != nil { + t.Fatal(err) + } + kept, err := os.ReadFile(existing) + if err != nil || string(kept) != "keep me" { + t.Fatalf("existing session.md was overwritten: %q %v", kept, err) + } + if result.MarkdownBytes != 0 || !strings.Contains(result.Diagnostic, "not overwritten") { + t.Fatalf("skip reason not recorded: %+v", result) + } + if _, err := os.Stat(filepath.Join(dir, SessionHTMLFile)); err != nil { + t.Fatalf("html should still be written: %v", err) + } +} + +func TestExportSessionFailureWritesNoFiles(t *testing.T) { + dir := t.TempDir() + t.Setenv("PIPELINES_OPENCODE", filepath.Join(t.TempDir(), "absent-opencode")) + _, err := ExportSession(context.Background(), sessionRequest(dir)) + if err == nil { + t.Fatal("export failure must return an error") + } + entries, err := os.ReadDir(dir) + if err != nil { + t.Fatal(err) + } + if len(entries) != 0 { + t.Fatalf("failure wrote files: %v", entries) + } +} + +func TestExportSessionRejectsInvalidIDAndMissingDirectory(t *testing.T) { + sessionCLI(t, "ses_ok", sessionBody()) + bad := sessionRequest(t.TempDir()) + bad.SessionID = "not-a-session" + if _, err := ExportSession(context.Background(), bad); err == nil { + t.Fatal("invalid session id accepted") + } + missing := sessionRequest(t.TempDir()) + missing.ArtifactsDir = "" + if _, err := ExportSession(context.Background(), missing); err == nil { + t.Fatal("missing artifacts directory accepted") + } +} + +// TestAssembleSessionFileNeverExceedsLimit confirms the final guard bounds even +// a pathological header. +func TestAssembleSessionFileNeverExceedsLimit(t *testing.T) { + header := strings.Repeat("h", SessionExportFileLimit+10) + body := strings.Repeat("b", 100) + got, _ := assembleSessionFile(header, body, false, markdownTruncationBanner, markdownTruncationBanner) + if len(got) > SessionExportFileLimit { + t.Fatalf("assembled file exceeds cap: %d", len(got)) + } +}