fix(stage): export settled Pi native sessions as escaped HTML
This commit is contained in:
@@ -0,0 +1,258 @@
|
||||
package stage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"git.a-wan.net/alan/pipelines/internal/opencode"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
|
||||
// exportPiSession reads only a settled, server-owned Pi session. os.Root confines
|
||||
// all opens, including during renames; explicit lstat checks additionally reject
|
||||
// even in-root symlinks. No CLI, agent, interrupt or recovery is invoked here.
|
||||
func exportPiSession(ctx context.Context, request SessionExportRequest) (opencode.ExportedSession, error) {
|
||||
session := opencode.ExportedSession{ID: request.SessionID, Backend: "pi", Attempts: 1}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return session, err
|
||||
}
|
||||
fail := func() (opencode.ExportedSession, error) {
|
||||
return session, fmt.Errorf("Pi native session unavailable: invalid, active or unsettled retained evidence")
|
||||
}
|
||||
cache, err := os.UserCacheDir()
|
||||
if err != nil || request.SessionID == "" || !filepath.IsAbs(request.Reference) || filepath.Clean(request.Reference) != request.Reference {
|
||||
return fail()
|
||||
}
|
||||
base := filepath.Join(cache, "pipelines", "pi-sessions")
|
||||
if filepath.Dir(request.Reference) != base || !strings.HasPrefix(filepath.Base(request.Reference), "stage-") {
|
||||
return fail()
|
||||
}
|
||||
// The OS cache itself can have platform aliases (/var on macOS). From
|
||||
// that trusted anchor onward, reject symlinks, including parent directories.
|
||||
cacheRoot, err := os.OpenRoot(cache)
|
||||
if err != nil {
|
||||
return fail()
|
||||
}
|
||||
defer cacheRoot.Close()
|
||||
rel, err := filepath.Rel(cache, request.Reference)
|
||||
if err != nil {
|
||||
return fail()
|
||||
}
|
||||
components := strings.Split(rel, string(filepath.Separator))
|
||||
for i := range components {
|
||||
info, err := cacheRoot.Lstat(filepath.Join(components[:i+1]...))
|
||||
if err != nil || !info.IsDir() || !piOwned(info) || info.Mode().Perm()&0022 != 0 {
|
||||
return fail()
|
||||
}
|
||||
}
|
||||
info, err := cacheRoot.Lstat(rel)
|
||||
if err != nil || info.Mode().Perm()&0077 != 0 {
|
||||
return fail()
|
||||
}
|
||||
root, err := cacheRoot.OpenRoot(rel)
|
||||
if err != nil {
|
||||
return fail()
|
||||
}
|
||||
defer root.Close()
|
||||
openedInfo, err := root.Stat(".")
|
||||
if err != nil || !os.SameFile(info, openedInfo) {
|
||||
return fail()
|
||||
}
|
||||
read := func(name string, limit int64) ([]byte, error) {
|
||||
f, err := piOpenEvidence(root, name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer f.Close()
|
||||
data, err := io.ReadAll(io.LimitReader(f, limit+1))
|
||||
if len(data) > int(limit) {
|
||||
return nil, fmt.Errorf("oversized Pi control file")
|
||||
}
|
||||
return data, err
|
||||
}
|
||||
ownerData, err := read("owner.json", 16<<10)
|
||||
var owner struct {
|
||||
PID int `json:"pid"`
|
||||
SessionID string `json:"session_id"`
|
||||
SessionFile string `json:"session_file"`
|
||||
}
|
||||
if err != nil || json.Unmarshal(ownerData, &owner) != nil || owner.SessionID != request.SessionID || owner.PID <= 1 {
|
||||
return fail()
|
||||
}
|
||||
quiet, err := read("quiescent", 32)
|
||||
if err != nil || string(quiet) != "quiescent" || !errors.Is(syscall.Kill(owner.PID, 0), syscall.ESRCH) || !errors.Is(syscall.Kill(-owner.PID, 0), syscall.ESRCH) {
|
||||
return fail()
|
||||
}
|
||||
if !filepath.IsAbs(owner.SessionFile) || filepath.Clean(owner.SessionFile) != owner.SessionFile || filepath.Ext(owner.SessionFile) != ".jsonl" {
|
||||
return fail()
|
||||
}
|
||||
name, err := filepath.Rel(request.Reference, owner.SessionFile)
|
||||
if err != nil || !filepath.IsLocal(name) {
|
||||
return fail()
|
||||
}
|
||||
f, err := piOpenEvidence(root, name)
|
||||
if err != nil {
|
||||
return fail()
|
||||
}
|
||||
defer f.Close()
|
||||
data, err := io.ReadAll(io.LimitReader(f, SessionExportSourceLimit+1))
|
||||
if err != nil {
|
||||
return fail()
|
||||
}
|
||||
session.Truncated = len(data) > SessionExportSourceLimit
|
||||
if session.Truncated {
|
||||
data = data[:SessionExportSourceLimit]
|
||||
// A cut JSONL record is never fabricated or partially decoded.
|
||||
if i := bytes.LastIndexByte(data, '\n'); i >= 0 {
|
||||
data = data[:i+1]
|
||||
} else {
|
||||
data = nil
|
||||
}
|
||||
}
|
||||
lines := bytes.Split(bytes.TrimSpace(data), []byte{'\n'})
|
||||
var header struct {
|
||||
Type, ID string
|
||||
Version int
|
||||
}
|
||||
if len(lines) == 0 || json.Unmarshal(lines[0], &header) != nil || header.Type != "session" || header.ID != owner.SessionID || header.Version != 3 {
|
||||
return fail()
|
||||
}
|
||||
// State-only entries are retained alongside the next actual message, not
|
||||
// counted as invented conversation turns. Trailing entries follow the last.
|
||||
pending := []opencode.ExportedPart{
|
||||
{Type: "pi_native_header", Raw: append(json.RawMessage(nil), lines[0]...)},
|
||||
{Type: "pi_native_owner", Raw: append(json.RawMessage(nil), ownerData...)},
|
||||
}
|
||||
for _, line := range lines[1:] {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return session, err
|
||||
}
|
||||
if len(bytes.TrimSpace(line)) == 0 {
|
||||
continue
|
||||
}
|
||||
var entry struct {
|
||||
Type, ID, Timestamp string
|
||||
Message json.RawMessage
|
||||
}
|
||||
if json.Unmarshal(line, &entry) != nil || entry.Type == "" || entry.Type == "session" {
|
||||
return fail()
|
||||
}
|
||||
if entry.Type != "message" {
|
||||
pending = append(pending, opencode.ExportedPart{Type: "pi_native_entry", Raw: append(json.RawMessage(nil), line...)})
|
||||
continue
|
||||
}
|
||||
m := opencode.ExportedMessage{ID: entry.ID, Parts: pending}
|
||||
pending = nil
|
||||
if stamp, err := time.Parse(time.RFC3339Nano, entry.Timestamp); err == nil {
|
||||
m.CreatedAt = stamp.UnixMilli()
|
||||
}
|
||||
if entry.Type == "message" {
|
||||
var native struct {
|
||||
Role, Model, Provider, ToolCallID, ToolName, ErrorMessage string
|
||||
IsError bool
|
||||
Content json.RawMessage
|
||||
}
|
||||
if json.Unmarshal(entry.Message, &native) != nil || native.Role == "" {
|
||||
return fail()
|
||||
}
|
||||
m.Role, m.Model, m.Agent = native.Role, native.Model, native.Provider
|
||||
var text string
|
||||
if len(native.Content) == 0 {
|
||||
// Native extension/bashExecution messages can use fields other
|
||||
// than content; the complete entry below is their evidence.
|
||||
} else if json.Unmarshal(native.Content, &text) == nil {
|
||||
m.Parts = append(m.Parts, opencode.ExportedPart{Type: protocol.ChatPartText, Text: text})
|
||||
} else {
|
||||
var parts []json.RawMessage
|
||||
if json.Unmarshal(native.Content, &parts) != nil {
|
||||
return fail()
|
||||
}
|
||||
for _, raw := range parts {
|
||||
var p struct {
|
||||
Type, Text, Thinking, ID, Name string
|
||||
Arguments json.RawMessage
|
||||
}
|
||||
if json.Unmarshal(raw, &p) != nil {
|
||||
return fail()
|
||||
}
|
||||
part := opencode.ExportedPart{Type: p.Type, Text: p.Text, Raw: raw}
|
||||
switch p.Type {
|
||||
case "thinking":
|
||||
part.Type, part.Text = protocol.ChatPartReasoning, p.Thinking
|
||||
case "toolCall":
|
||||
part.Type, part.ID, part.Name = protocol.ChatPartTool, p.ID, p.Name
|
||||
part.State = &protocol.ChatToolState{Input: p.Arguments}
|
||||
}
|
||||
m.Parts = append(m.Parts, part)
|
||||
}
|
||||
}
|
||||
if native.ErrorMessage != "" {
|
||||
data, _ := json.Marshal(native.ErrorMessage)
|
||||
m.Parts = append(m.Parts, opencode.ExportedPart{Type: "error", Raw: data})
|
||||
}
|
||||
if native.Role == "toolResult" {
|
||||
status := "completed"
|
||||
if native.IsError {
|
||||
status = "error"
|
||||
}
|
||||
// The result remains its own real native turn, not spliced into
|
||||
// an earlier call (which can be on a different session branch).
|
||||
m.Parts = append(m.Parts, opencode.ExportedPart{Type: protocol.ChatPartTool,
|
||||
ID: native.ToolCallID, Name: native.ToolName, State: &protocol.ChatToolState{Status: status}})
|
||||
}
|
||||
}
|
||||
// Keep the actual entry (including toolResult isError, toolCallId,
|
||||
// stopReason, unknown content and branch/compaction records) verbatim.
|
||||
// This is native evidence, not a synthetic assistant placeholder.
|
||||
m.Parts = append(m.Parts, opencode.ExportedPart{Type: "pi_native_entry", Raw: append(json.RawMessage(nil), line...)})
|
||||
session.Messages = append(session.Messages, m)
|
||||
}
|
||||
if len(session.Messages) == 0 {
|
||||
return session, opencode.ErrEmptySessionExport
|
||||
}
|
||||
last := &session.Messages[len(session.Messages)-1]
|
||||
last.Parts = append(last.Parts, pending...)
|
||||
return session, nil
|
||||
}
|
||||
|
||||
func piOwned(info os.FileInfo) bool {
|
||||
stat, ok := info.Sys().(*syscall.Stat_t)
|
||||
return ok && stat.Uid == uint32(os.Geteuid())
|
||||
}
|
||||
|
||||
func piOpenEvidence(root *os.Root, name string) (*os.File, error) {
|
||||
if !filepath.IsLocal(name) {
|
||||
return nil, fmt.Errorf("nonlocal Pi evidence")
|
||||
}
|
||||
parts := strings.Split(name, string(filepath.Separator))
|
||||
var checked os.FileInfo
|
||||
for i := range parts {
|
||||
info, err := root.Lstat(filepath.Join(parts[:i+1]...))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if info.Mode()&os.ModeSymlink != 0 || !piOwned(info) || info.Mode().Perm()&0022 != 0 || (i < len(parts)-1 && !info.IsDir()) || (i == len(parts)-1 && (!info.Mode().IsRegular() || info.Sys().(*syscall.Stat_t).Nlink != 1)) {
|
||||
return nil, fmt.Errorf("unsafe Pi evidence")
|
||||
}
|
||||
checked = info
|
||||
}
|
||||
f, err := root.Open(name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
info, err := f.Stat()
|
||||
if err != nil || !os.SameFile(checked, info) || !info.Mode().IsRegular() || !piOwned(info) || info.Mode().Perm()&0022 != 0 || info.Sys().(*syscall.Stat_t).Nlink != 1 {
|
||||
f.Close()
|
||||
return nil, fmt.Errorf("unsafe Pi evidence")
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
@@ -0,0 +1,273 @@
|
||||
package stage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"syscall"
|
||||
"testing"
|
||||
)
|
||||
|
||||
const piFixtureID = "b59a48a7-47bf-483f-9eac-78894d015648"
|
||||
|
||||
// Fixture follows @earendil-works/pi-coding-agent 1.3.0's v3 FileEntry /
|
||||
// SessionMessageEntry and pi-ai Message types. Tests never execute Pi.
|
||||
func piExportFixture(t *testing.T) (SessionExportRequest, string) {
|
||||
t.Helper()
|
||||
home := t.TempDir()
|
||||
t.Setenv("HOME", home)
|
||||
t.Setenv("XDG_CACHE_HOME", filepath.Join(home, "cache"))
|
||||
cache, err := os.UserCacheDir()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ref := filepath.Join(cache, "pipelines", "pi-sessions", "stage-test")
|
||||
if err := os.MkdirAll(ref, 0700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
data, err := os.ReadFile("testdata/pi-session.jsonl")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
file := filepath.Join(ref, "2026-10-20T10-00-00_"+piFixtureID+".jsonl")
|
||||
if err := os.WriteFile(file, data, 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Use a confirmed nonexistent PID; neither the PID nor its process group
|
||||
// is signalled or started by the exporter.
|
||||
pid := 1 << 30
|
||||
if syscall.Kill(pid, 0) != syscall.ESRCH || syscall.Kill(-pid, 0) != syscall.ESRCH {
|
||||
t.Fatal("test PID unexpectedly exists")
|
||||
}
|
||||
owner, _ := json.Marshal(map[string]any{"pid": pid, "session_id": piFixtureID, "session_file": file})
|
||||
for name, content := range map[string][]byte{"owner.json": owner, "quiescent": []byte("quiescent")} {
|
||||
if err := os.WriteFile(filepath.Join(ref, name), content, 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
return SessionExportRequest{Backend: "pi", SessionID: piFixtureID, Reference: ref, ArtifactsDir: t.TempDir(), RunID: 7, Sequence: 2, Stage: "verify"}, file
|
||||
}
|
||||
|
||||
func TestPiSessionExportNativeEvidence(t *testing.T) {
|
||||
req, file := piExportFixture(t)
|
||||
t.Setenv("PIPELINES_OPENCODE", filepath.Join(t.TempDir(), "must-not-execute"))
|
||||
result, err := ExportSession(context.Background(), req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if result.HTML != SessionHTMLFile || result.Messages != 4 || result.Attempts != 1 || result.Truncated || result.Source != "native_export" {
|
||||
t.Fatalf("result: %+v", result)
|
||||
}
|
||||
data, err := os.ReadFile(filepath.Join(req.ArtifactsDir, result.HTML))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
html := string(data)
|
||||
for _, want := range []string{piFixtureID, "pi_native_jsonl", req.Reference, filepath.Base(file), "pi_native_header", "user0001", "toolResult", "call_001", "tool: bash (error)", "cat missing.txt", "Need actual tool evidence <private>", "No such file <failure>", "isError":true", "The file is missing & the tool failed.", "provider failed <upstream>", "opaque-signature", "model_change"} {
|
||||
if !strings.Contains(html, want) {
|
||||
t.Errorf("missing %q", want)
|
||||
}
|
||||
}
|
||||
if strings.Contains(html, "<script>") || strings.Contains(html, "<failure>") {
|
||||
t.Fatal("unescaped native content")
|
||||
}
|
||||
before := string(data)
|
||||
result, err = ExportSession(context.Background(), req)
|
||||
if err != nil || !strings.Contains(result.Diagnostic, "not overwritten") {
|
||||
t.Fatalf("overwrite: %+v %v", result, err)
|
||||
}
|
||||
after, _ := os.ReadFile(filepath.Join(req.ArtifactsDir, result.HTML))
|
||||
if string(after) != before {
|
||||
t.Fatal("existing export changed")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPiSessionExportRejectsUnsafeEvidence(t *testing.T) {
|
||||
for _, name := range []string{"empty_id", "wrong_id", "wrong_header", "header_version", "empty_file", "missing_receipt", "bad_receipt", "active", "bad_owner", "outside_file", "relative_file", "unclean_file", "relative_reference", "arbitrary_reference", "public_reference", "symlink_reference", "symlink_parent", "symlink_owner", "symlink_receipt", "symlink_file", "symlink_nested", "hardlink_file", "invalid_jsonl", "oversized_owner"} {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
req, file := piExportFixture(t)
|
||||
ownerPath := filepath.Join(req.Reference, "owner.json")
|
||||
setOwner := func(id, path string, pid int) {
|
||||
data, _ := json.Marshal(map[string]any{"pid": pid, "session_id": id, "session_file": path})
|
||||
if err := os.WriteFile(ownerPath, data, 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
switch name {
|
||||
case "empty_id":
|
||||
req.SessionID = ""
|
||||
case "wrong_id":
|
||||
req.SessionID = "different-id"
|
||||
case "wrong_header":
|
||||
data, _ := os.ReadFile(file)
|
||||
_ = os.WriteFile(file, []byte(strings.Replace(string(data), piFixtureID, "other", 1)), 0644)
|
||||
case "header_version":
|
||||
data, _ := os.ReadFile(file)
|
||||
_ = os.WriteFile(file, []byte(strings.Replace(string(data), `"version":3`, `"version":99`, 1)), 0644)
|
||||
case "empty_file":
|
||||
_ = os.WriteFile(file, nil, 0644)
|
||||
case "missing_receipt":
|
||||
_ = os.Remove(filepath.Join(req.Reference, "quiescent"))
|
||||
case "bad_receipt":
|
||||
_ = os.WriteFile(filepath.Join(req.Reference, "quiescent"), []byte("active"), 0600)
|
||||
case "active":
|
||||
setOwner(piFixtureID, file, os.Getpid())
|
||||
case "bad_owner":
|
||||
_ = os.WriteFile(ownerPath, []byte(`{`), 0600)
|
||||
case "outside_file":
|
||||
outside := filepath.Join(t.TempDir(), "secret.jsonl")
|
||||
data, _ := os.ReadFile(file)
|
||||
if err := os.WriteFile(outside, data, 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
setOwner(piFixtureID, outside, 1<<30)
|
||||
case "relative_file":
|
||||
setOwner(piFixtureID, "session.jsonl", 1<<30)
|
||||
case "unclean_file":
|
||||
setOwner(piFixtureID, req.Reference+"/nested/../"+filepath.Base(file), 1<<30)
|
||||
case "relative_reference":
|
||||
req.Reference = "relative"
|
||||
case "arbitrary_reference":
|
||||
outside := filepath.Join(t.TempDir(), "stage-test")
|
||||
if err := os.Rename(req.Reference, outside); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req.Reference = outside
|
||||
ownerPath = filepath.Join(outside, "owner.json")
|
||||
setOwner(piFixtureID, filepath.Join(outside, filepath.Base(file)), 1<<30)
|
||||
case "public_reference":
|
||||
_ = os.Chmod(req.Reference, 0755)
|
||||
case "symlink_reference":
|
||||
target := req.Reference + "-real"
|
||||
_ = os.Rename(req.Reference, target)
|
||||
if err := os.Symlink(target, req.Reference); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
case "symlink_parent":
|
||||
parent := filepath.Dir(req.Reference)
|
||||
target := parent + "-real"
|
||||
_ = os.Rename(parent, target)
|
||||
if err := os.Symlink(target, parent); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
case "symlink_owner", "symlink_receipt", "symlink_file":
|
||||
path := file
|
||||
if name == "symlink_owner" {
|
||||
path = ownerPath
|
||||
}
|
||||
if name == "symlink_receipt" {
|
||||
path = filepath.Join(req.Reference, "quiescent")
|
||||
}
|
||||
target := filepath.Join(t.TempDir(), "outside")
|
||||
if err := os.Rename(path, target); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.Symlink(target, path); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
case "symlink_nested":
|
||||
dir := filepath.Join(req.Reference, "nested")
|
||||
if err := os.Symlink(filepath.Dir(file), dir); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
setOwner(piFixtureID, filepath.Join(dir, filepath.Base(file)), 1<<30)
|
||||
case "hardlink_file":
|
||||
if err := os.Link(file, filepath.Join(t.TempDir(), "linked")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
case "invalid_jsonl":
|
||||
f, err := os.OpenFile(file, os.O_APPEND|os.O_WRONLY, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, _ = f.WriteString("{broken}\n")
|
||||
_ = f.Close()
|
||||
case "oversized_owner":
|
||||
_ = os.WriteFile(ownerPath, []byte(strings.Repeat("x", (16<<10)+1)), 0600)
|
||||
}
|
||||
result, err := ExportSession(context.Background(), req)
|
||||
if err == nil {
|
||||
t.Fatalf("unsafe evidence accepted: %+v", result)
|
||||
}
|
||||
entries, _ := os.ReadDir(req.ArtifactsDir)
|
||||
if len(entries) != 0 {
|
||||
t.Fatal("failed export wrote artifacts")
|
||||
}
|
||||
if strings.Contains(err.Error(), req.Reference) || strings.Contains(err.Error(), "secret") {
|
||||
t.Fatalf("unsanitized error: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPiSessionExportEmptyAndBounds(t *testing.T) {
|
||||
t.Run("native_extra_entries", func(t *testing.T) {
|
||||
req, file := piExportFixture(t)
|
||||
f, err := os.OpenFile(file, os.O_APPEND|os.O_WRONLY, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, _ = f.WriteString("{\"type\":\"message\",\"id\":\"bash-extra\",\"message\":{\"role\":\"bashExecution\",\"command\":\"pwd\",\"output\":\"/native/output\",\"exitCode\":0}}\n" +
|
||||
"{\"type\":\"custom\",\"id\":\"trailing\",\"customType\":\"fixture\",\"data\":{\"text\":\"trailing native evidence\"}}\n")
|
||||
_ = f.Close()
|
||||
result, err := ExportSession(context.Background(), req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
data, _ := os.ReadFile(filepath.Join(req.ArtifactsDir, result.HTML))
|
||||
if result.Messages != 5 || !strings.Contains(string(data), "/native/output") || !strings.Contains(string(data), "trailing native evidence") {
|
||||
t.Fatalf("native entries lost: %+v", result)
|
||||
}
|
||||
})
|
||||
t.Run("cancelled", func(t *testing.T) {
|
||||
req, _ := piExportFixture(t)
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
if result, err := ExportSession(ctx, req); err == nil || result.HTML != "" {
|
||||
t.Fatalf("cancel: %+v %v", result, err)
|
||||
}
|
||||
})
|
||||
t.Run("header_only", func(t *testing.T) {
|
||||
req, file := piExportFixture(t)
|
||||
data, _ := os.ReadFile(file)
|
||||
header := strings.SplitN(string(data), "\n", 2)[0] + "\n"
|
||||
_ = os.WriteFile(file, []byte(header), 0644)
|
||||
result, err := ExportSession(context.Background(), req)
|
||||
if err != nil || result.Status != "empty" || result.HTML != "" {
|
||||
t.Fatalf("empty: %+v %v", result, err)
|
||||
}
|
||||
})
|
||||
for _, name := range []string{"source", "render"} {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
req, file := piExportFixture(t)
|
||||
size := SessionExportSourceLimit + 100
|
||||
if name == "render" {
|
||||
size = SessionExportFileLimit
|
||||
}
|
||||
content := strings.Repeat("x", size)
|
||||
record, _ := json.Marshal(map[string]any{"type": "message", "id": "large", "message": map[string]any{"role": "assistant", "content": content}})
|
||||
f, err := os.OpenFile(file, os.O_APPEND|os.O_WRONLY, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, _ = f.Write(append(record, '\n'))
|
||||
_ = f.Close()
|
||||
result, err := ExportSession(context.Background(), req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
data, err := os.ReadFile(filepath.Join(req.ArtifactsDir, result.HTML))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !result.Truncated || len(data) > SessionExportFileLimit || !strings.Contains(string(data), "TRUNCATED") || !strings.Contains(string(data), "user0001") {
|
||||
t.Fatalf("bounds: %+v bytes=%d", result, len(data))
|
||||
}
|
||||
if name == "source" && strings.Contains(string(data), `id: large`) {
|
||||
t.Fatal("partial record rendered")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -51,6 +51,8 @@ type SessionExportRequest struct {
|
||||
Stage string
|
||||
Provider string
|
||||
Model string
|
||||
// Reference is the private retained native session directory (Pi only).
|
||||
Reference string
|
||||
}
|
||||
|
||||
// SessionExportResult is the outcome of one session export: the written html
|
||||
@@ -82,7 +84,7 @@ const (
|
||||
// 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) {
|
||||
if request.Backend != "pi" && !opencode.ValidSessionID(request.SessionID) {
|
||||
return SessionExportResult{}, fmt.Errorf("session export: invalid session ID")
|
||||
}
|
||||
if request.ArtifactsDir == "" {
|
||||
@@ -95,9 +97,18 @@ func ExportSession(ctx context.Context, request SessionExportRequest) (SessionEx
|
||||
if filepath.Base(name) != name || !strings.HasSuffix(name, ".html") || (name != SessionHTMLFile && !strings.HasPrefix(name, "session-repair-")) {
|
||||
return SessionExportResult{}, fmt.Errorf("session export: invalid server filename")
|
||||
}
|
||||
session, err := opencode.ExportSession(ctx, opencode.Executable(), request.Directory, request.Backend, request.SessionID)
|
||||
var session opencode.ExportedSession
|
||||
var err error
|
||||
if request.Backend == "pi" {
|
||||
session, err = exportPiSession(ctx, request)
|
||||
} else {
|
||||
session, err = opencode.ExportSession(ctx, opencode.Executable(), request.Directory, request.Backend, request.SessionID)
|
||||
}
|
||||
if err != nil {
|
||||
if errors.Is(err, opencode.ErrEmptySessionExport) {
|
||||
if request.Backend == "pi" {
|
||||
return SessionExportResult{Source: sessionExportSource, Status: "empty", Attempts: session.Attempts, Truncated: session.Truncated, Diagnostic: "settled Pi session contains no complete messages inside the bounded read; full session evidence was not captured"}, nil
|
||||
}
|
||||
return SessionExportResult{Source: sessionExportSource, Status: "empty", Attempts: session.Attempts, Truncated: session.Truncated, Diagnostic: "session recorded but export contains no messages after bounded retries; full session evidence was not captured"}, nil
|
||||
}
|
||||
return SessionExportResult{Source: sessionExportSource, Status: "failed", Attempts: session.Attempts}, fmt.Errorf("session export: %s", RedactEvidence(err.Error()))
|
||||
@@ -191,6 +202,9 @@ func sessionMetadata(session opencode.ExportedSession, request SessionExportRequ
|
||||
if request.Provider != "" {
|
||||
meta = append(meta, sessionMeta{"provider", request.Provider})
|
||||
}
|
||||
if session.Backend == "pi" {
|
||||
meta = append(meta, sessionMeta{"format", "pi_native_jsonl"}, sessionMeta{"reference", request.Reference})
|
||||
}
|
||||
if request.Model != "" {
|
||||
meta = append(meta, sessionMeta{"model", request.Model})
|
||||
}
|
||||
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
{"type":"session","version":3,"id":"b59a48a7-47bf-483f-9eac-78894d015648","timestamp":"2026-10-20T10:00:00.000Z","cwd":"/work/project"}
|
||||
{"type":"model_change","id":"model001","parentId":null,"timestamp":"2026-10-20T10:00:00.001Z","provider":"anthropic","modelId":"claude-sonnet-4-6"}
|
||||
{"type":"message","id":"user0001","parentId":"model001","timestamp":"2026-10-20T10:00:01.000Z","message":{"role":"user","content":"Inspect <script>alert(1)</script> & report","timestamp":1792490401000}}
|
||||
{"type":"message","id":"assist01","parentId":"user0001","timestamp":"2026-10-20T10:00:02.000Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Need actual tool evidence <private>","thinkingSignature":"opaque-signature"},{"type":"toolCall","id":"call_001","name":"bash","arguments":{"command":"cat missing.txt"}}],"api":"anthropic-messages","provider":"anthropic","model":"claude-sonnet-4-6","usage":{"input":10,"output":8,"cacheRead":0,"cacheWrite":0,"totalTokens":18,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1792490402000}}
|
||||
{"type":"message","id":"result01","parentId":"assist01","timestamp":"2026-10-20T10:00:03.000Z","message":{"role":"toolResult","toolCallId":"call_001","toolName":"bash","content":[{"type":"text","text":"cat: missing.txt: No such file <failure>"}],"details":{"exitCode":1},"isError":true,"timestamp":1792490403000}}
|
||||
{"type":"message","id":"assist02","parentId":"result01","timestamp":"2026-10-20T10:00:04.000Z","message":{"role":"assistant","content":[{"type":"text","text":"The file is missing & the tool failed."}],"api":"anthropic-messages","provider":"anthropic","model":"claude-sonnet-4-6","stopReason":"error","errorMessage":"provider failed <upstream>","timestamp":1792490404000}}
|
||||
Reference in New Issue
Block a user