sidekick-shared 0.27.5 → 0.28.0

package/dist/esm/watchers/jsonlWatcher.js

@@ -0,0 +1,435 @@
+/**
+ * JSONL session watcher for Claude Code and Codex.
+ * Uses byte-offset tracking + fs.watch with debounce + catch-up polling.
+ */
+import { createJsonlTail } from './jsonlTail';
+import { normalizeCodexToolName, resolveCodexCallUsage } from '../parsers/codexParser';
+import { formatToolSummary } from '../formatters/toolSummary';
+import { ClaudeUsageDeduper, normalizeClaudeUsage } from '../usage/claudeUsageDedupe';
+// ── Normalizers ──
+/**
+ * Split lines of one Claude response repeat its usage; run the raw usage
+ * through the shared deduper so each response is counted once (last copy wins).
+ */
+function dedupedClaudeUsage(raw, deduper) {
+    if (!raw.message?.usage)
+        return { usage: undefined, usageKind: undefined };
+    const event = deduper.apply(normalizeClaudeUsage({
+        type: 'assistant',
+        timestamp: raw.timestamp || '',
+        message: raw.message,
+    }));
+    return { usage: event.message?.usage, usageKind: event.message?.usageKind };
+}
+function normalizeClaudeCodeEvent(raw, deduper) {
+    const events = [];
+    const ts = raw.timestamp || new Date().toISOString();
+    const permissionMode = raw.permissionMode;
+    const { usage, usageKind } = raw.type === 'assistant'
+        ? dedupedClaudeUsage(raw, deduper)
+        : { usage: undefined, usageKind: undefined };
+    const tokens = usage
+        ? { input: usage.input_tokens || 0, output: usage.output_tokens || 0 }
+        : undefined;
+    const cacheTokens = usage && (usage.cache_read_input_tokens || usage.cache_creation_input_tokens)
+        ? { read: usage.cache_read_input_tokens || 0, write: usage.cache_creation_input_tokens || 0 }
+        : undefined;
+    const cost = usage?.reported_cost;
+    const model = raw.message?.model;
+    if (raw.type === 'user') {
+        const content = raw.message?.content;
+        // Extract tool_result blocks (these carry TaskCreate results, etc.)
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+                    const resultText = typeof block.content === 'string' ? truncate(block.content, 120) : '';
+                    events.push({
+                        providerId: 'claude-code',
+                        type: 'tool_result',
+                        timestamp: ts,
+                        summary: resultText || '(tool result)',
+                        raw: block,
+                    });
+                }
+            }
+        }
+        const text = extractTextContent(content);
+        if (text || events.length === 0) {
+            events.push({
+                providerId: 'claude-code',
+                type: 'user',
+                timestamp: ts,
+                summary: text || '(user message)',
+                model,
+                raw,
+            });
+        }
+    }
+    else if (raw.type === 'assistant') {
+        const content = raw.message?.content;
+        // Extract tool_use blocks first
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'tool_use' && typeof block.name === 'string') {
+                    const input = block.input
+                        ? summarizeToolInput(block.name, block.input)
+                        : '';
+                    events.push({
+                        providerId: 'claude-code',
+                        type: 'tool_use',
+                        timestamp: ts,
+                        summary: input ? `${block.name} ${input}` : block.name,
+                        toolName: block.name,
+                        toolInput: input,
+                        model,
+                        raw: block,
+                    });
+                }
+            }
+        }
+        // Emit the assistant text (if any)
+        const text = extractTextContent(content);
+        if (text || events.length === 0) {
+            events.push({
+                providerId: 'claude-code',
+                type: 'assistant',
+                timestamp: ts,
+                summary: text || '(thinking...)',
+                tokens,
+                cacheTokens,
+                ...(usageKind ? { usageKind } : {}),
+                cost,
+                model,
+                raw,
+            });
+        }
+        else if (tokens) {
+            // Attach tokens to the last tool_use event if no separate text
+            const last = events[events.length - 1];
+            last.tokens = tokens;
+            last.cacheTokens = cacheTokens;
+            if (usageKind)
+                last.usageKind = usageKind;
+            last.cost = cost;
+        }
+    }
+    else if (raw.type === 'summary') {
+        events.push({
+            providerId: 'claude-code',
+            type: 'summary',
+            timestamp: ts,
+            summary: 'Context compacted',
+            raw,
+        });
+    }
+    else {
+        // system / result events
+        if (raw.type === 'result') {
+            events.push({
+                providerId: 'claude-code',
+                type: 'system',
+                timestamp: ts,
+                summary: 'Session ended',
+                raw,
+            });
+        }
+    }
+    // Propagate permission mode to all generated events
+    if (permissionMode) {
+        for (const e of events) {
+            e.permissionMode = permissionMode;
+        }
+    }
+    return events;
+}
+// normalizeCodexEvent is now a method on JsonlSessionWatcher for plan mode state tracking
+// ── Helpers ──
+function extractTextContent(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return truncate(content, 200);
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block.type === 'text' && typeof block.text === 'string') {
+                return truncate(block.text, 200);
+            }
+        }
+    }
+    return '';
+}
+function extractPayloadContent(payload) {
+    const content = payload.content;
+    if (typeof content === 'string')
+        return truncate(content, 200);
+    if (Array.isArray(content)) {
+        for (const part of content) {
+            if (typeof part.text === 'string')
+                return truncate(part.text, 200);
+        }
+    }
+    return '';
+}
+function summarizeToolInput(toolName, input) {
+    return formatToolSummary(toolName, input);
+}
+function extractRateLimits(rl) {
+    const primary = rl.primary;
+    const secondary = rl.secondary;
+    if (!primary && !secondary)
+        return undefined;
+    return {
+        primary: primary
+            ? {
+                usedPercent: primary.used_percent || 0,
+                windowMinutes: primary.window_minutes || 0,
+                resetsAt: primary.resets_at || 0,
+            }
+            : undefined,
+        secondary: secondary
+            ? {
+                usedPercent: secondary.used_percent || 0,
+                windowMinutes: secondary.window_minutes || 0,
+                resetsAt: secondary.resets_at || 0,
+            }
+            : undefined,
+    };
+}
+function truncate(text, maxLen) {
+    const clean = text.replace(/\s+/g, ' ').trim();
+    return clean.length > maxLen ? clean.substring(0, maxLen - 3) + '...' : clean;
+}
+// ── Watcher ──
+export class JsonlSessionWatcher {
+    providerId;
+    sessionPath;
+    callbacks;
+    tail;
+    startOffset;
+    codexInPlanMode = false;
+    claudeUsageDeduper = new ClaudeUsageDeduper();
+    /** Last Codex cumulative usage seen; repeated `token_count` events carry the same value. */
+    codexPrevTotal;
+    constructor(providerId, sessionPath, callbacks) {
+        this.providerId = providerId;
+        this.sessionPath = sessionPath;
+        this.callbacks = callbacks;
+    }
+    get isActive() {
+        return this.tail?.isActive ?? false;
+    }
+    /** Seek to a committed byte offset before starting replay. */
+    seekTo(position) {
+        this.startOffset = Math.max(0, position);
+        this.tail?.seekTo(this.startOffset);
+    }
+    /** Position after the last complete JSONL line. */
+    getPosition() {
+        return this.tail?.getOffset() ?? this.startOffset ?? 0;
+    }
+    start(replay) {
+        if (this.isActive)
+            return;
+        this.tail = createJsonlTail({
+            path: this.sessionPath,
+            startOffset: replay ? this.getPosition() : undefined,
+            startAtEnd: !replay,
+            onEvent: (event) => this.handleRawEvent(event),
+            onBatchComplete: () => this.callbacks.onBatchComplete?.(),
+            onError: (error) => this.callbacks.onError?.(error),
+            // The file starts over, so per-file state from the old content must go too.
+            onReset: () => {
+                this.codexInPlanMode = false;
+                this.claudeUsageDeduper.reset();
+                this.codexPrevTotal = undefined;
+                this.callbacks.onReset?.();
+            },
+        });
+        this.tail.start();
+    }
+    stop() {
+        this.tail?.stop();
+        this.codexInPlanMode = false;
+        this.claudeUsageDeduper.reset();
+        this.codexPrevTotal = undefined;
+    }
+    handleRawEvent(event) {
+        // For codex, raw events don't match RawSessionEvent shape exactly, but
+        // JsonlParser parses any JSON object. Cast to Record for codex normalizer.
+        const followEvents = this.providerId === 'codex'
+            ? this.normalizeCodexEvent(event)
+            : normalizeClaudeCodeEvent(event, this.claudeUsageDeduper);
+        for (const fe of followEvents) {
+            this.callbacks.onEvent(fe);
+        }
+    }
+    /** One call's usage from a token_count `info`, skipping duplicate events. */
+    codexCallUsage(info) {
+        const resolved = resolveCodexCallUsage(info, this.codexPrevTotal ?? null);
+        this.codexPrevTotal = resolved.total ?? undefined;
+        return resolved.usage;
+    }
+    normalizeCodexEvent(raw) {
+        const events = [];
+        const ts = raw.timestamp || new Date().toISOString();
+        const type = raw.type;
+        if (type === 'session_meta') {
+            events.push({
+                providerId: 'codex',
+                type: 'system',
+                timestamp: ts,
+                summary: `Session started in ${raw.payload?.cwd || '?'}`,
+                raw,
+            });
+        }
+        else if (type === 'turn_context') {
+            const payload = raw.payload;
+            if (payload?.model) {
+                events.push({
+                    providerId: 'codex',
+                    type: 'system',
+                    timestamp: ts,
+                    summary: `Model: ${payload.model}`,
+                    model: payload.model,
+                    raw,
+                });
+            }
+        }
+        else if (type === 'response_item') {
+            const p = raw.payload;
+            if (!p)
+                return events;
+            if (p.role === 'user') {
+                const text = extractPayloadContent(p);
+                events.push({
+                    providerId: 'codex',
+                    type: 'user',
+                    timestamp: ts,
+                    summary: text || '(user message)',
+                    raw,
+                });
+            }
+            else if (p.role === 'assistant' || p.type === 'message') {
+                const text = extractPayloadContent(p);
+                events.push({
+                    providerId: 'codex',
+                    type: 'assistant',
+                    timestamp: ts,
+                    summary: text || '(thinking...)',
+                    raw,
+                });
+            }
+            else if (p.type === 'function_call' || p.type === 'custom_tool_call') {
+                const rawName = p.name || 'unknown';
+                const name = normalizeCodexToolName(rawName);
+                let parsedArgs = {};
+                try {
+                    parsedArgs = JSON.parse(p.arguments);
+                }
+                catch {
+                    /* keep empty */
+                }
+                const args = typeof p.arguments === 'string' ? truncate(p.arguments, 80) : '';
+                events.push({
+                    providerId: 'codex',
+                    type: 'tool_use',
+                    timestamp: ts,
+                    summary: args ? `${name} ${args}` : name,
+                    toolName: name,
+                    toolInput: args,
+                    raw: { input: parsedArgs },
+                });
+            }
+            else if (p.type === 'local_shell_call') {
+                const cmd = truncate(JSON.stringify(p.command ?? p.arguments ?? ''), 80);
+                events.push({
+                    providerId: 'codex',
+                    type: 'tool_use',
+                    timestamp: ts,
+                    summary: `Bash ${cmd}`,
+                    toolName: 'Bash',
+                    toolInput: cmd,
+                    raw,
+                });
+            }
+            else if (p.type === 'function_call_output') {
+                events.push({
+                    providerId: 'codex',
+                    type: 'tool_result',
+                    timestamp: ts,
+                    summary: truncate(String(p.output ?? ''), 120),
+                    raw,
+                });
+            }
+        }
+        else if (type === 'event_msg') {
+            const payload = raw.payload;
+            const evtType = payload?.type;
+            if (evtType === 'token_count') {
+                const info = payload?.info;
+                const usage = this.codexCallUsage(info);
+                const rl = payload?.rate_limits;
+                const rateLimits = rl ? extractRateLimits(rl) : undefined;
+                if (usage || rateLimits) {
+                    events.push({
+                        providerId: 'codex',
+                        type: 'system',
+                        timestamp: ts,
+                        summary: usage
+                            ? `Tokens: ${usage.input_tokens ?? 0} in / ${usage.output_tokens ?? 0} out`
+                            : 'Rate limits updated',
+                        // Codex input includes cached input; FollowEvent buckets are disjoint.
+                        tokens: usage
+                            ? {
+                                input: Math.max(0, (usage.input_tokens || 0) - (usage.cached_input_tokens || 0)),
+                                output: usage.output_tokens || 0,
+                            }
+                            : undefined,
+                        cacheTokens: usage?.cached_input_tokens
+                            ? { read: usage.cached_input_tokens, write: 0 }
+                            : undefined,
+                        rateLimits,
+                        raw,
+                    });
+                }
+            }
+            else if (evtType === 'task_started') {
+                const collaboration = payload?.collaboration_mode_kind;
+                if (collaboration === 'plan' && !this.codexInPlanMode) {
+                    this.codexInPlanMode = true;
+                    events.push({
+                        providerId: 'codex',
+                        type: 'tool_use',
+                        timestamp: ts,
+                        summary: 'EnterPlanMode',
+                        toolName: 'EnterPlanMode',
+                        raw: { input: { source: 'codex_task_started' } },
+                    });
+                }
+            }
+            else if (evtType === 'task_complete') {
+                if (this.codexInPlanMode) {
+                    this.codexInPlanMode = false;
+                    events.push({
+                        providerId: 'codex',
+                        type: 'tool_use',
+                        timestamp: ts,
+                        summary: 'ExitPlanMode',
+                        toolName: 'ExitPlanMode',
+                        raw: { input: { source: 'codex_task_complete' } },
+                    });
+                }
+            }
+        }
+        else if (type === 'compacted') {
+            events.push({
+                providerId: 'codex',
+                type: 'summary',
+                timestamp: ts,
+                summary: 'Context compacted',
+                raw,
+            });
+        }
+        return events;
+    }
+}

