@phenx-inc/ctlsurf 0.4.0 → 0.5.1

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]`
+}

package/src/main/tui.ts

@@ -140,6 +140,10 @@ export class Tui {
       let selected = 0
       let trackTime = options.initialTrackTime
       let logChat = options.initialLogChat
+      // Navigable items: agent rows, then Track time and Log chat checkbox rows
+      const trackIdx = agents.length
+      const logIdx = agents.length + 1
+      const itemCount = agents.length + 2
       const modalWidth = 44
       // +4 for borders/title/sep, +3 for separator + track-time row + log-chat row
       const modalHeight = agents.length + 4 + 3
@@ -190,26 +194,27 @@ export class Tui {
         const sepRow = startRow + 3 + agents.length
         this.write(`${CSI}${sepRow};${startCol}H${BG_MODAL}${FG_DIM}${innerSep}${RESET}`)
 
+        const drawCheckboxRow = (row: number, label: string, checked: boolean, isSelected: boolean) => {
+          const bg = isSelected ? BG_SELECTED : BG_MODAL
+          const pointer = isSelected ? `${FG_ACCENT}▸ ` : '  '
+          const checkbox = checked ? `${FG_GREEN}[✓]${RESET}${bg}` : `${FG_DIM}[ ]${RESET}${bg}`
+          const labelFg = checked || isSelected ? FG_WHITE : FG_DIM
+          const content = `${pointer}${checkbox} ${labelFg}${label}${RESET}${bg}`
+          const contentLen = 2 + 3 + 1 + label.length
+          const pad = ' '.repeat(Math.max(0, modalWidth - 2 - contentLen))
+          this.write(`${CSI}${row};${startCol}H${bg}${FG_DIM}│${RESET}${bg}${content}${pad}${RESET}${BG_MODAL}${FG_DIM}│${RESET}`)
+        }
+
         const trackRow = sepRow + 1
-        const checkbox = trackTime ? `${FG_GREEN}[✓]${RESET}${BG_MODAL}` : `${FG_DIM}[ ]${RESET}${BG_MODAL}`
-        const trackLabelFg = trackTime ? FG_WHITE : FG_DIM
-        const trackContent = `  ${checkbox} ${trackLabelFg}Track time${RESET}${BG_MODAL}`
-        const trackContentLen = 2 + 3 + 1 + 'Track time'.length
-        const trackPad = ' '.repeat(Math.max(0, modalWidth - 2 - trackContentLen))
-        this.write(`${CSI}${trackRow};${startCol}H${BG_MODAL}${FG_DIM}│${RESET}${BG_MODAL}${trackContent}${trackPad}${FG_DIM}│${RESET}`)
+        drawCheckboxRow(trackRow, 'Track time', trackTime, selected === trackIdx)
 
         const logRow = trackRow + 1
-        const logCheckbox = logChat ? `${FG_GREEN}[\u2713]${RESET}${BG_MODAL}` : `${FG_DIM}[ ]${RESET}${BG_MODAL}`
-        const logLabelFg = logChat ? FG_WHITE : FG_DIM
-        const logContent = `  ${logCheckbox} ${logLabelFg}Log chat${RESET}${BG_MODAL}`
-        const logContentLen = 2 + 3 + 1 + 'Log chat'.length
-        const logPad = ' '.repeat(Math.max(0, modalWidth - 2 - logContentLen))
-        this.write(`${CSI}${logRow};${startCol}H${BG_MODAL}${FG_DIM}\u2502${RESET}${BG_MODAL}${logContent}${logPad}${FG_DIM}\u2502${RESET}`)
+        drawCheckboxRow(logRow, 'Log chat', logChat, selected === logIdx)
 
         const botRow = logRow + 1
         this.write(`${CSI}${botRow};${startCol}H${BG_MODAL}${FG_DIM}${botBorder}${RESET}`)
 
-        const hint = '\u2191\u2193 nav \u00B7 Enter \u00B7 t track \u00B7 l log \u00B7 q quit'
+        const hint = '\u2191\u2193 nav \u00B7 Enter select \u00B7 Space toggle \u00B7 q quit'
         const hintCol = Math.max(1, Math.floor((this.cols - hint.length) / 2))
         this.write(`${CSI}${botRow + 2};${hintCol}H${FG_DIM}${hint}${RESET}`)
       }
@@ -224,11 +229,23 @@ export class Tui {
       const onKey = (data: Buffer) => {
         const key = data.toString()
 
+        const toggleSelected = (): boolean => {
+          if (selected === trackIdx) {
+            trackTime = !trackTime
+          } else if (selected === logIdx) {
+            logChat = !logChat
+          } else {
+            return false
+          }
+          drawModal()
+          return true
+        }
+
         if (key === '\x1b[A' || key === 'k') {
-          selected = (selected - 1 + agents.length) % agents.length
+          selected = (selected - 1 + itemCount) % itemCount
           drawModal()
         } else if (key === '\x1b[B' || key === 'j') {
-          selected = (selected + 1) % agents.length
+          selected = (selected + 1) % itemCount
           drawModal()
         } else if (key === 't' || key === 'T') {
           trackTime = !trackTime
@@ -236,9 +253,14 @@ export class Tui {
         } else if (key === 'l' || key === 'L') {
           logChat = !logChat
           drawModal()
+        } else if (key === ' ') {
+          toggleSelected()
         } else if (key === '\r' || key === '\n') {
-          cleanup()
-          resolve({ agentIdx: selected, trackTime, logChat })
+          // Enter on a checkbox row toggles it; on an agent row it confirms
+          if (!toggleSelected()) {
+            cleanup()
+            resolve({ agentIdx: selected, trackTime, logChat })
+          }
         } else if (key === 'q' || key === '\x1b' || key === '\x03') {
           cleanup()
           this.write(`${CSI}?25h`)