sidekick-shared 0.21.2 → 0.21.3

package/dist/codexQuotaWatcher.js

@@ -93,7 +93,8 @@ class CodexQuotaWatcher {
     running = false;
     constructor(workspacePath, options = {}) {
         this.workspacePath = workspacePath;
-        this.discoveryPollIntervalMs = options.discoveryPollIntervalMs ?? DEFAULT_DISCOVERY_POLL_INTERVAL_MS;
+        this.discoveryPollIntervalMs =
+            options.discoveryPollIntervalMs ?? DEFAULT_DISCOVERY_POLL_INTERVAL_MS;
         this.providerFactory = options.providerFactory ?? (() => new codex_1.CodexProvider());
         this.getActiveAccount = options.getActiveAccount ?? codexProfiles_1.getActiveCodexAccount;
         this.readSnapshot = options.readSnapshot ?? quotaSnapshots_1.readQuotaSnapshot;
@@ -207,8 +208,14 @@ class CodexQuotaWatcher {
                     runtimeProvider: 'codex',
                     providerId: account.id,
                     workspaceId: this.workspaceId,
-                    fiveHour: { utilization: liveQuota.fiveHour.utilization, resetsAt: liveQuota.fiveHour.resetsAt },
-                    sevenDay: { utilization: liveQuota.sevenDay.utilization, resetsAt: liveQuota.sevenDay.resetsAt },
+                    fiveHour: {
+                        utilization: liveQuota.fiveHour.utilization,
+                        resetsAt: liveQuota.fiveHour.resetsAt,
+                    },
+                    sevenDay: {
+                        utilization: liveQuota.sevenDay.utilization,
+                        resetsAt: liveQuota.sevenDay.resetsAt,
+                    },
                     available: liveQuota.available,
                     error: liveQuota.error,
                     source: liveQuota.source,

package/dist/context/composer.js

@@ -29,7 +29,9 @@ async function composeContext(slug, fidelity, provider, workspacePath) {
         try {
             sessionSummaries.push(provider.readSessionStats(sp));
         }
-        catch { /* skip */ }
+        catch {
+            /* skip */
+        }
     }
     // Apply fidelity filtering
     let tasks;
@@ -40,23 +42,23 @@ async function composeContext(slug, fidelity, provider, workspacePath) {
         case 'full':
             tasks = allTasks;
             decisions = allDecisions;
-            notes = allNotes.filter(n => n.status === 'active' || n.status === 'needs_review');
+            notes = allNotes.filter((n) => n.status === 'active' || n.status === 'needs_review');
             if (history) {
                 stats = { tokens: { ...history.allTime.tokens }, cost: history.allTime.totalCost };
             }
             break;
         case 'compact':
-            tasks = allTasks.filter(t => t.status === 'pending');
+            tasks = allTasks.filter((t) => t.status === 'pending');
             decisions = allDecisions.slice(0, 10);
-            notes = allNotes.filter(n => n.status === 'active');
+            notes = allNotes.filter((n) => n.status === 'active');
             if (history) {
                 stats = { tokens: { ...history.allTime.tokens }, cost: history.allTime.totalCost };
             }
             break;
         case 'brief':
-            tasks = allTasks.filter(t => t.status === 'pending').slice(0, 3);
+            tasks = allTasks.filter((t) => t.status === 'pending').slice(0, 3);
             decisions = []; // Count only
-            notes = allNotes.filter(n => n.importance === 'critical');
+            notes = allNotes.filter((n) => n.importance === 'critical');
             stats = null;
             break;
     }

package/dist/context/sessionContext.js

@@ -65,7 +65,7 @@ function buildSessionContextSnapshot(events, options = {}) {
     const allSources = sourceState.sources;
     const limitedSources = limitSources(allSources, options.sourceLimit ?? DEFAULT_CONTEXT_SOURCE_LIMIT);
     const breakdown = buildLayerBreakdown(limitedSources);
-    const layers = breakdown.map(row => row.layer);
+    const layers = breakdown.map((row) => row.layer);
     const sourceTokenTotal = allSources.reduce((sum, source) => sum + source.tokenEstimate, 0);
     const contextTokens = metrics.currentContextSize > 0 ? metrics.currentContextSize : sourceTokenTotal;
     const { pressure, ratio } = calculateSessionContextPressure(contextTokens, contextWindow);
@@ -381,16 +381,16 @@ function limitSources(sources, limit) {
         return [];
     if (sources.length <= limit)
         return [...sources];
-    const pinned = sources.filter(source => source.sourceType === 'system' ||
+    const pinned = sources.filter((source) => source.sourceType === 'system' ||
         source.sourceType === 'runtime' ||
         source.sourceType === 'rate_limit');
     const pinnedLimit = Math.min(pinned.length, Math.max(1, Math.floor(limit / 4)));
     const pinnedKept = pinned.slice(0, pinnedLimit);
-    const pinnedIds = new Set(pinnedKept.map(source => source.id));
-    const remaining = sources.filter(source => !pinnedIds.has(source.id));
+    const pinnedIds = new Set(pinnedKept.map((source) => source.id));
+    const remaining = sources.filter((source) => !pinnedIds.has(source.id));
     const latest = remaining.slice(-(limit - pinnedKept.length));
-    const keepIds = new Set([...pinnedKept, ...latest].map(source => source.id));
-    return sources.filter(source => keepIds.has(source.id));
+    const keepIds = new Set([...pinnedKept, ...latest].map((source) => source.id));
+    return sources.filter((source) => keepIds.has(source.id));
 }
 function latestModel(events) {
     for (let i = events.length - 1; i >= 0; i--) {
@@ -440,7 +440,7 @@ function inferSourceFile(input) {
     }
     const files = input.files;
     if (Array.isArray(files)) {
-        const first = files.find(value => typeof value === 'string' && value.trim());
+        const first = files.find((value) => typeof value === 'string' && value.trim());
         if (typeof first === 'string')
             return first.trim();
     }
@@ -451,7 +451,10 @@ function inferCommand(input) {
     if (typeof command === 'string' && command.trim())
         return command.trim();
     if (Array.isArray(command)) {
-        return command.map(part => String(part)).join(' ').trim() || undefined;
+        return (command
+            .map((part) => String(part))
+            .join(' ')
+            .trim() || undefined);
     }
     return undefined;
 }
@@ -469,7 +472,7 @@ function extractText(content) {
         return content;
     if (Array.isArray(content)) {
         return content
-            .map(block => isRecord(block) ? blockText(block) : '')
+            .map((block) => (isRecord(block) ? blockText(block) : ''))
             .filter(Boolean)
             .join('\n');
     }

package/dist/credentialIO.js

@@ -66,9 +66,7 @@ function getCredentialsFilePath(configDir) {
 function readActiveCredentials(configDir) {
     if (process.platform === 'darwin') {
         try {
-            const raw = (0, child_process_1.execFileSync)('security', [
-                'find-generic-password', '-s', (0, claudeProfiles_1.claudeKeychainService)(configDir), '-w',
-            ], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            const raw = (0, child_process_1.execFileSync)('security', ['find-generic-password', '-s', (0, claudeProfiles_1.claudeKeychainService)(configDir), '-w'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 4000, killSignal: 'SIGKILL' });
             return JSON.parse(raw.trim());
         }
         catch {
@@ -96,11 +94,15 @@ function writeActiveCredentials(credentials, configDir) {
     JSON.parse(json); // validate round-trip
     if (process.platform === 'darwin') {
         (0, child_process_1.execFileSync)('security', [
-            'add-generic-password', '-U',
-            '-s', (0, claudeProfiles_1.claudeKeychainService)(configDir),
-            '-a', process.env.USER || 'user',
-            '-w', json,
-        ], { stdio: ['pipe', 'pipe', 'pipe'] });
+            'add-generic-password',
+            '-U',
+            '-s',
+            (0, claudeProfiles_1.claudeKeychainService)(configDir),
+            '-a',
+            process.env.USER || 'user',
+            '-w',
+            json,
+        ], { stdio: ['pipe', 'pipe', 'pipe'], timeout: 4000, killSignal: 'SIGKILL' });
         return;
     }
     // Linux / WSL / Windows — file-based

package/dist/extractors/sessionAssets.js

@@ -62,7 +62,15 @@ const os = __importStar(require("node:os"));
 const node_path_1 = require("node:path");
 const URL_RE = /(?:https?|file):\/\/[^\s"'<>)\]`\\]+/g;
 const PATH_RE = /(?:~|\.{0,2}\/)?[A-Za-z0-9_@.-]*(?:\/[A-Za-z0-9_@.-]+)+(?::\d+){0,2}|[A-Za-z0-9_@-]+\.[A-Za-z0-9]{1,8}(?::\d+){0,2}/g;
-const SHELL_TAGS = new Set(['sh', 'bash', 'shell', 'zsh', 'console', 'shellscript', 'shell-session']);
+const SHELL_TAGS = new Set([
+    'sh',
+    'bash',
+    'shell',
+    'zsh',
+    'console',
+    'shellscript',
+    'shell-session',
+]);
 exports.DEFAULT_CAPS = {
     command: 60,
     path: 60,

package/dist/extractors/sources/claudeAssets.js

@@ -149,7 +149,13 @@ function accumClaude(filePath, cwd, acc) {
 }
 function readClaudeAssets(cwd, limit = 3) {
     const sessions = claudeSessions(cwd, limit);
-    const acc = { urls: [], paths: [], commands: [], plans: [], hadSession: sessions.length > 0 };
+    const acc = {
+        urls: [],
+        paths: [],
+        commands: [],
+        plans: [],
+        hadSession: sessions.length > 0,
+    };
     for (const session of sessions)
         accumClaude(session, cwd, acc);
     return acc;

package/dist/extractors/sources/codexAssets.js

@@ -99,7 +99,9 @@ function rolloutFiles(limit = 150) {
             if (entry.isDirectory()) {
                 walk(fullPath);
             }
-            else if (entry.isFile() && entry.name.startsWith('rollout-') && entry.name.endsWith('.jsonl')) {
+            else if (entry.isFile() &&
+                entry.name.startsWith('rollout-') &&
+                entry.name.endsWith('.jsonl')) {
                 try {
                     if (seen.has(fullPath))
                         continue;
@@ -117,7 +119,10 @@ function rolloutFiles(limit = 150) {
         if (dirExists(sessionsDir))
             walk(sessionsDir);
     }
-    return entries.sort((a, b) => b.mtime - a.mtime).slice(0, limit).map((entry) => entry.path);
+    return entries
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, limit)
+        .map((entry) => entry.path);
 }
 function codexSessions(cwd, limit = 3) {
     const exactCwd = (0, node_path_1.resolve)(cwd);
@@ -182,7 +187,13 @@ function addExecutedCommandAssets(acc, command, cwd, timestamp, meta) {
 function readCodexAssets(cwd, limit = 3) {
     const exactCwd = (0, node_path_1.resolve)(cwd);
     const files = codexSessions(exactCwd, limit);
-    const acc = { urls: [], paths: [], commands: [], plans: [], hadSession: files.length > 0 };
+    const acc = {
+        urls: [],
+        paths: [],
+        commands: [],
+        plans: [],
+        hadSession: files.length > 0,
+    };
     const skip = (line) => line.includes('"type":"function_call_output"') ||
         line.includes('"type":"reasoning"') ||
         line.includes('"type":"token_count"');

package/dist/extractors/toolCall.js

@@ -37,10 +37,7 @@ function extractToolCalls(event) {
     const timestamp = new Date(event.timestamp);
     const calls = [];
     for (const block of content) {
-        if (block &&
-            typeof block === 'object' &&
-            'type' in block &&
-            block.type === 'tool_use') {
+        if (block && typeof block === 'object' && 'type' in block && block.type === 'tool_use') {
             const toolBlock = block;
             if (toolBlock.name) {
                 calls.push({

package/dist/formatters/eventHighlighter.js

@@ -46,43 +46,163 @@ const HTML_COLORS = {
 };
 function getColors(format) {
     switch (format) {
-        case 'blessed': return BLESSED_COLORS;
-        case 'ansi': return ANSI_COLORS;
-        case 'html': return HTML_COLORS;
+        case 'blessed':
+            return BLESSED_COLORS;
+        case 'ansi':
+            return ANSI_COLORS;
+        case 'html':
+            return HTML_COLORS;
     }
 }
 const ERROR_KEYWORDS = new Set([
-    'error', 'errors', 'err', 'fail', 'failed', 'failure', 'failures',
-    'fatal', 'panic', 'crash', 'crashed', 'exception', 'exceptions',
-    'critical', 'alert', 'abort', 'aborted', 'denied', 'forbidden',
-    'rejected', 'invalid', 'illegal', 'corrupt', 'corrupted',
-    'broken', 'bug', 'segfault', 'timeout', 'timedout', 'timed-out',
-    'deadlock', 'overflow', 'underflow', 'null', 'undefined', 'nan',
-    'unhandled', 'uncaught', 'unreachable', 'missing', 'notfound',
-    'not-found', 'unavailable', 'disconnected', 'dropped',
+    'error',
+    'errors',
+    'err',
+    'fail',
+    'failed',
+    'failure',
+    'failures',
+    'fatal',
+    'panic',
+    'crash',
+    'crashed',
+    'exception',
+    'exceptions',
+    'critical',
+    'alert',
+    'abort',
+    'aborted',
+    'denied',
+    'forbidden',
+    'rejected',
+    'invalid',
+    'illegal',
+    'corrupt',
+    'corrupted',
+    'broken',
+    'bug',
+    'segfault',
+    'timeout',
+    'timedout',
+    'timed-out',
+    'deadlock',
+    'overflow',
+    'underflow',
+    'null',
+    'undefined',
+    'nan',
+    'unhandled',
+    'uncaught',
+    'unreachable',
+    'missing',
+    'notfound',
+    'not-found',
+    'unavailable',
+    'disconnected',
+    'dropped',
 ]);
 const SUCCESS_KEYWORDS = new Set([
-    'success', 'successful', 'succeeded', 'ok', 'done', 'complete',
-    'completed', 'passed', 'pass', 'resolved', 'fixed', 'ready',
-    'active', 'running', 'started', 'created', 'connected',
-    'established', 'accepted', 'approved', 'merged', 'deployed',
-    'installed', 'loaded', 'enabled', 'healthy', 'valid', 'verified',
+    'success',
+    'successful',
+    'succeeded',
+    'ok',
+    'done',
+    'complete',
+    'completed',
+    'passed',
+    'pass',
+    'resolved',
+    'fixed',
+    'ready',
+    'active',
+    'running',
+    'started',
+    'created',
+    'connected',
+    'established',
+    'accepted',
+    'approved',
+    'merged',
+    'deployed',
+    'installed',
+    'loaded',
+    'enabled',
+    'healthy',
+    'valid',
+    'verified',
 ]);
 const WARNING_KEYWORDS = new Set([
-    'warn', 'warning', 'warnings', 'caution', 'deprecated',
-    'slow', 'retry', 'retrying', 'retries', 'pending', 'waiting',
-    'queued', 'stale', 'expired', 'expiring', 'limited',
-    'throttled', 'throttling', 'degraded', 'unstable', 'flaky',
-    'skipped', 'skip', 'ignored', 'unknown', 'unrecognized',
+    'warn',
+    'warning',
+    'warnings',
+    'caution',
+    'deprecated',
+    'slow',
+    'retry',
+    'retrying',
+    'retries',
+    'pending',
+    'waiting',
+    'queued',
+    'stale',
+    'expired',
+    'expiring',
+    'limited',
+    'throttled',
+    'throttling',
+    'degraded',
+    'unstable',
+    'flaky',
+    'skipped',
+    'skip',
+    'ignored',
+    'unknown',
+    'unrecognized',
 ]);
 const ACTION_KEYWORDS = new Set([
-    'read', 'write', 'edit', 'delete', 'create', 'update', 'insert',
-    'remove', 'add', 'modify', 'patch', 'merge', 'push', 'pull',
-    'fetch', 'send', 'receive', 'request', 'response', 'query',
-    'search', 'find', 'list', 'get', 'set', 'put', 'post',
-    'build', 'compile', 'test', 'deploy', 'install', 'run',
-    'execute', 'start', 'stop', 'restart', 'init', 'initialize',
-    'configure', 'spawn', 'call', 'invoke',
+    'read',
+    'write',
+    'edit',
+    'delete',
+    'create',
+    'update',
+    'insert',
+    'remove',
+    'add',
+    'modify',
+    'patch',
+    'merge',
+    'push',
+    'pull',
+    'fetch',
+    'send',
+    'receive',
+    'request',
+    'response',
+    'query',
+    'search',
+    'find',
+    'list',
+    'get',
+    'set',
+    'put',
+    'post',
+    'build',
+    'compile',
+    'test',
+    'deploy',
+    'install',
+    'run',
+    'execute',
+    'start',
+    'stop',
+    'restart',
+    'init',
+    'initialize',
+    'configure',
+    'spawn',
+    'call',
+    'invoke',
 ]);
 const HTTP_METHODS = new Map([
     ['GET', 'green'],

package/dist/formatters/noiseClassifier.js

@@ -18,11 +18,7 @@ exports.shouldMergeWithPrevious = shouldMergeWithPrevious;
 exports.classifyNoise = classifyNoise;
 // ── Hard Noise Detection ──
 /** Hard noise types that should be dropped entirely from display. */
-const HARD_NOISE_EVENT_TYPES = new Set([
-    'file-history-snapshot',
-    'queue-operation',
-    'progress',
-]);
+const HARD_NOISE_EVENT_TYPES = new Set(['file-history-snapshot', 'queue-operation', 'progress']);
 const SYNTHETIC_MODEL_PREFIX = '<synthetic>';
 /**
  * Determines if an event is "hard noise" and should be dropped entirely.
@@ -70,11 +66,7 @@ const COMMAND_CAVEAT_PATTERNS = [
     /IMPORTANT:.*?(?:never|always|must|should)/i,
     /Note:.*?(?:do not|don't|avoid)/i,
 ];
-const INTERRUPTION_MARKERS = [
-    'interrupted by user',
-    'operation cancelled',
-    'aborted',
-];
+const INTERRUPTION_MARKERS = ['interrupted by user', 'operation cancelled', 'aborted'];
 /**
  * Checks for soft noise that can be hidden but not dropped.
  *
@@ -222,5 +214,5 @@ function extractContent(event) {
 function hasToolUseBlocks(content) {
     if (!Array.isArray(content))
         return false;
-    return content.some(b => b.type === 'tool_use');
+    return content.some((b) => b.type === 'tool_use');
 }

package/dist/formatters/sessionDump.js

@@ -51,7 +51,7 @@ function formatSessionText(metrics, options = {}) {
     // Tool stats
     if (metrics.toolStats.length > 0) {
         lines.push('Tools:');
-        const sorted = [...metrics.toolStats].sort((a, b) => (b.successCount + b.failureCount) - (a.successCount + a.failureCount));
+        const sorted = [...metrics.toolStats].sort((a, b) => b.successCount + b.failureCount - (a.successCount + a.failureCount));
         for (const t of sorted) {
             const total = t.successCount + t.failureCount;
             const failStr = t.failureCount > 0 ? ` (${t.failureCount} failed)` : '';
@@ -77,7 +77,7 @@ function formatSessionText(metrics, options = {}) {
     lines.push(hr);
     const filteredEvents = expand
         ? metrics.timeline
-        : metrics.timeline.filter(e => e.noiseLevel !== 'noise');
+        : metrics.timeline.filter((e) => e.noiseLevel !== 'noise');
     if (filteredEvents.length === 0) {
         lines.push('  (no events)');
     }
@@ -150,7 +150,7 @@ function formatSessionMarkdown(metrics, options = {}) {
         lines.push('');
         lines.push(`| Tool | Total | Failed | Avg Duration |`);
         lines.push(`|------|-------|--------|--------------|`);
-        const sorted = [...metrics.toolStats].sort((a, b) => (b.successCount + b.failureCount) - (a.successCount + a.failureCount));
+        const sorted = [...metrics.toolStats].sort((a, b) => b.successCount + b.failureCount - (a.successCount + a.failureCount));
         for (const t of sorted) {
             const total = t.successCount + t.failureCount;
             const avgMs = t.completedCount > 0 ? Math.round(t.totalDuration / t.completedCount) : 0;
@@ -190,7 +190,7 @@ function formatSessionMarkdown(metrics, options = {}) {
     lines.push('');
     const filteredEvents = expand
         ? metrics.timeline
-        : metrics.timeline.filter(e => e.noiseLevel !== 'noise');
+        : metrics.timeline.filter((e) => e.noiseLevel !== 'noise');
     if (filteredEvents.length === 0) {
         lines.push('_(no events)_');
     }
@@ -279,15 +279,24 @@ function formatDuration(start, end) {
 /** Map TimelineEvent.type to a display icon. */
 function getTimelineEventIcon(type) {
     switch (type) {
-        case 'user_prompt': return '\u25b6'; // right-pointing triangle
-        case 'assistant_response': return '\u2726'; // four-pointed star
-        case 'tool_call': return '\u2699'; // gear
-        case 'tool_result': return '\u2190'; // left arrow
-        case 'compaction': return '\u21bb'; // clockwise arrow
-        case 'error': return '\u2718'; // heavy ballot X
-        case 'session_start': return '\u25cf'; // black circle
-        case 'session_end': return '\u25cb'; // white circle
-        default: return ' ';
+        case 'user_prompt':
+            return '\u25b6'; // right-pointing triangle
+        case 'assistant_response':
+            return '\u2726'; // four-pointed star
+        case 'tool_call':
+            return '\u2699'; // gear
+        case 'tool_result':
+            return '\u2190'; // left arrow
+        case 'compaction':
+            return '\u21bb'; // clockwise arrow
+        case 'error':
+            return '\u2718'; // heavy ballot X
+        case 'session_start':
+            return '\u25cf'; // black circle
+        case 'session_end':
+            return '\u25cb'; // white circle
+        default:
+            return ' ';
     }
 }
 function truncateToWidth(text, maxLen) {

package/dist/formatters/toolSummary.js

@@ -217,9 +217,7 @@ function genericFallback(input) {
  */
 function formatToolSummary(toolName, input) {
     // Strip MCP prefixes: "mcp__server__tool" → use "tool" for matching
-    const baseName = toolName.includes('__')
-        ? toolName.split('__').pop() ?? toolName
-        : toolName;
+    const baseName = toolName.includes('__') ? (toolName.split('__').pop() ?? toolName) : toolName;
     const formatter = TOOL_FORMATTERS[toolName] ?? TOOL_FORMATTERS[baseName];
     if (formatter) {
         const result = formatter(input);