beehaven 0.8.16

package/dist/transcript-tailer.js

@@ -0,0 +1,215 @@
+/**
+ * TranscriptTailer — tails Claude Code session JSONL files for full conversation streaming.
+ *
+ * When a SessionStart hook fires, we get the transcript_path. We then watch
+ * that file and stream every new entry (user prompts, assistant prose, tool calls,
+ * tool results) to the relay for DO storage and to IPC clients for live display.
+ *
+ * This captures everything hooks DON'T: Claude's conversational text responses,
+ * thinking blocks, and the full conversation flow.
+ */
+// chokidar is loaded lazily in startTailing() so a daemon without chokidar
+// bundled still imports this module cleanly — tailing becomes a no-op.
+import { createReadStream, existsSync, statSync } from 'fs';
+import { createInterface } from 'readline';
+import { EventEmitter } from 'events';
+export class TranscriptTailer extends EventEmitter {
+    /** Active tailers keyed by session ID */
+    tailers = new Map();
+    /**
+     * Start tailing a session transcript.
+     * Call this when a SessionStart hook fires with transcript_path.
+     */
+    async startTailing(sessionId, transcriptPath) {
+        // Callers fire-and-forget this method; any throw would become an
+        // unhandled rejection. All paths log and return.
+        try {
+            if (this.tailers.has(sessionId))
+                return;
+            if (!existsSync(transcriptPath))
+                return;
+            let watch;
+            try {
+                watch = (await import('chokidar')).watch;
+            }
+            catch {
+                console.warn(`[transcript-tailer] chokidar not available — cannot tail ${transcriptPath}`);
+                return;
+            }
+            await this._startTailingInner(sessionId, transcriptPath, watch);
+        }
+        catch (err) {
+            console.warn(`[transcript-tailer] startTailing failed for ${transcriptPath}: ${err?.message ?? err}`);
+        }
+    }
+    async _startTailingInner(sessionId, transcriptPath, watch) {
+        const lastSize = statSync(transcriptPath).size;
+        const watcher = watch(transcriptPath, {
+            persistent: true,
+            usePolling: true,
+            interval: 200,
+        });
+        const state = { path: transcriptPath, watcher, lastSize, processing: false };
+        this.tailers.set(sessionId, state);
+        watcher.on('change', () => {
+            this.readNewLines(sessionId, state);
+        });
+        // Read any existing content after our start position
+        // (there may be lines written between SessionStart and our watch starting)
+        setTimeout(() => this.readNewLines(sessionId, state), 100);
+    }
+    /**
+     * Stop tailing a session (call on SessionEnd).
+     * Does a final read to capture any remaining lines.
+     */
+    stopTailing(sessionId) {
+        const state = this.tailers.get(sessionId);
+        if (!state)
+            return;
+        // Final read
+        this.readNewLines(sessionId, state);
+        state.watcher.close();
+        this.tailers.delete(sessionId);
+    }
+    /** Stop all tailers */
+    stopAll() {
+        for (const [sessionId] of this.tailers) {
+            this.stopTailing(sessionId);
+        }
+    }
+    /** Number of active tailers */
+    get activeCount() {
+        return this.tailers.size;
+    }
+    // ─── Internal ───
+    async readNewLines(sessionId, state) {
+        if (state.processing)
+            return;
+        state.processing = true;
+        try {
+            if (!existsSync(state.path)) {
+                state.processing = false;
+                return;
+            }
+            const currentSize = statSync(state.path).size;
+            if (currentSize <= state.lastSize) {
+                if (currentSize < state.lastSize)
+                    state.lastSize = 0; // File was truncated
+                state.processing = false;
+                return;
+            }
+            const stream = createReadStream(state.path, {
+                start: state.lastSize,
+                encoding: 'utf8',
+            });
+            const rl = createInterface({ input: stream });
+            for await (const line of rl) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const raw = JSON.parse(line);
+                    const entry = this.parseEntry(sessionId, raw);
+                    if (entry) {
+                        this.emit('entry', entry);
+                    }
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            state.lastSize = currentSize;
+        }
+        catch {
+            // File may have been deleted
+        }
+        state.processing = false;
+    }
+    parseEntry(sessionId, raw) {
+        // Skip file-history-snapshot entries (large, not conversational)
+        if (raw.type === 'file-history-snapshot')
+            return null;
+        // Skip progress entries (subagent internal)
+        if (raw.type === 'progress')
+            return null;
+        // User message
+        if (raw.type === 'user' && raw.message?.role === 'user') {
+            const content = typeof raw.message.content === 'string'
+                ? raw.message.content
+                : Array.isArray(raw.message.content)
+                    ? raw.message.content
+                        .filter((b) => b.type === 'text')
+                        .map((b) => b.text)
+                        .join('')
+                    : '';
+            return {
+                sessionId,
+                type: 'user',
+                role: 'user',
+                content,
+                uuid: raw.uuid,
+                timestamp: raw.timestamp,
+                raw,
+            };
+        }
+        // Assistant message
+        if (raw.type === 'assistant' || raw.message?.role === 'assistant') {
+            const content = raw.message?.content;
+            if (!Array.isArray(content))
+                return null;
+            // Extract text blocks
+            const textParts = content.filter((b) => b.type === 'text').map((b) => b.text);
+            const text = textParts.join('');
+            // Extract tool use blocks
+            const toolUses = content.filter((b) => b.type === 'tool_use');
+            // If it has text, emit as assistant message
+            if (text) {
+                return {
+                    sessionId,
+                    type: 'assistant',
+                    role: 'assistant',
+                    content: text,
+                    uuid: raw.uuid,
+                    timestamp: raw.timestamp,
+                    raw,
+                };
+            }
+            // If it has tool use, emit as tool_use
+            if (toolUses.length > 0) {
+                const tool = toolUses[0];
+                return {
+                    sessionId,
+                    type: 'tool_use',
+                    toolName: tool.name,
+                    toolInput: tool.input,
+                    uuid: raw.uuid,
+                    timestamp: raw.timestamp,
+                    raw,
+                };
+            }
+            // If it has thinking, emit as thinking
+            const thinking = content.find((b) => b.type === 'thinking');
+            if (thinking) {
+                return {
+                    sessionId,
+                    type: 'thinking',
+                    content: '(thinking...)',
+                    uuid: raw.uuid,
+                    timestamp: raw.timestamp,
+                    raw,
+                };
+            }
+        }
+        // Tool result
+        if (raw.type === 'tool_result') {
+            return {
+                sessionId,
+                type: 'tool_result',
+                toolResponse: raw.content,
+                uuid: raw.uuid,
+                timestamp: raw.timestamp,
+                raw,
+            };
+        }
+        return null;
+    }
+}