sidekick-shared 0.27.3 → 0.27.5

package/dist/sessionPromptSignals.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * What the human-prompt filter leaves out of a session, for consumers that
+ * classify a whole session: the agent's reply to each prompt and timestamped
+ * interaction signals (interrupts, rejected or failed tools, compactions, API
+ * errors, rollbacks). Pure: log records in, results out; no file system access.
+ *
+ * Records reach an extractor after the prompt scanner has seen them, with the
+ * ordinal of the latest human prompt, so replies and signals share the prompt
+ * ordinals of `collectPromptHistory()`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGNAL_TEXT_CHARS = void 0;
+exports.createSessionRecordExtractor = createSessionRecordExtractor;
+/** Error text kept on a signal; tool output can be arbitrarily long. */
+exports.SIGNAL_TEXT_CHARS = 1024;
+const CLAUDE_REJECTED_PREFIX = "The user doesn't want to proceed with this tool use";
+const CLAUDE_REJECTION_REASON = /the user said:\s*([\s\S]*)$/;
+const CLAUDE_INTERRUPT_PREFIX = '[Request interrupted by user';
+const CLAUDE_TOOL_USE_INTERRUPT = '[Request interrupted by user for tool use]';
+function createSessionRecordExtractor(provider, include) {
+    return provider === 'claude-code'
+        ? new ClaudeRecordExtractor(include)
+        : new CodexRecordExtractor(include);
+}
+/** Timestamps, signal bookkeeping, and reply slots shared by both providers. */
+class RecordExtractor {
+    include;
+    firstMs = Infinity;
+    lastMs = -Infinity;
+    firstTimestamp;
+    lastTimestamp;
+    signals = [];
+    replies = new Map();
+    constructor(include) {
+        this.include = include;
+    }
+    observe(record, info) {
+        const timestamp = validTimestamp(record.timestamp);
+        if (timestamp) {
+            const ms = Date.parse(timestamp);
+            if (ms < this.firstMs) {
+                this.firstMs = ms;
+                this.firstTimestamp = timestamp;
+            }
+            if (ms > this.lastMs) {
+                this.lastMs = ms;
+                this.lastTimestamp = timestamp;
+            }
+        }
+        this.accept(record, timestamp, info.ordinal, info.lineOffset);
+    }
+    result() {
+        return {
+            ...(this.firstTimestamp ? { firstTimestamp: this.firstTimestamp } : {}),
+            ...(this.lastTimestamp ? { lastTimestamp: this.lastTimestamp } : {}),
+            signals: [...this.signals],
+            replies: new Map(this.replies),
+        };
+    }
+    signal(kind, timestamp, ordinal, detail = {}) {
+        if (!this.include.signals || !timestamp)
+            return;
+        const signal = { kind, timestamp, afterOrdinal: ordinal };
+        if (detail.tool)
+            signal.tool = detail.tool;
+        if (detail.fullText) {
+            signal.text = detail.fullText;
+        }
+        else if (detail.text?.trim()) {
+            const text = detail.text.trim();
+            if (text.length > exports.SIGNAL_TEXT_CHARS) {
+                signal.text = detachedPrefix(text, exports.SIGNAL_TEXT_CHARS);
+                signal.textTruncated = true;
+            }
+            else {
+                signal.text = text;
+            }
+        }
+        this.signals.push(signal);
+    }
+}
+class ClaudeRecordExtractor extends RecordExtractor {
+    toolNames = new Map();
+    /** The reply being assembled: split records of one message share an id. */
+    reply = null;
+    /**
+     * A rejection without a reason is always followed by a
+     * `[Request interrupted by user for tool use]` record; it is one action.
+     */
+    rejectionAwaitingInterrupt = false;
+    lastOrdinal = -1;
+    accept(record, timestamp, ordinal, lineOffset) {
+        if (record.isSidechain === true)
+            return;
+        if (ordinal !== this.lastOrdinal) {
+            this.lastOrdinal = ordinal;
+            this.rejectionAwaitingInterrupt = false;
+        }
+        if (record.type === 'system') {
+            if (record.subtype === 'compact_boundary')
+                this.signal('compaction', timestamp, ordinal);
+            return;
+        }
+        const message = record.message;
+        if (typeof message !== 'object' || message === null)
+            return;
+        const blocks = contentBlocks(message.content);
+        if (record.type === 'assistant') {
+            this.rejectionAwaitingInterrupt = false;
+            for (const block of blocks) {
+                if (block.type === 'tool_use' && typeof block.id === 'string') {
+                    const name = stringValue(block.name);
+                    if (name)
+                        this.toolNames.set(block.id, name);
+                }
+            }
+            if (record.isApiErrorMessage === true) {
+                this.signal('apiError', timestamp, ordinal, { text: blockText(blocks) });
+                return;
+            }
+            if (message.model === '<synthetic>')
+                return;
+            this.recordReply(blocks, stringValue(message.id) ?? `line:${lineOffset}`, timestamp, ordinal);
+            return;
+        }
+        if (record.type !== 'user')
+            return;
+        for (const block of blocks) {
+            if (block.type === 'text' && typeof block.text === 'string') {
+                const text = block.text.trim();
+                if (!text.startsWith(CLAUDE_INTERRUPT_PREFIX))
+                    continue;
+                const paired = text.startsWith(CLAUDE_TOOL_USE_INTERRUPT) && this.rejectionAwaitingInterrupt;
+                this.rejectionAwaitingInterrupt = false;
+                if (!paired)
+                    this.signal('interrupt', timestamp, ordinal);
+            }
+            else if (block.type === 'tool_result' && block.is_error === true) {
+                const text = toolResultText(block.content);
+                const tool = typeof block.tool_use_id === 'string' ? this.toolNames.get(block.tool_use_id) : undefined;
+                if (text.startsWith(CLAUDE_REJECTED_PREFIX)) {
+                    const reason = text.match(CLAUDE_REJECTION_REASON)?.[1].trim();
+                    this.signal('toolRejected', timestamp, ordinal, { tool, fullText: reason || undefined });
+                    this.rejectionAwaitingInterrupt = !reason;
+                }
+                else {
+                    this.signal('toolError', timestamp, ordinal, { tool, text });
+                }
+            }
+        }
+    }
+    recordReply(blocks, id, timestamp, ordinal) {
+        if (!this.include.replies || ordinal < 0 || !timestamp)
+            return;
+        const text = blockText(blocks);
+        if (!text.trim())
+            return;
+        const current = this.reply;
+        if (current && current.ordinal === ordinal && current.id === id) {
+            current.parts.push(text);
+        }
+        else {
+            this.reply = { ordinal, id, parts: [text], timestamp };
+        }
+        const reply = this.reply;
+        this.replies.set(ordinal, { text: reply.parts.join('\n'), timestamp: reply.timestamp });
+    }
+}
+class CodexRecordExtractor extends RecordExtractor {
+    /** Ordinals whose reply came from `task_complete`, which later fallbacks do not replace. */
+    finalReplies = new Set();
+    accept(record, timestamp, ordinal) {
+        // Every compaction writes one top-level `compacted` record; the matching
+        // event or item exists only in some Codex versions, so it is not counted.
+        if (record.type === 'compacted') {
+            this.signal('compaction', timestamp, ordinal);
+            return;
+        }
+        const payload = record.payload;
+        if (typeof payload !== 'object' || payload === null)
+            return;
+        if (record.type === 'response_item') {
+            if (payload.type === 'message' && payload.role === 'assistant') {
+                this.fallbackReply(blockText(contentBlocks(payload.content)), timestamp, ordinal);
+            }
+            return;
+        }
+        if (record.type !== 'event_msg')
+            return;
+        switch (payload.type) {
+            case 'turn_aborted':
+                this.signal('interrupt', timestamp, ordinal);
+                break;
+            case 'thread_rolled_back':
+                this.signal('rollback', timestamp, ordinal);
+                break;
+            case 'task_complete': {
+                const last = stringValue(payload.last_agent_message);
+                if (last?.trim() && this.include.replies && ordinal >= 0 && timestamp) {
+                    this.replies.set(ordinal, { text: last, timestamp });
+                    this.finalReplies.add(ordinal);
+                }
+                if (payload.error !== undefined && payload.error !== null) {
+                    this.signal('apiError', timestamp, ordinal, { text: errorText(payload.error) });
+                }
+                break;
+            }
+            case 'error':
+                this.signal('apiError', timestamp, ordinal, { text: errorText(payload) });
+                break;
+            case 'agent_message':
+                this.fallbackReply(stringValue(payload.message) ?? '', timestamp, ordinal);
+                break;
+            case 'exec_command_end':
+                if (payload.status === 'failed' || nonZero(payload.exit_code)) {
+                    this.signal('toolError', timestamp, ordinal, {
+                        tool: 'exec_command',
+                        text: commandText(payload),
+                    });
+                }
+                break;
+            case 'patch_apply_end':
+                if (payload.success === false) {
+                    this.signal('toolError', timestamp, ordinal, {
+                        tool: 'apply_patch',
+                        text: stringValue(payload.stderr) || stringValue(payload.stdout),
+                    });
+                }
+                break;
+            case 'mcp_tool_call_end': {
+                const invocation = payload.invocation;
+                const failure = mcpFailure(payload.result);
+                if (failure !== null) {
+                    this.signal('toolError', timestamp, ordinal, {
+                        tool: invocation ? stringValue(invocation.tool) : undefined,
+                        text: failure,
+                    });
+                }
+                break;
+            }
+            case 'item_completed':
+                this.acceptItem(payload.item, timestamp, ordinal);
+                break;
+        }
+    }
+    acceptItem(item, timestamp, ordinal) {
+        if (typeof item !== 'object' || item === null)
+            return;
+        const row = item;
+        const failed = row.status === 'failed';
+        switch (row.type) {
+            case 'AgentMessage':
+                this.fallbackReply(blockText(contentBlocks(row.content)), timestamp, ordinal);
+                break;
+            case 'CommandExecution':
+                if (failed) {
+                    this.signal('toolError', timestamp, ordinal, {
+                        tool: 'exec_command',
+                        text: commandText(row),
+                    });
+                }
+                break;
+            case 'FileChange':
+                if (failed) {
+                    this.signal('toolError', timestamp, ordinal, {
+                        tool: 'apply_patch',
+                        text: stringValue(row.stderr) || stringValue(row.stdout),
+                    });
+                }
+                break;
+            case 'McpToolCall':
+                if (failed) {
+                    this.signal('toolError', timestamp, ordinal, {
+                        tool: stringValue(row.tool),
+                        text: row.error !== undefined && row.error !== null
+                            ? errorText(row.error)
+                            : (mcpFailure(row.result) ?? undefined),
+                    });
+                }
+                break;
+        }
+    }
+    /** The latest agent text of the turn, until `task_complete` settles it. */
+    fallbackReply(text, timestamp, ordinal) {
+        if (!this.include.replies || ordinal < 0 || !timestamp || !text.trim())
+            return;
+        if (this.finalReplies.has(ordinal))
+            return;
+        this.replies.set(ordinal, { text, timestamp });
+    }
+}
+/**
+ * The first `chars` UTF-16 units of `text` as a new string. A plain slice can
+ * keep the whole source string alive (V8 sliced strings), which for a tool's
+ * output may be megabytes per signal. A surrogate pair is never split.
+ */
+function detachedPrefix(text, chars) {
+    const end = /[\uD800-\uDBFF]/.test(text.charAt(chars - 1)) ? chars - 1 : chars;
+    return Buffer.from(text.slice(0, end), 'utf8').toString('utf8');
+}
+function validTimestamp(value) {
+    return typeof value === 'string' && !Number.isNaN(Date.parse(value)) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function contentBlocks(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => typeof block === 'object' && block !== null);
+}
+/** Text of text-like blocks: Claude `text`, Codex `output_text`, Codex item `Text`. */
+function blockText(blocks) {
+    return blocks
+        .filter((block) => (block.type === 'text' || block.type === 'output_text' || block.type === 'Text') &&
+        typeof block.text === 'string')
+        .map((block) => block.text)
+        .join('\n');
+}
+function toolResultText(content) {
+    return blockText(contentBlocks(content)).trim();
+}
+function nonZero(value) {
+    return typeof value === 'number' && value !== 0;
+}
+/** A failed command as `$ <command>` plus its output. */
+function commandText(row) {
+    const command = Array.isArray(row.command)
+        ? row.command.filter((part) => typeof part === 'string').at(-1)
+        : stringValue(row.command);
+    const output = stringValue(row.aggregated_output) ?? stringValue(row.stderr) ?? stringValue(row.stdout) ?? '';
+    return command ? `$ ${command}\n${output}` : output;
+}
+function errorText(error) {
+    if (typeof error === 'string')
+        return error;
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    return stringValue(error.message);
+}
+/** The failure text of an MCP call result, or null when it succeeded. */
+function mcpFailure(result) {
+    if (typeof result !== 'object' || result === null)
+        return null;
+    const row = result;
+    if ('Err' in row)
+        return typeof row.Err === 'string' ? row.Err : (errorText(row.Err) ?? '');
+    const ok = (row.Ok ?? row);
+    if (typeof ok !== 'object' || ok === null || ok.isError !== true)
+        return null;
+    return blockText(contentBlocks(ok.content));
+}

