@phenx-inc/ctlsurf 0.4.0 → 0.5.0

package/src/main/transcripts.ts

@@ -0,0 +1,341 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+/**
+ * Transcript Tailer
+ *
+ * Primary chat-log source for agents that write native session transcripts
+ * (Claude Code, Codex CLI). Instead of scraping the TUI screen — which hard-
+ * wraps paragraphs at terminal width and leaks chrome — we tail the agent's
+ * own JSONL transcript and forward exact user/assistant messages.
+ *
+ * The ConversationBridge screen-scraper remains the fallback for agents
+ * without a known transcript format (plain shell, unknown CLIs).
+ *
+ * Formats:
+ * - Claude Code: ~/.claude/projects/<cwd-slug>/<sessionId>.jsonl
+ *   One JSON object per line: { type: 'user'|'assistant', message, timestamp, cwd, ... }
+ * - Codex CLI: ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<id>.jsonl
+ *   First line is { type: 'session_meta', payload: { cwd, ... } }; chat content
+ *   arrives as { type: 'event_msg', payload: { type: 'user_message'|'agent_message', message } }
+ */
+
+export interface ChatLogEntry {
+  ts: string
+  type: 'user_input' | 'terminal_output'
+  content: string
+}
+
+export type ChatLogSink = (entry: ChatLogEntry) => void
+
+export type TranscriptAgentId = 'claude' | 'codex'
+
+export function supportsTranscriptLogging(agentId: string): agentId is TranscriptAgentId {
+  return agentId === 'claude' || agentId === 'codex'
+}
+
+export interface TranscriptTailerOptions {
+  agentId: TranscriptAgentId
+  cwd: string
+  sink: ChatLogSink
+  /** Override transcript roots (for tests). */
+  claudeProjectsDir?: string
+  codexSessionsDir?: string
+}
+
+const POLL_INTERVAL_MS = 1_000
+const DISCOVERY_SLACK_MS = 10_000
+const READ_CHUNK_BYTES = 64 * 1024
+const MAX_ENTRY_CHARS = 20_000
+
+interface FileTail {
+  offset: number
+  remainder: string
+  /** Codex file whose session_meta cwd belongs to a different project. */
+  excluded: boolean
+}
+
+export class TranscriptTailer {
+  private readonly agentId: TranscriptAgentId
+  private readonly cwd: string
+  private readonly sink: ChatLogSink
+  private readonly claudeProjectsDir: string
+  private readonly codexSessionsDir: string
+
+  private files = new Map<string, FileTail>()
+  private pollTimer: ReturnType<typeof setInterval> | null = null
+  private sinceMs = 0
+
+  constructor(options: TranscriptTailerOptions) {
+    this.agentId = options.agentId
+    this.cwd = stripTrailingSep(options.cwd)
+    this.sink = options.sink
+    this.claudeProjectsDir = options.claudeProjectsDir || path.join(os.homedir(), '.claude', 'projects')
+    this.codexSessionsDir = options.codexSessionsDir || path.join(os.homedir(), '.codex', 'sessions')
+  }
+
+  start(): void {
+    if (this.pollTimer) return
+    this.sinceMs = Date.now()
+    this.files.clear()
+    this.pollTimer = setInterval(() => this.poll(), POLL_INTERVAL_MS)
+    console.log(`[transcripts] Tailing ${this.agentId} transcripts for ${this.cwd}`)
+  }
+
+  stop(): void {
+    if (!this.pollTimer) return
+    clearInterval(this.pollTimer)
+    this.pollTimer = null
+    // Final drain so messages written just before exit aren't lost.
+    this.poll()
+    this.files.clear()
+    console.log('[transcripts] Stopped')
+  }
+
+  private poll(): void {
+    try {
+      this.discover()
+      for (const [filePath, tail] of this.files) {
+        if (!tail.excluded) this.drainFile(filePath, tail)
+      }
+    } catch (err) {
+      console.error('[transcripts] Poll error:', err)
+    }
+  }
+
+  // ─── Discovery ──────────────────────────────────
+
+  /**
+   * Track every transcript file with recent activity, not just the first
+   * match: /clear (Claude) or /new (Codex) starts a new session file in the
+   * middle of one PTY run, and tailing all active candidates handles the
+   * switch without special cases. Old idle files never match (stale mtime).
+   */
+  private discover(): void {
+    const dirs = this.agentId === 'claude' ? [this.claudeProjectsDirForCwd()] : this.codexDateDirs()
+
+    for (const dir of dirs) {
+      let names: string[]
+      try {
+        names = fs.readdirSync(dir)
+      } catch {
+        continue // Directory may not exist until the agent writes its first message
+      }
+      for (const name of names) {
+        if (!name.endsWith('.jsonl')) continue
+        if (this.agentId === 'codex' && !name.startsWith('rollout-')) continue
+        const filePath = path.join(dir, name)
+        if (this.files.has(filePath)) continue
+        try {
+          const stat = fs.statSync(filePath)
+          if (stat.mtimeMs >= this.sinceMs - DISCOVERY_SLACK_MS) {
+            this.files.set(filePath, { offset: 0, remainder: '', excluded: false })
+          }
+        } catch { /* ignore — file may have vanished */ }
+      }
+    }
+  }
+
+  private claudeProjectsDirForCwd(): string {
+    // Claude Code slugs the cwd by replacing every non-alphanumeric char with '-'
+    // e.g. /Users/me/Code/quick_apps/app → -Users-me-Code-quick-apps-app
+    const slug = this.cwd.replace(/[^a-zA-Z0-9]/g, '-')
+    return path.join(this.claudeProjectsDir, slug)
+  }
+
+  private codexDateDirs(): string[] {
+    // Codex groups sessions by local date; check the start date and today to
+    // cover sessions running across midnight.
+    const dirs = new Set<string>()
+    for (const ms of [this.sinceMs, Date.now()]) {
+      const d = new Date(ms)
+      const yyyy = String(d.getFullYear())
+      const mm = String(d.getMonth() + 1).padStart(2, '0')
+      const dd = String(d.getDate()).padStart(2, '0')
+      dirs.add(path.join(this.codexSessionsDir, yyyy, mm, dd))
+    }
+    return [...dirs]
+  }
+
+  // ─── Tailing ────────────────────────────────────
+
+  private drainFile(filePath: string, tail: FileTail): void {
+    let size: number
+    try {
+      size = fs.statSync(filePath).size
+    } catch {
+      return
+    }
+    if (size <= tail.offset) return
+
+    let fd: number
+    try {
+      fd = fs.openSync(filePath, 'r')
+    } catch {
+      return
+    }
+    try {
+      const buf = Buffer.alloc(READ_CHUNK_BYTES)
+      while (tail.offset < size && !tail.excluded) {
+        const bytesRead = fs.readSync(fd, buf, 0, READ_CHUNK_BYTES, tail.offset)
+        if (bytesRead <= 0) break
+        tail.offset += bytesRead
+        tail.remainder += buf.toString('utf-8', 0, bytesRead)
+
+        const lines = tail.remainder.split('\n')
+        tail.remainder = lines.pop() || ''
+        for (const line of lines) {
+          this.handleLine(line, tail)
+          if (tail.excluded) break
+        }
+      }
+    } catch (err) {
+      console.error(`[transcripts] Read error for ${filePath}:`, err)
+    } finally {
+      try { fs.closeSync(fd) } catch { /* ignore */ }
+    }
+  }
+
+  private handleLine(line: string, tail: FileTail): void {
+    const trimmed = line.trim()
+    if (!trimmed) return
+
+    let obj: any
+    try {
+      obj = JSON.parse(trimmed)
+    } catch {
+      return // tolerate partial/corrupt lines
+    }
+
+    const entry = this.agentId === 'claude' ? this.parseClaudeLine(obj) : this.parseCodexLine(obj, tail)
+    if (!entry) return
+
+    // Skip history replayed into resumed/forked session files.
+    const ms = Date.parse(entry.ts)
+    if (Number.isFinite(ms) && ms < this.sinceMs - DISCOVERY_SLACK_MS) return
+
+    this.sink({ ...entry, content: capLength(entry.content) })
+  }
+
+  // ─── Claude Code format ─────────────────────────
+
+  private parseClaudeLine(obj: any): ChatLogEntry | null {
+    if (!obj || typeof obj !== 'object') return null
+    if (obj.isMeta) return null
+    if (obj.type !== 'user' && obj.type !== 'assistant') return null
+    // Belt-and-braces: the slug dir already scopes to this cwd, but lines
+    // carry the cwd too (subagent/sidechain lines can differ).
+    if (typeof obj.cwd === 'string' && stripTrailingSep(obj.cwd) !== this.cwd) return null
+    if (obj.isSidechain) return null
+
+    const message = obj.message
+    if (!message) return null
+
+    const text = extractClaudeText(message.content, obj.type === 'user')
+    if (!text) return null
+
+    return {
+      ts: typeof obj.timestamp === 'string' ? obj.timestamp : new Date().toISOString(),
+      type: obj.type === 'user' ? 'user_input' : 'terminal_output',
+      content: text,
+    }
+  }
+
+  // ─── Codex CLI format ───────────────────────────
+
+  private parseCodexLine(obj: any, tail: FileTail): ChatLogEntry | null {
+    if (!obj || typeof obj !== 'object') return null
+    const payload = obj.payload
+
+    if (obj.type === 'session_meta') {
+      const metaCwd = payload?.cwd
+      if (typeof metaCwd === 'string' && stripTrailingSep(metaCwd) !== this.cwd) {
+        tail.excluded = true // another project's session sharing the date dir
+      }
+      return null
+    }
+
+    if (obj.type !== 'event_msg' || !payload || typeof payload !== 'object') return null
+
+    let type: ChatLogEntry['type']
+    if (payload.type === 'user_message') {
+      type = 'user_input'
+    } else if (payload.type === 'agent_message') {
+      type = 'terminal_output'
+    } else {
+      return null
+    }
+
+    const text = typeof payload.message === 'string' ? payload.message.trim() : ''
+    if (!text || isCodexNoise(text)) return null
+
+    return {
+      ts: typeof obj.timestamp === 'string' ? obj.timestamp : new Date().toISOString(),
+      type,
+      content: text,
+    }
+  }
+}
+
+// ─── Text extraction & filters ────────────────────
+
+/** Prefixes of injected/meta user content that isn't something the user typed. */
+const CLAUDE_NOISE_PREFIXES = [
+  '<local-command-caveat>',
+  '<command-name>',
+  '<command-message>',
+  '<local-command-stdout>',
+  '<bash-input>',
+  '<bash-stdout>',
+  '<bash-stderr>',
+  '<system-reminder>',
+  '<task-notification>',
+  'caveat: the messages below',
+  '[request interrupted',
+]
+
+const CODEX_NOISE_PREFIXES = [
+  '<environment_context>',
+  '<user_instructions>',
+  '<permissions instructions>',
+  '<turn_aborted>',
+]
+
+function isClaudeNoise(text: string): boolean {
+  const lower = text.trimStart().toLowerCase()
+  return CLAUDE_NOISE_PREFIXES.some((p) => lower.startsWith(p))
+}
+
+function isCodexNoise(text: string): boolean {
+  const lower = text.trimStart().toLowerCase()
+  return CODEX_NOISE_PREFIXES.some((p) => lower.startsWith(p))
+}
+
+function extractClaudeText(content: unknown, isUser: boolean): string {
+  if (typeof content === 'string') {
+    const text = content.trim()
+    return text && !isClaudeNoise(text) ? text : ''
+  }
+  if (!Array.isArray(content)) return ''
+
+  // Tool results come back as user-role lines; they're not typed input.
+  if (isUser && content.some((b: any) => b?.type === 'tool_result')) return ''
+
+  const parts: string[] = []
+  for (const block of content) {
+    if (block?.type !== 'text' || typeof block.text !== 'string') continue
+    const text = block.text.trim()
+    if (text && !isClaudeNoise(text)) parts.push(text)
+  }
+  return parts.join('\n\n')
+}
+
+function stripTrailingSep(p: string): string {
+  return p.length > 1 ? p.replace(/[/\\]+$/, '') : p
+}
+
+function capLength(str: string): string {
+  if (str.length <= MAX_ENTRY_CHARS) return str
+  return str.slice(0, MAX_ENTRY_CHARS) + `… [truncated, ${str.length} total chars]`
+}