imcodes 2026.4.1875-dev.1861 → 2026.4.1881-dev.1865

package/dist/src/daemon/jsonl-watcher.js

@@ -21,8 +21,8 @@ import logger from '../util/logger.js';
 import { resolveContextWindow } from '../util/model-context.js';
 import { getSessionContextWindow } from './cc-presets.js';
 import { registerWatcherControl, unregisterWatcherControl } from './watcher-controls.js';
-import { TIMELINE_EVENT_FILE_CHANGE } from '../../shared/file-change.js';
-import { normalizeClaudeFileChange } from './file-change-normalizer.js';
+import { createParseContext, forgetSession as forgetSessionInCtx, parseLines as parseLinesInCtx, } from './jsonl-parse-core.js';
+import { jsonlParsePool, isJsonlWorkerEnabled } from './jsonl-parse-pool.js';
 // ── Path helpers ──────────────────────────────────────────────────────────────
 /** Compute a filesystem-safe project key from an absolute path.
  *  Replaces / \ and : with '-'. Used by Claude Code and Codex watchers.
@@ -134,364 +134,26 @@ async function findLatestJsonl(dir) {
     withStats.sort((a, b) => b.mtime - a.mtime);
     return join(dir, withStats[0].f);
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
-}
-function extractToolInput(name, input) {
-    if (!input)
-        return '';
-    if (name === 'Grep') {
-        const pattern = input.pattern ?? input.query ?? input.text;
-        const path = input.path ?? input.file_path ?? input.filePath;
-        if (pattern && path)
-            return `${String(pattern).split('\n')[0]} in ${String(path).split('\n')[0]}`;
-    }
-    const val = input.command
-        ?? input.path
-        ?? input.file_path
-        ?? input.pattern
-        ?? input.description
-        ?? input.query
-        ?? input.objective
-        ?? input.text
-        ?? '';
-    const text = String(val);
-    return text.split('\n')[0] ?? '';
-}
-const pendingClaudeToolCalls = new Map();
-function getPendingClaudeTools(sessionName) {
-    let pending = pendingClaudeToolCalls.get(sessionName);
-    if (!pending) {
-        pending = new Map();
-        pendingClaudeToolCalls.set(sessionName, pending);
-    }
-    return pending;
-}
-function rememberClaudeToolCall(sessionName, pending) {
-    getPendingClaudeTools(sessionName).set(pending.id, pending);
-}
-function takeClaudeToolCall(sessionName, toolUseId) {
-    if (!toolUseId)
-        return undefined;
-    const pending = pendingClaudeToolCalls.get(sessionName);
-    if (!pending)
-        return undefined;
-    const tool = pending.get(toolUseId);
-    if (tool)
-        pending.delete(toolUseId);
-    if (pending.size === 0)
-        pendingClaudeToolCalls.delete(sessionName);
-    return tool;
-}
-function emitClaudeFileChange(sessionName, batch, eventId, ts) {
-    timelineEmitter.emit(sessionName, TIMELINE_EVENT_FILE_CHANGE, { batch }, {
-        source: 'daemon',
-        confidence: 'high',
-        eventId,
-        ...(ts ? { ts } : {}),
-    });
-}
-function buildClaudeToolEventId(sessionName, toolUseId, phase) {
-    return `cc-tool:${sessionName}:${toolUseId}:${phase}`;
-}
-function isClaudeFileChangeTool(name) {
-    return name === 'Edit' || name === 'MultiEdit' || name === 'Write' || name === 'NotebookEdit';
-}
-/** Patterns for system-injected messages that should not display as user messages. */
-const SYSTEM_INJECT_RE = /<task-notification|<system-reminder|<command-name>|<command-message>|<local-command-|<bash-input>|<bash-stdout>|<bash-stderr>/;
-function emitUserStringContent(sessionName, text, stableId, ts) {
-    if (!text.trim())
-        return;
-    // System-injected messages: don't show as user message, emit working signal instead
-    if (SYSTEM_INJECT_RE.test(text)) {
-        timelineEmitter.emit(sessionName, 'agent.status', {
-            status: 'processing',
-            label: 'Processing system event...',
-        }, { source: 'daemon', confidence: 'high' });
-        return;
-    }
-    timelineEmitter.emit(sessionName, 'user.message', {
-        text,
-    }, { source: 'daemon', confidence: 'high', ...(stableId ? { eventId: stableId('um') } : {}), ...(ts ? { ts } : {}) });
-}
-function emitAssistantStringContent(sessionName, text, stableId, ts) {
-    if (!text.trim())
-        return;
-    timelineEmitter.emit(sessionName, 'assistant.text', {
-        text,
-        streaming: false,
-    }, { source: 'daemon', confidence: 'high', ...(stableId ? { eventId: stableId('at') } : {}), ...(ts ? { ts } : {}) });
-}
-function emitClaudeToolCallBlock(sessionName, block, stableId, ts) {
-    if (!block.name)
-        return;
-    if (block.name === 'AskUserQuestion') {
-        const inp = block.input;
-        timelineEmitter.emit(sessionName, 'ask.question', {
-            toolUseId: block.id,
-            questions: inp?.['questions'] ?? [],
-        }, { source: 'daemon', confidence: 'high', ...(stableId ? { eventId: stableId('aq') } : {}), ...(ts ? { ts } : {}) });
-        return;
-    }
-    const input = block.input;
-    const toolUseId = block.id;
-    const isDeferredFileTool = isClaudeFileChangeTool(block.name) && !!toolUseId;
-    if (toolUseId) {
-        rememberClaudeToolCall(sessionName, {
-            id: toolUseId,
-            name: block.name,
-            input,
-            ...(ts ? { ts } : {}),
-        });
-    }
-    if (isDeferredFileTool)
-        return;
-    const callEventId = toolUseId ? buildClaudeToolEventId(sessionName, toolUseId, 'call') : (stableId ? stableId('tc') : undefined);
-    const summaryInput = extractToolInput(block.name, input);
-    timelineEmitter.emit(sessionName, 'tool.call', {
-        tool: block.name,
-        ...(summaryInput ? { input: summaryInput } : (input ? { input } : {})),
-    }, {
-        source: 'daemon',
-        confidence: 'high',
-        ...(callEventId ? { eventId: callEventId } : {}),
-        ...(ts ? { ts } : {}),
-    });
-}
-function emitClaudeToolResultBlock(sessionName, block, stableId, ts) {
-    const toolUseId = block.tool_use_id;
-    const pending = takeClaudeToolCall(sessionName, toolUseId);
-    const toolUseResult = asRecord(block.toolUseResult);
-    const contentResult = asRecord(block.content);
-    const normalized = pending
-        && !block.is_error
-        ? normalizeClaudeFileChange({
-            toolName: pending.name,
-            toolCallId: pending.id,
-            input: pending.input,
-            toolResult: toolUseResult ?? contentResult ?? undefined,
-        })
-        : null;
-    if (pending && isClaudeFileChangeTool(pending.name)) {
-        const summaryInput = extractToolInput(pending.name, pending.input);
-        timelineEmitter.emit(sessionName, 'tool.call', {
-            tool: pending.name,
-            ...(summaryInput ? { input: summaryInput } : (pending.input ? { input: pending.input } : {})),
-        }, {
-            source: 'daemon',
-            confidence: 'high',
-            eventId: buildClaudeToolEventId(sessionName, pending.id, 'call'),
-            ...(pending.ts ? { ts: pending.ts } : {}),
-            ...(normalized ? { hidden: true } : {}),
-        });
-    }
-    if (normalized && pending) {
-        timelineEmitter.emit(sessionName, 'tool.result', {
-            ...(block.is_error ? { error: String(block.content ?? 'error') } : {}),
-            ...(toolUseResult?.content ? { output: toolUseResult.content } : {}),
-        }, {
-            source: 'daemon',
-            confidence: 'high',
-            eventId: buildClaudeToolEventId(sessionName, pending.id, 'result'),
-            ...(ts ? { ts } : {}),
-            hidden: true,
-        });
-        emitClaudeFileChange(sessionName, normalized, `cc-file-change:${sessionName}:${pending.id}`, ts);
-        return;
-    }
-    const error = block.is_error ? String(block.content ?? 'error') : undefined;
-    const output = !error ? extractToolResultOutput(block) : undefined;
-    timelineEmitter.emit(sessionName, 'tool.result', {
-        ...(error ? { error } : {}),
-        ...(output ? { output } : {}),
-    }, {
-        source: 'daemon',
-        confidence: 'high',
-        ...(toolUseId ? { eventId: buildClaudeToolEventId(sessionName, toolUseId, 'result') } : stableId ? { eventId: stableId('tr') } : {}),
-        ...(ts ? { ts } : {}),
-    });
-}
-/**
- * Parse one JSONL line and emit timeline events.
- * - assistant: emit assistant.text, assistant.thinking, tool.call
- * - user: emit user.message, tool.result
- *
- * lineByteOffset: byte offset of this line in the file — used to generate stable
- * eventIds so the same line always produces the same ID regardless of whether it
- * arrives via real-time streaming or history replay.
- */
-function parseLine(sessionName, line, lineByteOffset) {
-    if (!line.trim())
-        return;
-    let raw;
-    try {
-        raw = JSON.parse(line);
-    }
-    catch {
-        return;
-    }
-    // Extract original event timestamp from JSONL (CC writes ISO timestamp on each entry).
-    const lineTs = raw['timestamp'] ? new Date(raw['timestamp']).getTime() : undefined;
-    const ts = lineTs && isFinite(lineTs) ? lineTs : undefined;
-    // Stable ID generator: same line always gets same eventId across restarts.
-    let blockIdx = 0;
-    const stableId = lineByteOffset !== undefined
-        ? (suffix) => `cc:${sessionName}:${lineByteOffset}:${suffix}:${blockIdx++}`
-        : undefined;
-    // Progress events — transient status for status bar display (no message.content)
-    if (raw['type'] === 'progress') {
-        const data = raw['data'];
-        if (!data)
-            return;
-        const progressType = String(data['type'] ?? '');
-        switch (progressType) {
-            case 'bash_progress': {
-                const elapsed = data['elapsedTimeSeconds'];
-                timelineEmitter.emit(sessionName, 'agent.status', {
-                    status: 'bash_running',
-                    label: `Bash running${elapsed ? ` (${Math.round(elapsed)}s)` : ''}...`,
-                }, { source: 'daemon', confidence: 'high' });
-                break;
-            }
-            case 'agent_progress': {
-                const raw = data['message'];
-                let msg = 'working';
-                if (typeof raw === 'string') {
-                    msg = raw;
-                }
-                else if (raw && typeof raw === 'object') {
-                    const role = raw.type ?? raw.role ?? '';
-                    msg = String(role) || 'working';
-                }
-                timelineEmitter.emit(sessionName, 'agent.status', {
-                    status: 'agent_working',
-                    label: `Sub-agent: ${msg}`,
-                }, { source: 'daemon', confidence: 'high' });
-                break;
-            }
-            case 'mcp_progress': {
-                const toolName = String(data['toolName'] ?? 'tool');
-                const server = String(data['serverName'] ?? '');
-                const mStatus = String(data['status'] ?? 'started');
-                if (mStatus === 'started') {
-                    timelineEmitter.emit(sessionName, 'agent.status', {
-                        status: 'mcp_running',
-                        label: `MCP: ${server ? server + '/' : ''}${toolName}...`,
-                    }, { source: 'daemon', confidence: 'high' });
-                }
-                break;
-            }
-            case 'waiting_for_task': {
-                const desc = String(data['taskDescription'] ?? 'task');
-                timelineEmitter.emit(sessionName, 'agent.status', {
-                    status: 'waiting',
-                    label: `Waiting: ${desc}`,
-                }, { source: 'daemon', confidence: 'high' });
-                break;
-            }
-        }
-        return;
-    }
-    // Result events — end-of-turn summary with total cost
-    if (raw['type'] === 'result') {
-        const costUsd = raw['total_cost_usd'];
-        if (typeof costUsd === 'number' && costUsd > 0) {
-            timelineEmitter.emit(sessionName, 'usage.update', { costUsd }, { source: 'daemon', confidence: 'high' });
-        }
-        return;
-    }
-    // System events — compact_boundary etc. (no message.content)
-    if (raw['type'] === 'system') {
-        const subtype = String(raw['subtype'] ?? '');
-        if (subtype === 'compact_boundary') {
-            timelineEmitter.emit(sessionName, 'agent.status', {
-                status: 'compacting',
-                label: 'Compacting conversation...',
-            }, { source: 'daemon', confidence: 'high' });
-        }
-        return;
-    }
-    const msg = raw['message'];
-    if (!msg)
-        return;
-    const content = msg['content'];
-    if (raw['type'] === 'assistant') {
-        if (typeof content === 'string') {
-            emitAssistantStringContent(sessionName, content, stableId, ts);
-            return;
-        }
-        if (!Array.isArray(content))
-            return;
-        for (const block of content) {
-            if (block.type === 'text' && block.text) {
-                timelineEmitter.emit(sessionName, 'assistant.text', {
-                    text: block.text,
-                    streaming: false,
-                }, { source: 'daemon', confidence: 'high', ...(stableId ? { eventId: stableId('at') } : {}), ...(ts ? { ts } : {}) });
-            }
-            else if (block.type === 'thinking') {
-                timelineEmitter.emit(sessionName, 'assistant.thinking', {
-                    text: block.thinking,
-                }, { source: 'daemon', confidence: 'high', ...(stableId ? { eventId: stableId('th') } : {}), ...(ts ? { ts } : {}) });
-            }
-            else if (block.type === 'tool_use' && block.name) {
-                emitClaudeToolCallBlock(sessionName, block, stableId, ts);
-            }
-            else if (block.type === 'tool_result') {
-                emitClaudeToolResultBlock(sessionName, block, stableId, ts);
-            }
-        }
-        // Emit token usage + model for context bar (transient, no stable ID needed)
-        const usage = msg['usage'];
-        const model = msg['model'];
-        if (usage && typeof usage.input_tokens === 'number') {
-            const presetCtx = watchers.get(sessionName)?.ccSessionId ? getSessionContextWindow(watchers.get(sessionName).ccSessionId) : undefined;
-            timelineEmitter.emit(sessionName, 'usage.update', {
-                inputTokens: usage.input_tokens + (usage.cache_creation_input_tokens ?? 0),
-                cacheTokens: usage.cache_read_input_tokens ?? 0,
-                contextWindow: resolveContextWindow(presetCtx, model),
-                ...(model ? { model } : {}),
-            }, { source: 'daemon', confidence: 'high' });
-        }
-        return;
-    }
-    if (raw['type'] === 'user') {
-        if (typeof content === 'string') {
-            emitUserStringContent(sessionName, content, stableId, ts);
-            return;
-        }
-        if (!Array.isArray(content))
-            return;
-        for (const block of content) {
-            if (block.type === 'text' && block.text?.trim()) {
-                emitUserStringContent(sessionName, block.text, stableId, ts);
-            }
-            else if (block.type === 'tool_result') {
-                emitClaudeToolResultBlock(sessionName, block, stableId, ts);
-            }
-        }
-    }
-}
-/** Extract a truncated summary of tool result content for display. */
-function extractToolResultOutput(block) {
-    const raw = block.content;
-    if (!raw)
-        return undefined;
-    let text;
-    if (typeof raw === 'string') {
-        text = raw;
-    }
-    else if (Array.isArray(raw)) {
-        text = raw.map((b) => b.text ?? '').join('\n');
-    }
-    else {
-        return undefined;
-    }
-    text = text.trim();
-    if (!text)
-        return undefined;
-    return text.length > 200 ? text.slice(0, 197) + '...' : text;
-}
+// ── JSONL parsing ─────────────────────────────────────────────────────────────
+//
+// The heavy parsing (JSON.parse + regex + block interpretation) lives in the
+// pure `jsonl-parse-core` module so it can run either on the main thread or
+// in the `jsonl-parse-worker` thread without diverging. The watcher itself
+// only owns I/O and event dispatch.
+//
+// Strategy:
+//   - Default: drained batches are parsed synchronously on main using
+//     `mainParseCtx`. Code path identical to pre-worker behaviour.
+//   - Opt-in `IM4CODES_JSONL_WORKER=1`: drained batches ship to the worker
+//     pool; crash / timeout automatically falls back to the main-thread
+//     context (same pure parser). Intended for deployments that observe
+//     main-loop pressure from heavy Claude JSONL streams.
+//
+// `emitRecentHistory` (one-shot at session start) always runs on main using a
+// throwaway context, because (a) it's infrequent and (b) we want to filter
+// `usage.update` events and emit the snapshot at the end instead.
+/** Main-thread fallback state (only used when worker disabled or failed). */
+const mainParseCtx = createParseContext();
 const watchers = new Map();
 function watcherControl(sessionName) {
     return {
@@ -630,58 +292,27 @@ export async function emitRecentHistory(sessionName, filePath) {
             const content = msg?.['content'];
             if (!(Array.isArray(content) || typeof content === 'string'))
                 continue;
-            allEntries.push({ lineBytePos, raw });
+            allEntries.push({ lineBytePos, rawLine: line });
         }
-        // Take last HISTORY_LINES entries
+        // Take last HISTORY_LINES entries and replay them through the shared parse
+        // core. A scratch ParseContext keeps history's tool-call correlation state
+        // isolated from the live watcher — no leakage into subsequent drains.
         const recentEntries = allEntries.slice(-HISTORY_LINES);
-        for (const { lineBytePos, raw } of recentEntries) {
-            let blockIdx = 0;
-            const stableId = (suffix) => `cc:${sessionName}:${lineBytePos}:${suffix}:${blockIdx++}`;
-            // Extract original timestamp from JSONL entry (same as parseLine)
-            const lineTs = raw['timestamp'] ? new Date(raw['timestamp']).getTime() : undefined;
-            const ts = lineTs && isFinite(lineTs) ? lineTs : undefined;
-            if (raw['type'] === 'assistant') {
-                const msg = raw['message'];
-                const content = msg?.['content'];
-                if (typeof content === 'string') {
-                    emitAssistantStringContent(sessionName, content, stableId, ts);
-                    continue;
-                }
-                for (const block of content) {
-                    if (block.type === 'text' && block.text) {
-                        timelineEmitter.emit(sessionName, 'assistant.text', {
-                            text: block.text, streaming: false,
-                        }, { source: 'daemon', confidence: 'high', eventId: stableId('at'), ...(ts ? { ts } : {}) });
-                    }
-                    else if (block.type === 'thinking') {
-                        timelineEmitter.emit(sessionName, 'assistant.thinking', {
-                            text: block.thinking,
-                        }, { source: 'daemon', confidence: 'high', eventId: stableId('th'), ...(ts ? { ts } : {}) });
-                    }
-                    else if (block.type === 'tool_use' && block.name) {
-                        emitClaudeToolCallBlock(sessionName, block, stableId, ts);
-                    }
-                    else if (block.type === 'tool_result') {
-                        emitClaudeToolResultBlock(sessionName, block, stableId, ts);
-                    }
-                }
-            }
-            else if (raw['type'] === 'user') {
-                const msg = raw['message'];
-                const content = msg?.['content'];
-                if (typeof content === 'string') {
-                    emitUserStringContent(sessionName, content, stableId, ts);
-                    continue;
-                }
-                for (const block of content) {
-                    if (block.type === 'text' && block.text?.trim()) {
-                        emitUserStringContent(sessionName, block.text, stableId, ts);
-                    }
-                    else if (block.type === 'tool_result') {
-                        emitClaudeToolResultBlock(sessionName, block, stableId, ts);
-                    }
-                }
-            }
+        const historyCtx = createParseContext();
+        const presetContextWindow = watchers.get(sessionName)?.ccSessionId
+            ? getSessionContextWindow(watchers.get(sessionName).ccSessionId)
+            : undefined;
+        const { emits } = parseLinesInCtx(historyCtx, {
+            sessionName,
+            items: recentEntries.map((e) => ({ line: e.rawLine, lineByteOffset: e.lineBytePos })),
+            ...(presetContextWindow !== undefined ? { presetContextWindow } : {}),
+        });
+        // History handles the usage snapshot separately below — drop per-line
+        // usage events so we don't spam the context bar during replay.
+        for (const em of emits) {
+            if (em.type === 'usage.update')
+                continue;
+            timelineEmitter.emit(em.sessionName, em.type, em.payload, em.metadata);
         }
         // Emit the most recent usage snapshot so the context bar populates on load
         if (lastUsagePayload) {
@@ -779,7 +410,10 @@ export function stopWatching(sessionName) {
     unregisterWatcherControl(sessionName);
     releaseFiles(sessionName);
     releaseOwnership(sessionName);
-    pendingClaudeToolCalls.delete(sessionName);
+    // Drop per-session pending tool-call state in both the main-thread fallback
+    // context and the worker (best-effort; worker call is async and unawaited).
+    forgetSessionInCtx(mainParseCtx, sessionName);
+    void jsonlParsePool.forgetSession(sessionName);
 }
 /**
  * Start watching a specific JSONL file (CC sub-sessions with known --session-id path).
@@ -1102,12 +736,38 @@ async function drainNewLines(sessionName, state) {
         // pendingPartialLine bytes were already read in a prior drain, so we subtract them.
         const prevPendingByteLen = Buffer.byteLength(fullChunk.slice(0, fullChunk.length - chunk.length), 'utf8');
         let lineByteOffset = chunkStartOffset - prevPendingByteLen;
+        // Batch complete lines and route to worker (if enabled) or parse on main.
+        const items = [];
         for (const line of lines) {
             if (state.stopped)
                 break;
-            parseLine(sessionName, line, lineByteOffset);
+            items.push({ line, lineByteOffset });
             lineByteOffset += Buffer.byteLength(line, 'utf8') + 1; // +1 for \n
         }
+        if (items.length === 0)
+            return;
+        const presetContextWindow = state.ccSessionId
+            ? getSessionContextWindow(state.ccSessionId)
+            : undefined;
+        const request = {
+            sessionName,
+            items,
+            ...(state.ccSessionId ? { ccSessionId: state.ccSessionId } : {}),
+            ...(presetContextWindow !== undefined ? { presetContextWindow } : {}),
+        };
+        let emits = null;
+        if (isJsonlWorkerEnabled() && jsonlParsePool.isAvailable()) {
+            const result = await jsonlParsePool.parseLines(request);
+            if (result)
+                emits = result.emits;
+        }
+        if (!emits) {
+            // Main-thread fallback: either worker disabled, unavailable, or returned null.
+            emits = parseLinesInCtx(mainParseCtx, request).emits;
+        }
+        for (const em of emits) {
+            timelineEmitter.emit(em.sessionName, em.type, em.payload, em.metadata);
+        }
     }
     catch (err) {
         if (!state.stopped) {