package/dist/usage/usageEvents.d.ts

@@ -78,6 +78,13 @@ export interface CollectUsageEventsOptions {
     /** Skip the on-disk cache entirely. */
     noCache?: boolean;
     onDiagnostic?: (diagnostic: SessionProviderDiagnostic) => void;
+    /**
+     * Stops the collection before listing and between sessions; the promise
+     * rejects with the signal's reason (an `AbortError` by default). Sessions
+     * read before the abort keep their cache entries; no partial session is
+     * cached.
+     */
+    signal?: AbortSignal;
 }
 export interface CollectUsageEventsResult {
     /** Events within the window, oldest first. */

package/dist/usage/usageEvents.js

@@ -290,12 +290,15 @@ async function collectUsageEvents(options) {
     const untilMs = toMs(options.until, 'until');
     const cacheDir = options.cacheDir ?? getUsageCacheDir();
     const useCache = !options.noCache;
+    const signal = options.signal;
+    signal?.throwIfAborted();
     const listed = await (0, sessionPreviews_1.listSessionPreviewsAsync)(options.providers, {
         since: options.since,
         workspacePath: options.workspacePath,
         limit: Number.MAX_SAFE_INTEGER,
         concurrency: options.concurrency,
     });
+    signal?.throwIfAborted();
     const diagnostics = [...listed.diagnostics];
     for (const diagnostic of listed.diagnostics)
         options.onDiagnostic?.(diagnostic);
@@ -306,6 +309,7 @@ async function collectUsageEvents(options) {
     let cacheMisses = 0;
     let wroteCache = false;
     for (const preview of listed.previews) {
+        signal?.throwIfAborted();
         const provider = providerById.get(preview.provider);
         if (!provider)
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.27.3",
+  "version": "0.27.5",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "keywords": [
     "claude-code",