From 3d35e8a86332430559daa5ddf07c5fa83aa2fffa Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Tue, 20 Oct 2026 20:44:50 +0100 Subject: [PATCH] fix(stage): export settled Pi native sessions as escaped HTML --- internal/stage/pi_session_export.go | 258 +++++++++++++++++++++ internal/stage/pi_session_export_test.go | 273 +++++++++++++++++++++++ internal/stage/session_export.go | 18 +- internal/stage/testdata/pi-session.jsonl | 6 + 4 files changed, 553 insertions(+), 2 deletions(-) create mode 100644 internal/stage/pi_session_export.go create mode 100644 internal/stage/pi_session_export_test.go create mode 100644 internal/stage/testdata/pi-session.jsonl diff --git a/internal/stage/pi_session_export.go b/internal/stage/pi_session_export.go new file mode 100644 index 00000000..0b911914 --- /dev/null +++ b/internal/stage/pi_session_export.go @@ -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 +} diff --git a/internal/stage/pi_session_export_test.go b/internal/stage/pi_session_export_test.go new file mode 100644 index 00000000..3400b62a --- /dev/null +++ b/internal/stage/pi_session_export_test.go @@ -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, " & 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 ","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 "}],"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 ","timestamp":1792490404000}}