package/dist/esm/watchers/providerReaderWatcher.js

@@ -0,0 +1,118 @@
+/**
+ * Session watcher backed by a provider SessionReader.
+ *
+ * This keeps live/replay FollowEvent consumers on the same canonical parser
+ * path used by provider-aware VS Code monitoring.
+ */
+import * as fs from 'fs';
+import { toFollowEvents } from './eventBridge';
+const DEBOUNCE_MS = 100;
+const CATCHUP_INTERVAL_MS = 30_000;
+export class ProviderReaderSessionWatcher {
+    provider;
+    sessionPath;
+    callbacks;
+    _isActive = false;
+    fsWatcher = null;
+    catchupTimer = null;
+    debounceTimer = null;
+    reader;
+    constructor(provider, sessionPath, callbacks) {
+        this.provider = provider;
+        this.sessionPath = sessionPath;
+        this.callbacks = callbacks;
+        this.reader = provider.createReader(sessionPath);
+    }
+    get isActive() {
+        return this._isActive;
+    }
+    seekTo(position) {
+        this.reader.seekTo(position);
+    }
+    getPosition() {
+        return this.reader.getPosition();
+    }
+    start(replay) {
+        if (this._isActive)
+            return;
+        this._isActive = true;
+        if (!replay) {
+            this.seekToEnd();
+        }
+        else {
+            this.readNewEvents();
+        }
+        try {
+            this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
+                this.debouncedRead();
+            });
+            this.fsWatcher.on('error', (error) => {
+                this.fsWatcher?.close();
+                this.fsWatcher = null;
+                this.callbacks.onError?.(error);
+            });
+        }
+        catch {
+            // fs.watch may be unavailable; polling still catches up.
+        }
+        this.catchupTimer = setInterval(() => {
+            if (this._isActive)
+                this.readNewEvents();
+        }, CATCHUP_INTERVAL_MS);
+    }
+    stop() {
+        if (!this._isActive)
+            return;
+        this._isActive = false;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.fsWatcher) {
+            this.fsWatcher.close();
+            this.fsWatcher = null;
+        }
+        if (this.catchupTimer) {
+            clearInterval(this.catchupTimer);
+            this.catchupTimer = null;
+        }
+        // Keep unfinished input buffered so a later start can resume losslessly.
+    }
+    seekToEnd() {
+        try {
+            // Consume existing complete records to retain parser context and any
+            // unfinished line, without emitting historical events.
+            this.reader.readNew();
+        }
+        catch {
+            this.reader.reset();
+        }
+    }
+    debouncedRead() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.readNewEvents();
+        }, DEBOUNCE_MS);
+    }
+    readNewEvents() {
+        if (!this._isActive)
+            return;
+        try {
+            if (this.reader.wasTruncated()) {
+                this.reader.reset();
+                this.callbacks.onReset?.();
+            }
+            const events = this.reader.readNew();
+            for (const event of events) {
+                for (const followEvent of toFollowEvents(event, this.provider.id)) {
+                    this.callbacks.onEvent(followEvent);
+                }
+            }
+            this.callbacks.onBatchComplete?.();
+        }
+        catch (err) {
+            this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+}