diff --git a/agents/agentd/cmd/agentd/main.go b/agents/agentd/cmd/agentd/main.go index f2f61973..9a939134 100644 --- a/agents/agentd/cmd/agentd/main.go +++ b/agents/agentd/cmd/agentd/main.go @@ -55,13 +55,15 @@ type Agent struct { topologyMu sync.Mutex // Session state - sessions map[string]*SessionState - sessionsMu sync.RWMutex - snapshotHash map[string]string - toolEventsMu sync.Mutex - pendingToolEvents map[string][]toolEventPending - bufferedHooksMu sync.Mutex - bufferedHooks []bufferedHook + sessions map[string]*SessionState + sessionsMu sync.RWMutex + transcriptPaths map[string]string + claudeProjectsRoot string + snapshotHash map[string]string + toolEventsMu sync.Mutex + pendingToolEvents map[string][]toolEventPending + bufferedHooksMu sync.Mutex + bufferedHooks []bufferedHook // Approval lifecycle - TTL cache to prevent race conditions recentDecisions map[string]time.Time @@ -388,6 +390,7 @@ func runDaemon() { agent := &Agent{ cfg: cfg, sessions: make(map[string]*SessionState), + transcriptPaths: make(map[string]string), snapshotHash: make(map[string]string), providerUsageHash: make(map[string]string), pendingToolEvents: make(map[string][]toolEventPending), @@ -2053,6 +2056,12 @@ func (a *Agent) executeCommand(cmd commands.Dispatch) (map[string]any, error) { break } resultPayload, err = a.executeCapturePaneCommand(session, cmd.Command.Payload) + case "capture_transcript": + if !exists { + err = fmt.Errorf("session not found") + break + } + resultPayload, err = a.executeCaptureTranscriptCommand(session, cmd.Command.Payload) case "copy_to_session": if !exists { err = fmt.Errorf("session not found") @@ -2923,6 +2932,7 @@ func (a *Agent) executeSpawnSessionWorktree(sessionID string, p protocol.SpawnSe if registered { a.sessionsMu.Lock() delete(a.sessions, sessionID) + delete(a.transcriptPaths, sessionID) a.refreshHierarchyMetadataLocked() a.sessionsMu.Unlock() } @@ -3062,6 +3072,7 @@ func (a *Agent) executeSpawnSessionInteractive(sessionID string, p protocol.Spaw if registered { a.sessionsMu.Lock() delete(a.sessions, sessionID) + delete(a.transcriptPaths, sessionID) a.refreshHierarchyMetadataLocked() a.sessionsMu.Unlock() } @@ -3275,6 +3286,7 @@ func (a *Agent) executeFork(parentSession *SessionState, payload json.RawMessage if registered { a.sessionsMu.Lock() delete(a.sessions, newSessionID) + delete(a.transcriptPaths, newSessionID) a.refreshHierarchyMetadataLocked() a.sessionsMu.Unlock() } @@ -3696,6 +3708,7 @@ func (a *Agent) handleClaudeHook(payload providers.ClaudeHookPayload) (*provider a.bufferHook("claude_code", payload) return nil, nil } + a.retainTranscriptPath(sessionID, extractHookString(hookData, "transcript_path", "transcriptPath")) a.markSessionReady(sessionID) // Update session status based on hook @@ -3870,6 +3883,27 @@ func (a *Agent) resolveHookSessionID(payload providers.ClaudeHookPayload) string return "" } +func (a *Agent) retainTranscriptPath(sessionID, transcriptPath string) { + if sessionID == "" || transcriptPath == "" { + return + } + a.sessionsMu.Lock() + defer a.sessionsMu.Unlock() + if a.sessions[sessionID] == nil { + return + } + if a.transcriptPaths == nil { + a.transcriptPaths = make(map[string]string) + } + a.transcriptPaths[sessionID] = transcriptPath +} + +func (a *Agent) transcriptPathForSession(sessionID string) string { + a.sessionsMu.RLock() + defer a.sessionsMu.RUnlock() + return a.transcriptPaths[sessionID] +} + func (a *Agent) markSessionReady(sessionID string) { a.sessionsMu.Lock() if session := a.sessions[sessionID]; session != nil { @@ -5164,6 +5198,7 @@ func (a *Agent) syncPanes(panes []tmux.Pane, procSnap *proc.Snapshot) { } for _, id := range staleIDs { delete(a.sessions, id) + delete(a.transcriptPaths, id) delete(a.snapshotHash, id) delete(a.providerUsageHash, id) } diff --git a/agents/agentd/cmd/agentd/main_transcript_test.go b/agents/agentd/cmd/agentd/main_transcript_test.go new file mode 100644 index 00000000..93c3fa4f --- /dev/null +++ b/agents/agentd/cmd/agentd/main_transcript_test.go @@ -0,0 +1,387 @@ +package main + +import ( + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/agent-command/agentd/internal/commands" + "github.com/agent-command/agentd/internal/config" + "github.com/agent-command/agentd/internal/protocol" + "github.com/agent-command/agentd/internal/providers" + "github.com/agent-command/agentd/internal/usage" +) + +func TestClaudeHookRetainsLatestTranscriptPathUntilSessionCleanup(t *testing.T) { + agent := &Agent{ + cfg: &config.Config{}, + sessions: map[string]*SessionState{"session-1": {ID: "session-1", Kind: "tmux_pane", PaneID: "%1"}}, + transcriptPaths: make(map[string]string), + snapshotHash: make(map[string]string), + providerUsageHash: make(map[string]string), + usageTracker: usage.NewUsageTracker(), + lastPruneAt: time.Now(), + sendMessage: func(string, any) error { return nil }, + } + hook := providers.ClaudeHookPayload{Hook: json.RawMessage(`{ + "hook_event_name":"Custom", + "transcript_path":"/safe/first.jsonl" + }`)} + hook.Meta.ACSessionID = "session-1" + if _, err := agent.handleClaudeHook(hook); err != nil { + t.Fatal(err) + } + hook.Hook = json.RawMessage(`{ + "hook_event_name":"Custom", + "transcript_path":"/safe/latest.jsonl" + }`) + if _, err := agent.handleClaudeHook(hook); err != nil { + t.Fatal(err) + } + + if got := agent.transcriptPathForSession("session-1"); got != "/safe/latest.jsonl" { + t.Fatalf("retained transcript path=%q", got) + } + + agent.syncPanes(nil, nil) + if got := agent.transcriptPathForSession("session-1"); got != "" { + t.Fatalf("transcript path survived session cleanup: %q", got) + } +} + +func TestCaptureTranscriptDerivesNewestClaudeProjectFile(t *testing.T) { + projectsRoot := t.TempDir() + projectDir := filepath.Join(projectsRoot, "-home-dev-Chat--FW6-") + if err := os.MkdirAll(projectDir, 0o700); err != nil { + t.Fatal(err) + } + oldPath := filepath.Join(projectDir, "old.jsonl") + newPath := filepath.Join(projectDir, "new.jsonl") + if err := os.WriteFile(oldPath, []byte(`{"type":"user","message":{"content":"old"}}`+"\n"), 0o600); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(newPath, []byte(`{"type":"user","message":{"content":"new"}}`+"\n"), 0o600); err != nil { + t.Fatal(err) + } + now := time.Now() + if err := os.Chtimes(oldPath, now.Add(-time.Minute), now.Add(-time.Minute)); err != nil { + t.Fatal(err) + } + if err := os.Chtimes(newPath, now, now); err != nil { + t.Fatal(err) + } + + agent := &Agent{ + sessions: map[string]*SessionState{"session-1": {ID: "session-1", CWD: "/home/dev/Chat (FW6)"}}, + transcriptPaths: make(map[string]string), + claudeProjectsRoot: projectsRoot, + } + payload, err := json.Marshal(protocol.CaptureTranscriptPayload{PageSize: 1}) + if err != nil { + t.Fatal(err) + } + result, err := agent.executeCommand(commands.Dispatch{ + SessionID: "session-1", + Command: protocol.Command{ + Type: "capture_transcript", + Payload: payload, + }, + }) + if err != nil { + t.Fatal(err) + } + if result["source"] != "derived" || result["first_entry"] != 0 || result["total_entries"] != 1 { + t.Fatalf("derived transcript metadata=%+v", result) + } + entries, ok := result["entries"].([]map[string]any) + if !ok || len(entries) != 1 { + t.Fatalf("derived transcript entries=%T %+v", result["entries"], result["entries"]) + } + message, _ := entries[0]["message"].(map[string]any) + if message["content"] != "new" { + t.Fatalf("derived newest entry=%+v", entries[0]) + } +} + +func TestCaptureTranscriptPagesBackwardByEntryIndex(t *testing.T) { + projectsRoot := t.TempDir() + projectDir := filepath.Join(projectsRoot, "-repo") + if err := os.MkdirAll(projectDir, 0o700); err != nil { + t.Fatal(err) + } + transcriptPath := filepath.Join(projectDir, "session.jsonl") + file, err := os.Create(transcriptPath) + if err != nil { + t.Fatal(err) + } + for index := 0; index < 7; index++ { + if _, err := file.WriteString(`{"index":` + string(rune('0'+index)) + `}` + "\n"); err != nil { + t.Fatal(err) + } + } + if err := file.Close(); err != nil { + t.Fatal(err) + } + agent := &Agent{ + sessions: map[string]*SessionState{"session-1": {ID: "session-1", CWD: "/repo"}}, + transcriptPaths: map[string]string{"session-1": transcriptPath}, + claudeProjectsRoot: projectsRoot, + } + + assertPage := func(before *int, wantFirst int, wantIndexes []float64) { + t.Helper() + payload, err := json.Marshal(protocol.CaptureTranscriptPayload{PageSize: 3, BeforeEntry: before}) + if err != nil { + t.Fatal(err) + } + result, err := agent.executeCommand(commands.Dispatch{ + SessionID: "session-1", + Command: protocol.Command{Type: "capture_transcript", Payload: payload}, + }) + if err != nil { + t.Fatal(err) + } + if result["source"] != "hook" || result["first_entry"] != wantFirst || result["total_entries"] != 7 { + t.Fatalf("page metadata=%+v", result) + } + entries := result["entries"].([]map[string]any) + gotIndexes := make([]float64, 0, len(entries)) + for _, entry := range entries { + gotIndexes = append(gotIndexes, entry["index"].(float64)) + } + if len(gotIndexes) != len(wantIndexes) { + t.Fatalf("page indexes=%v want=%v", gotIndexes, wantIndexes) + } + for index := range gotIndexes { + if gotIndexes[index] != wantIndexes[index] { + t.Fatalf("page indexes=%v want=%v", gotIndexes, wantIndexes) + } + } + } + + assertPage(nil, 4, []float64{4, 5, 6}) + before := 4 + assertPage(&before, 1, []float64{1, 2, 3}) + before = 1 + assertPage(&before, 0, []float64{0}) +} + +func TestCaptureTranscriptRejectsHookPathsOutsideClaudeProjects(t *testing.T) { + projectsRoot := t.TempDir() + outsideRoot := t.TempDir() + outsidePath := filepath.Join(outsideRoot, "secret.jsonl") + if err := os.WriteFile(outsidePath, []byte(`{"secret":true}`+"\n"), 0o600); err != nil { + t.Fatal(err) + } + projectDir := filepath.Join(projectsRoot, "-repo") + if err := os.MkdirAll(projectDir, 0o700); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(projectDir, "safe.jsonl"), []byte(`{"safe":true}`+"\n"), 0o600); err != nil { + t.Fatal(err) + } + agent := &Agent{ + sessions: map[string]*SessionState{"session-1": {ID: "session-1", CWD: "/repo"}}, + transcriptPaths: map[string]string{"session-1": outsidePath}, + claudeProjectsRoot: projectsRoot, + } + payload, _ := json.Marshal(protocol.CaptureTranscriptPayload{PageSize: 1}) + result, err := agent.executeCommand(commands.Dispatch{ + SessionID: "session-1", + Command: protocol.Command{Type: "capture_transcript", Payload: payload}, + }) + if err != nil { + t.Fatal(err) + } + entries := result["entries"].([]map[string]any) + if result["source"] != "derived" || len(entries) != 1 || entries[0]["safe"] != true { + t.Fatalf("outside hook path was not rejected: %+v", result) + } +} + +func TestCaptureTranscriptCapsContentAndDropsBase64Blobs(t *testing.T) { + projectsRoot := t.TempDir() + projectDir := filepath.Join(projectsRoot, "-repo") + if err := os.MkdirAll(projectDir, 0o700); err != nil { + t.Fatal(err) + } + entry := map[string]any{ + "type": "assistant", + "message": map[string]any{ + "content": []any{ + map[string]any{"type": "text", "text": strings.Repeat("é", 9_000)}, + map[string]any{ + "type": "image", + "source": map[string]any{ + "type": "base64", + "media_type": "image/png", + "data": strings.Repeat("A", 256), + }, + }, + }, + }, + } + rawEntry, err := json.Marshal(entry) + if err != nil { + t.Fatal(err) + } + transcriptPath := filepath.Join(projectDir, "session.jsonl") + if err := os.WriteFile(transcriptPath, append(rawEntry, '\n'), 0o600); err != nil { + t.Fatal(err) + } + agent := &Agent{ + sessions: map[string]*SessionState{"session-1": {ID: "session-1", CWD: "/repo"}}, + transcriptPaths: map[string]string{"session-1": transcriptPath}, + claudeProjectsRoot: projectsRoot, + } + payload, _ := json.Marshal(protocol.CaptureTranscriptPayload{PageSize: 1}) + result, err := agent.executeCommand(commands.Dispatch{ + SessionID: "session-1", + Command: protocol.Command{Type: "capture_transcript", Payload: payload}, + }) + if err != nil { + t.Fatal(err) + } + entries := result["entries"].([]map[string]any) + message := entries[0]["message"].(map[string]any) + content := message["content"].([]any) + textBlock := content[0].(map[string]any) + text := textBlock["text"].(string) + if len([]byte(text)) > 16*1024 || !strings.HasPrefix(strings.Repeat("é", 9_000), text) { + t.Fatalf("capped text has %d bytes and valid-prefix=%v", len([]byte(text)), strings.HasPrefix(strings.Repeat("é", 9_000), text)) + } + imageBlock := content[1].(map[string]any) + source := imageBlock["source"].(map[string]any) + if _, exists := source["data"]; exists { + t.Fatalf("base64 data survived sanitization: %+v", source) + } +} + +func TestCaptureTranscriptRejectsOutOfBoundsRequests(t *testing.T) { + projectsRoot := t.TempDir() + projectDir := filepath.Join(projectsRoot, "-repo") + if err := os.MkdirAll(projectDir, 0o700); err != nil { + t.Fatal(err) + } + transcriptPath := filepath.Join(projectDir, "session.jsonl") + if err := os.WriteFile(transcriptPath, []byte(`{"entry":0}`+"\n"), 0o600); err != nil { + t.Fatal(err) + } + agent := &Agent{ + sessions: map[string]*SessionState{"session-1": {ID: "session-1", CWD: "/repo"}}, + transcriptPaths: map[string]string{"session-1": transcriptPath}, + claudeProjectsRoot: projectsRoot, + } + negative := -1 + beyondEnd := 2 + for _, request := range []protocol.CaptureTranscriptPayload{ + {PageSize: 501}, + {PageSize: 1, BeforeEntry: &negative}, + {PageSize: 1, BeforeEntry: &beyondEnd}, + } { + payload, _ := json.Marshal(request) + if _, err := agent.executeCommand(commands.Dispatch{ + SessionID: "session-1", + Command: protocol.Command{Type: "capture_transcript", Payload: payload}, + }); err == nil { + t.Fatalf("out-of-bounds request succeeded: %+v", request) + } + } +} + +func TestCaptureTranscriptReturnsNoTranscriptErrorCode(t *testing.T) { + agent := &Agent{ + sessions: map[string]*SessionState{"session-1": {ID: "session-1", CWD: "/missing"}}, + transcriptPaths: make(map[string]string), + claudeProjectsRoot: t.TempDir(), + } + results := make(chan commands.Result, 1) + executor := commands.NewExecutor(1, agent.executeCommand, func(result commands.Result) { + results <- result + }) + defer executor.Close() + payload, _ := json.Marshal(protocol.CaptureTranscriptPayload{PageSize: 1}) + if err := executor.Submit(commands.Dispatch{ + CmdID: "capture-1", + SessionID: "session-1", + Command: protocol.Command{Type: "capture_transcript", Payload: payload}, + }); err != nil { + t.Fatal(err) + } + select { + case result := <-results: + if result.OK || result.Error == nil || result.Error.Code != "no_transcript" { + t.Fatalf("missing transcript result=%+v", result) + } + case <-time.After(time.Second): + t.Fatal("timed out waiting for transcript result") + } +} + +func TestCaptureTranscriptToleratesTornTailAndStubsCorruptLines(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "session.jsonl") + content := `{"type":"user","message":{"role":"user","content":"hello"}}` + "\n" + + `{corrupt interior line` + "\n" + + `{"type":"assistant","message":{"role":"assistant","content":"world"}}` + "\n" + + `{"type":"assistant","message":{"role":"assist` // torn mid-append tail, no newline + if err := os.WriteFile(path, []byte(content), 0o600); err != nil { + t.Fatal(err) + } + + total, err := countTranscriptEntries(path) + if err != nil { + t.Fatal(err) + } + if total != 3 { + t.Fatalf("count = %d, want 3 (torn tail excluded)", total) + } + + entries, first, gotTotal, err := readTranscriptPage(path, protocol.CaptureTranscriptPayload{PageSize: 10}) + if err != nil { + t.Fatalf("page failed on torn/corrupt lines: %v", err) + } + if first != 0 || gotTotal != 3 || len(entries) != 3 { + t.Fatalf("page shape = first %d total %d len %d, want 0/3/3", first, gotTotal, len(entries)) + } + if entries[1]["type"] != "x-unparseable" { + t.Fatalf("corrupt interior line = %v, want x-unparseable stub", entries[1]) + } + if entries[2]["type"] != "assistant" { + t.Fatalf("final complete entry = %v, want assistant", entries[2]) + } +} + +func TestCaptureTranscriptDropsToolUseResultAndBudgetsAllStrings(t *testing.T) { + huge := strings.Repeat("x", 1024*1024) + entry := map[string]any{ + "type": "assistant", + "toolUseResult": map[string]any{"stdout": huge}, + "payload": map[string]any{"stdout": huge}, + } + cleaned := sanitizeTranscriptEntry(entry) + if _, ok := cleaned["toolUseResult"]; ok { + t.Fatal("toolUseResult should be dropped entirely") + } + payload, ok := cleaned["payload"].(map[string]any) + if !ok { + t.Fatalf("payload missing: %v", cleaned) + } + stdout, ok := payload["stdout"].(string) + if !ok { + t.Fatalf("payload.stdout missing: %v", payload) + } + if len(stdout) > maxTranscriptEntryBytes { + t.Fatalf("non-content string survived uncapped: %d bytes", len(stdout)) + } + encoded, err := json.Marshal(cleaned) + if err != nil { + t.Fatal(err) + } + if len(encoded) > 3*maxTranscriptEntryBytes { + t.Fatalf("sanitized entry too large: %d bytes", len(encoded)) + } +} diff --git a/agents/agentd/cmd/agentd/transcript.go b/agents/agentd/cmd/agentd/transcript.go new file mode 100644 index 00000000..c0931b14 --- /dev/null +++ b/agents/agentd/cmd/agentd/transcript.go @@ -0,0 +1,344 @@ +package main + +import ( + "bufio" + "encoding/json" + "errors" + "fmt" + "os" + "path/filepath" + "sort" + "strings" + "unicode/utf8" + + "github.com/agent-command/agentd/internal/commands" + "github.com/agent-command/agentd/internal/protocol" +) + +const ( + defaultTranscriptPageSize = 200 + maxTranscriptPageSize = 500 + maxTranscriptContentBytes = 16 * 1024 + maxTranscriptEntryBytes = 32 * 1024 + maxTranscriptScannerToken = 8 * 1024 * 1024 +) + +var errInvalidTranscriptRequest = errors.New("invalid transcript request") + +func (a *Agent) executeCaptureTranscriptCommand(session *SessionState, payload json.RawMessage) (map[string]any, error) { + var request protocol.CaptureTranscriptPayload + if err := json.Unmarshal(payload, &request); err != nil { + return nil, err + } + if request.PageSize == 0 { + request.PageSize = defaultTranscriptPageSize + } + if request.PageSize < 1 || request.PageSize > maxTranscriptPageSize { + return nil, fmt.Errorf("page_size must be between 1 and %d", maxTranscriptPageSize) + } + if request.BeforeEntry != nil && *request.BeforeEntry < 0 { + return nil, fmt.Errorf("before_entry must be nonnegative") + } + + transcriptPath, source, err := a.resolveTranscriptPath(session) + if err != nil { + return nil, commands.NewResultError("no_transcript", "Claude transcript is unavailable") + } + entries, firstEntry, totalEntries, err := readTranscriptPage(transcriptPath, request) + if err != nil { + if errors.Is(err, errInvalidTranscriptRequest) { + return nil, err + } + return nil, commands.NewResultError("no_transcript", "Claude transcript is unavailable") + } + return map[string]any{ + "entries": entries, + "first_entry": firstEntry, + "total_entries": totalEntries, + "source": source, + }, nil +} + +func (a *Agent) resolveTranscriptPath(session *SessionState) (string, string, error) { + projectsRoot, err := a.transcriptProjectsRoot() + if err != nil { + return "", "", err + } + if retained := a.transcriptPathForSession(session.ID); retained != "" { + if resolved, resolveErr := resolveTranscriptFile(projectsRoot, retained); resolveErr == nil { + return resolved, "hook", nil + } + } + if strings.TrimSpace(session.CWD) == "" { + return "", "", fmt.Errorf("no Claude transcript for session") + } + + projectDir := filepath.Join(projectsRoot, claudeProjectSlug(session.CWD)) + items, err := os.ReadDir(projectDir) + if err != nil { + return "", "", fmt.Errorf("no Claude transcript for session: %w", err) + } + var newestPath string + var newestModTime int64 + for _, item := range items { + if item.IsDir() || !strings.EqualFold(filepath.Ext(item.Name()), ".jsonl") { + continue + } + candidate := filepath.Join(projectDir, item.Name()) + resolved, err := resolveTranscriptFile(projectsRoot, candidate) + if err != nil { + continue + } + info, err := os.Stat(resolved) + if err != nil { + continue + } + modTime := info.ModTime().UnixNano() + if newestPath == "" || modTime > newestModTime { + newestPath = resolved + newestModTime = modTime + } + } + if newestPath == "" { + return "", "", fmt.Errorf("no Claude transcript for session") + } + return newestPath, "derived", nil +} + +func (a *Agent) transcriptProjectsRoot() (string, error) { + if a.claudeProjectsRoot != "" { + return a.claudeProjectsRoot, nil + } + home, err := os.UserHomeDir() + if err != nil { + return "", fmt.Errorf("resolve home directory: %w", err) + } + return filepath.Join(home, ".claude", "projects"), nil +} + +func claudeProjectSlug(cwd string) string { + return strings.Map(func(r rune) rune { + if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || + (r >= '0' && r <= '9') || r == '-' { + return r + } + return '-' + }, cwd) +} + +func resolveTranscriptFile(projectsRoot, candidate string) (string, error) { + root, err := filepath.EvalSymlinks(projectsRoot) + if err != nil { + return "", err + } + resolved, err := filepath.EvalSymlinks(candidate) + if err != nil { + return "", err + } + relative, err := filepath.Rel(root, resolved) + if err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) { + return "", fmt.Errorf("transcript path is outside Claude projects") + } + info, err := os.Stat(resolved) + if err != nil { + return "", err + } + if !info.Mode().IsRegular() { + return "", fmt.Errorf("transcript path is not a regular file") + } + return resolved, nil +} + +func readTranscriptPage(path string, request protocol.CaptureTranscriptPayload) ([]map[string]any, int, int, error) { + totalEntries, err := countTranscriptEntries(path) + if err != nil { + return nil, 0, 0, err + } + endEntry := totalEntries + if request.BeforeEntry != nil { + endEntry = *request.BeforeEntry + if endEntry > totalEntries { + return nil, 0, totalEntries, fmt.Errorf("%w: before_entry %d exceeds total entries %d", errInvalidTranscriptRequest, endEntry, totalEntries) + } + } + firstEntry := max(0, endEntry-request.PageSize) + + file, err := os.Open(path) + if err != nil { + return nil, 0, totalEntries, err + } + defer file.Close() + scanner := newTranscriptScanner(file) + entries := make([]map[string]any, 0, endEntry-firstEntry) + entryIndex := 0 + for scanner.Scan() { + line := strings.TrimSpace(scanner.Text()) + if line == "" { + continue + } + if entryIndex >= firstEntry && entryIndex < endEntry { + var entry map[string]any + if err := json.Unmarshal([]byte(line), &entry); err != nil { + // Claude appends to these files live; a torn or corrupt line + // must not fail the page. The stub renders as nothing. + entries = append(entries, map[string]any{"type": "x-unparseable"}) + } else { + entries = append(entries, sanitizeTranscriptEntry(entry)) + } + } + entryIndex++ + if entryIndex >= endEntry { + break + } + } + if err := scanner.Err(); err != nil { + return nil, 0, totalEntries, err + } + return entries, firstEntry, totalEntries, nil +} + +func countTranscriptEntries(path string) (int, error) { + file, err := os.Open(path) + if err != nil { + return 0, err + } + defer file.Close() + scanner := newTranscriptScanner(file) + count := 0 + lastLine := "" + for scanner.Scan() { + if line := strings.TrimSpace(scanner.Text()); line != "" { + count++ + lastLine = line + } + } + if err := scanner.Err(); err != nil { + return 0, err + } + // Exclude a mid-append torn tail so the newest page ends on a complete + // entry and count/page indices stay aligned across the retry. + if count > 0 && !json.Valid([]byte(lastLine)) { + count-- + } + return count, nil +} + +func newTranscriptScanner(file *os.File) *bufio.Scanner { + scanner := bufio.NewScanner(file) + scanner.Buffer(make([]byte, 64*1024), maxTranscriptScannerToken) + return scanner +} + +func sanitizeTranscriptEntry(entry map[string]any) map[string]any { + trimmed := make(map[string]any, len(entry)) + for key, value := range entry { + // Bulky non-rendered payloads (Bash stdout, Edit diffs, …) ride under + // toolUseResult; the formatter never displays them. + if strings.EqualFold(key, "toolUseResult") || strings.EqualFold(key, "tool_use_result") { + continue + } + trimmed[key] = value + } + budget := maxTranscriptEntryBytes + return sanitizeTranscriptMap(trimmed, true, &budget) +} + +func sanitizeTranscriptMap(value map[string]any, inContent bool, contentBudget *int) map[string]any { + keys := make([]string, 0, len(value)) + for key := range value { + keys = append(keys, key) + } + sort.Strings(keys) + cleaned := make(map[string]any, len(value)) + for _, key := range keys { + item := value[key] + if shouldDropTranscriptBlob(value, key, item) { + continue + } + if strings.EqualFold(key, "content") { + budget := maxTranscriptContentBytes + cleaned[key] = sanitizeTranscriptValue(item, true, &budget, true) + continue + } + countString := inContent && !isTranscriptMetadataKey(key) + cleaned[key] = sanitizeTranscriptValue(item, inContent, contentBudget, countString) + } + return cleaned +} + +func sanitizeTranscriptValue(value any, inContent bool, contentBudget *int, countString bool) any { + switch typed := value.(type) { + case map[string]any: + return sanitizeTranscriptMap(typed, inContent, contentBudget) + case []any: + cleaned := make([]any, 0, len(typed)) + for _, item := range typed { + cleaned = append(cleaned, sanitizeTranscriptValue(item, inContent, contentBudget, true)) + } + return cleaned + case string: + if !inContent || contentBudget == nil || !countString { + return typed + } + cleaned := truncateUTF8Bytes(typed, *contentBudget) + *contentBudget -= len([]byte(cleaned)) + return cleaned + default: + return typed + } +} + +func isTranscriptMetadataKey(key string) bool { + switch strings.ToLower(key) { + case "id", "type", "role", "name", "media_type", "mime_type": + return true + default: + return false + } +} + +func shouldDropTranscriptBlob(parent map[string]any, key string, value any) bool { + text, ok := value.(string) + if !ok { + return false + } + normalizedKey := strings.ToLower(key) + if normalizedKey == "base64" || normalizedKey == "blob" { + return true + } + if normalizedKey != "data" { + return false + } + parentType, _ := parent["type"].(string) + parentType = strings.ToLower(parentType) + return parentType == "base64" || parentType == "binary" || looksLikeBase64(text) +} + +func looksLikeBase64(value string) bool { + if len(value) < 128 { + return false + } + for _, char := range value { + if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || + (char >= '0' && char <= '9') || char == '+' || char == '/' || char == '=' || + char == '\r' || char == '\n' { + continue + } + return false + } + return true +} + +func truncateUTF8Bytes(value string, limit int) string { + if limit <= 0 { + return "" + } + if len([]byte(value)) <= limit { + return value + } + truncated := []byte(value)[:limit] + for len(truncated) > 0 && !utf8.Valid(truncated) { + truncated = truncated[:len(truncated)-1] + } + return string(truncated) +} diff --git a/agents/agentd/internal/commands/executor.go b/agents/agentd/internal/commands/executor.go index 69aab865..2a4e14d3 100644 --- a/agents/agentd/internal/commands/executor.go +++ b/agents/agentd/internal/commands/executor.go @@ -23,6 +23,18 @@ type Result = protocol.CommandResultPayload type Handler func(Dispatch) (map[string]any, error) type ResultHandler func(Result) +type commandResultError struct { + code string + message string +} + +func (e *commandResultError) Error() string { return e.message } +func (e *commandResultError) CommandResultCode() string { return e.code } + +func NewResultError(code, message string) error { + return &commandResultError{code: code, message: message} +} + // Executor runs commands on a fixed worker pool while allowing at most one // in-flight command for each session key. type Executor struct { @@ -155,7 +167,12 @@ func (e *Executor) execute(dispatch Dispatch) (result Result) { payload, err := e.handler(dispatch) if err != nil { - result.Error = &ResultError{Code: "COMMAND_FAILED", Message: err.Error()} + code := "COMMAND_FAILED" + var coded interface{ CommandResultCode() string } + if errors.As(err, &coded) && coded.CommandResultCode() != "" { + code = coded.CommandResultCode() + } + result.Error = &ResultError{Code: code, Message: err.Error()} return result } result.OK = true diff --git a/agents/agentd/internal/protocol/command.go b/agents/agentd/internal/protocol/command.go index 956a9f60..2748b474 100644 --- a/agents/agentd/internal/protocol/command.go +++ b/agents/agentd/internal/protocol/command.go @@ -147,6 +147,18 @@ type CapturePanePayload struct { StripANSI bool `json:"strip_ansi"` } +type CaptureTranscriptPayload struct { + PageSize int `json:"page_size,omitempty"` + BeforeEntry *int `json:"before_entry,omitempty"` +} + +type CaptureTranscriptResult struct { + Entries []map[string]any `json:"entries"` + FirstEntry int `json:"first_entry"` + TotalEntries int `json:"total_entries"` + Source string `json:"source"` +} + type CopyToSessionPayload struct { TargetSessionID string `json:"target_session_id"` Mode string `json:"mode"` diff --git a/agents/agentd/internal/ws/protocol_fixtures_test.go b/agents/agentd/internal/ws/protocol_fixtures_test.go index 2f372508..8e0d3d65 100644 --- a/agents/agentd/internal/ws/protocol_fixtures_test.go +++ b/agents/agentd/internal/ws/protocol_fixtures_test.go @@ -86,7 +86,7 @@ func TestProtocolFixtureMatrixRoundTripsProductionTypes(t *testing.T) { wantCommands := []string{ "send_input", "send_keys", "interrupt", "kill_session", "adopt_pane", "rename_session", "spawn_session", "spawn_job", "fork", "console.subscribe", "console.unsubscribe", - "capture_pane", "copy_to_session", "list_directory", + "capture_pane", "capture_transcript", "copy_to_session", "list_directory", "new_window", "kill_window", "rename_window", "split_pane", "select_window", "select_pane", "resize_pane", "zoom_pane", } @@ -217,6 +217,8 @@ func commandPayloadTarget(t *testing.T, commandType string) any { return &protocol.ConsoleUnsubscribePayload{} case "capture_pane": return &protocol.CapturePanePayload{} + case "capture_transcript": + return &protocol.CaptureTranscriptPayload{} case "copy_to_session": return &protocol.CopyToSessionPayload{} case "list_directory": diff --git a/apps/dashboard/src/components/TerminalView.tsx b/apps/dashboard/src/components/TerminalView.tsx index dc89105f..cf4ba25a 100644 --- a/apps/dashboard/src/components/TerminalView.tsx +++ b/apps/dashboard/src/components/TerminalView.tsx @@ -258,7 +258,8 @@ export function TerminalView({ strip_ansi: true, }); if (cancelled || !response.ok) return; - cacheScrollMode(historySessionId, classifyTerminalScrollMode(response.result?.content)); + const mode = classifyTerminalScrollMode(response.result?.content); + if (mode === 'history') cacheScrollMode(historySessionId, mode); } catch { // Transport failure leaves the pane unclassified; the overlay path re-probes. } diff --git a/apps/dashboard/src/components/terminal/TerminalHistoryOverlay.tsx b/apps/dashboard/src/components/terminal/TerminalHistoryOverlay.tsx index a786c33b..02c593e5 100644 --- a/apps/dashboard/src/components/terminal/TerminalHistoryOverlay.tsx +++ b/apps/dashboard/src/components/terminal/TerminalHistoryOverlay.tsx @@ -2,8 +2,9 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'; import { ArrowDown, Loader2, RotateCcw } from 'lucide-react'; +import type { TranscriptEntry } from '@agent-command/schema'; import { Button } from '@/components/ui/button'; -import { getSessionScrollback } from '@/lib/api'; +import { getSessionScrollback, getSessionTranscript } from '@/lib/api'; import { SCROLLBACK_PAGE_LINES, compensateScrollbackPrepend, @@ -17,6 +18,7 @@ import { type ScrollbackRange, } from './scrollbackPaging'; import { classifyTerminalScrollMode, type TerminalScrollMode } from './terminalScrollMode'; +import { formatTranscriptEntries } from './transcriptFormatter'; interface TerminalHistoryOverlayProps { sessionId: string; @@ -27,12 +29,28 @@ interface TerminalHistoryOverlayProps { } interface HistoryPage { + type: 'history'; range: ScrollbackRange; lines: string[]; - scrollMode: TerminalScrollMode; +} + +interface ChatPage { + type: 'chat'; + entries: TranscriptEntry[]; + firstEntry: number; + totalEntries: number; } const OVERSCAN_LINES = 12; +const TRANSCRIPT_PAGE_ENTRIES = 200; + +type OverlayPage = HistoryPage | ChatPage; + +interface OverlayLine { + key: string; + text: string; + dim: boolean; +} export function TerminalHistoryOverlay({ sessionId, @@ -41,21 +59,23 @@ export function TerminalHistoryOverlay({ onScrollModeResolved, onClose, }: TerminalHistoryOverlayProps) { - const [pages, setPages] = useState([]); + const [pages, setPages] = useState([]); + const [mode, setMode] = useState<'history' | 'chat' | null>(null); const [loadingInitial, setLoadingInitial] = useState(false); const [loadingOlder, setLoadingOlder] = useState(false); const [hasOlder, setHasOlder] = useState(true); const [error, setError] = useState(null); const [scrollTop, setScrollTop] = useState(0); const [viewportHeight, setViewportHeight] = useState(0); + const [viewportWidth, setViewportWidth] = useState(0); const scrollRef = useRef(null); const generationRef = useRef(0); const loadingOlderRef = useRef(false); const overscrollStartRef = useRef<{ y: number; atBottom: boolean } | null>(null); const lineHeight = Math.max(16, Math.round(fontSize * 1.2)); - const fetchPage = useCallback( - async (range: ScrollbackRange): Promise => { + const fetchHistoryPage = useCallback( + async (range: ScrollbackRange): Promise<{ page: HistoryPage; scrollMode: TerminalScrollMode }> => { const response = await getSessionScrollback(sessionId, { mode: 'range', start_line: range.startLine, @@ -67,37 +87,81 @@ export function TerminalHistoryOverlay({ } const content = response.result?.content; return { - range, - lines: contentScrollbackLines(content), + page: { + type: 'history', + range, + lines: contentScrollbackLines(content), + }, scrollMode: classifyTerminalScrollMode(content), }; }, [sessionId] ); + const fetchChatPage = useCallback( + async (beforeEntry?: number): Promise => { + const response = await getSessionTranscript(sessionId, { + page_size: TRANSCRIPT_PAGE_ENTRIES, + ...(beforeEntry !== undefined ? { before_entry: beforeEntry } : {}), + }); + if (!response.ok) { + throw new Error(response.error.message); + } + return { + type: 'chat', + entries: response.result.entries, + firstEntry: response.result.first_entry, + totalEntries: response.result.total_entries, + }; + }, + [sessionId] + ); + const loadInitial = useCallback(async () => { const generation = ++generationRef.current; setLoadingInitial(true); setError(null); setPages([]); + setMode(null); setHasOlder(true); setScrollTop(0); try { - const page = await fetchPage(initialScrollbackRange()); - onScrollModeResolved(page.scrollMode); + const { page, scrollMode } = await fetchHistoryPage(initialScrollbackRange()); if (generationRef.current !== generation) return; - if (page.scrollMode === 'app-scroll') { - onClose(); + if (scrollMode === 'app-scroll') { + try { + const chatPage = await fetchChatPage(); + if (generationRef.current !== generation) return; + setMode('chat'); + setPages([chatPage]); + setHasOlder(chatPage.firstEntry > 0); + onScrollModeResolved('chat'); + requestAnimationFrame(() => { + const element = scrollRef.current; + if (!element || generationRef.current !== generation) return; + element.scrollTop = element.scrollHeight; + setScrollTop(element.scrollTop); + setViewportHeight(element.clientHeight); + setViewportWidth(element.clientWidth); + }); + } catch { + if (generationRef.current !== generation) return; + onScrollModeResolved('app-scroll'); + onClose(); + } return; } + setMode('history'); setPages([page]); setHasOlder(page.lines.length >= SCROLLBACK_PAGE_LINES); + onScrollModeResolved('history'); requestAnimationFrame(() => { const element = scrollRef.current; if (!element || generationRef.current !== generation) return; element.scrollTop = element.scrollHeight; setScrollTop(element.scrollTop); setViewportHeight(element.clientHeight); + setViewportWidth(element.clientWidth); }); } catch (loadError) { if (generationRef.current !== generation) return; @@ -107,7 +171,7 @@ export function TerminalHistoryOverlay({ } finally { if (generationRef.current === generation) setLoadingInitial(false); } - }, [fetchPage, onClose, onScrollModeResolved]); + }, [fetchChatPage, fetchHistoryPage, onClose, onScrollModeResolved]); useEffect(() => { if (!open) { @@ -124,28 +188,43 @@ export function TerminalHistoryOverlay({ if (!open) return; const element = scrollRef.current; if (!element) return; - const updateHeight = () => setViewportHeight(element.clientHeight); - updateHeight(); - const observer = new ResizeObserver(updateHeight); + const updateViewport = () => { + setViewportHeight(element.clientHeight); + setViewportWidth(element.clientWidth); + }; + updateViewport(); + const observer = new ResizeObserver(updateViewport); observer.observe(element); return () => observer.disconnect(); }, [open]); const loadOlder = useCallback(async () => { - if (loadingOlderRef.current || !hasOlder) return; + if (loadingOlderRef.current || !hasOlder || mode === null) return; const generation = generationRef.current; - const currentOldest = pages[0]?.range ?? initialScrollbackRange(); - const range = olderScrollbackRange(currentOldest); const element = scrollRef.current; const previousHeight = element?.scrollHeight ?? 0; loadingOlderRef.current = true; setLoadingOlder(true); setError(null); try { - const page = await fetchPage(range); + let page: OverlayPage; + let olderAvailable: boolean; + if (mode === 'chat') { + const currentOldest = pages[0]?.type === 'chat' ? pages[0].firstEntry : 0; + page = await fetchChatPage(currentOldest); + olderAvailable = page.firstEntry > 0; + } else { + const currentOldest = pages[0]?.type === 'history' + ? pages[0].range + : initialScrollbackRange(); + const range = olderScrollbackRange(currentOldest); + const historyPage = await fetchHistoryPage(range); + page = historyPage.page; + olderAvailable = page.lines.length >= SCROLLBACK_PAGE_LINES; + } if (generationRef.current !== generation) return; setPages((current) => [page, ...current]); - setHasOlder(page.lines.length >= SCROLLBACK_PAGE_LINES); + setHasOlder(olderAvailable); requestAnimationFrame(() => { if (!element || generationRef.current !== generation) return; const nextTop = compensateScrollbackPrepend( @@ -159,7 +238,11 @@ export function TerminalHistoryOverlay({ } catch (loadError) { if (generationRef.current !== generation) return; setError( - loadError instanceof Error ? loadError.message : 'Older history could not be loaded.' + loadError instanceof Error + ? loadError.message + : mode === 'chat' + ? 'Older chat could not be loaded.' + : 'Older history could not be loaded.' ); } finally { if (generationRef.current === generation) { @@ -167,11 +250,30 @@ export function TerminalHistoryOverlay({ setLoadingOlder(false); } } - }, [fetchPage, hasOlder, pages]); + }, [fetchChatPage, fetchHistoryPage, hasOlder, mode, pages]); - const allLines = useMemo( - () => pages.flatMap((page) => numberScrollbackLines(page.range, page.lines)), - [pages] + const transcriptColumns = Math.max( + 20, + Math.floor((viewportWidth || 320) / Math.max(1, fontSize * 0.62)) - 2 + ); + const allLines = useMemo( + () => pages.flatMap((page) => { + if (page.type === 'history') { + return numberScrollbackLines(page.range, page.lines).map((line) => ({ + key: `history:${line.lineNumber}`, + text: line.text, + dim: false, + })); + } + return page.entries.flatMap((entry, entryOffset) => ( + formatTranscriptEntries([entry], transcriptColumns).map((line, lineOffset) => ({ + key: `chat:${page.firstEntry + entryOffset}:${lineOffset}`, + text: line.text, + dim: line.dim, + })) + )); + }), + [pages, transcriptColumns] ); const virtualWindow = resolveScrollbackVirtualWindow({ lineCount: allLines.length, @@ -195,7 +297,11 @@ export function TerminalHistoryOverlay({ className="rounded-full border border-white/10 bg-black/75 px-2.5 py-1 font-sans text-[10px] font-medium text-white/65 shadow-sm backdrop-blur" aria-live="polite" > - {loadingOlder ? 'Loading older…' : hasOlder ? 'History' : 'Start of history'} + {loadingOlder + ? 'Loading older…' + : hasOlder + ? mode === 'chat' ? 'Chat' : 'History' + : mode === 'chat' ? 'Start of chat' : 'Start of history'}