sidekick-shared 0.24.4 → 0.25.0

package/dist/parsers/codexHistory.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Reader for Codex's append-only `~/.codex/history.jsonl` (Node-only).
+ *
+ * Each line is `{"session_id","ts","text"}` — one entry per user prompt. The
+ * file grows without bound, so this reader takes a bounded tail instead of the
+ * whole file, drops the leading partial line, and parses tolerantly. Pair an
+ * entry with {@link findCodexRolloutFile} (providers/codex) to jump from a
+ * history row to its full rollout transcript.
+ *
+ * @module codexHistory
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCodexHistory = readCodexHistory;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const codexProfiles_1 = require("../codexProfiles");
+const DEFAULT_LIMIT = 100;
+const DEFAULT_TAIL_BYTES = 512 * 1024;
+/**
+ * Returns the newest history entries, newest first. A missing or unreadable
+ * file yields `[]`; malformed lines are skipped. Never throws.
+ */
+function readCodexHistory(options = {}) {
+    const limit = Math.max(0, options.limit ?? DEFAULT_LIMIT);
+    if (limit === 0)
+        return [];
+    const maxTailBytes = Math.max(1, options.maxTailBytes ?? Math.max(DEFAULT_TAIL_BYTES, limit * 4096));
+    const historyPath = path.join(options.codexHome ?? (0, codexProfiles_1.getSystemCodexHome)(), 'history.jsonl');
+    let descriptor;
+    try {
+        descriptor = fs.openSync(historyPath, 'r');
+    }
+    catch {
+        return [];
+    }
+    try {
+        const size = fs.fstatSync(descriptor).size;
+        const readBytes = Math.min(size, maxTailBytes);
+        const buffer = Buffer.alloc(readBytes);
+        fs.readSync(descriptor, buffer, 0, readBytes, size - readBytes);
+        let content = buffer.toString('utf8');
+        if (readBytes < size) {
+            // The tail almost certainly starts mid-line; a multibyte character
+            // straddling the boundary decodes as replacement garbage inside that
+            // same partial line, so dropping through the first newline handles both.
+            const firstNewline = content.indexOf('\n');
+            content = firstNewline === -1 ? '' : content.slice(firstNewline + 1);
+        }
+        const entries = [];
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (typeof parsed.session_id !== 'string' ||
+                typeof parsed.ts !== 'number' ||
+                // JSON.parse('1e400') yields Infinity, which would later RangeError
+                // out of Date serialization in consumers.
+                !Number.isFinite(parsed.ts) ||
+                typeof parsed.text !== 'string') {
+                continue;
+            }
+            entries.push({
+                sessionId: parsed.session_id,
+                ts: parsed.ts,
+                tsMs: parsed.ts * 1000,
+                text: parsed.text,
+            });
+        }
+        // The file is append-only, so on-disk order is oldest first.
+        entries.reverse();
+        return entries.slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            fs.closeSync(descriptor);
+        }
+        catch {
+            // Already closed or invalid; nothing to release.
+        }
+    }
+}

package/dist/parsers/mcpToolName.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Claude Code exposes MCP tools under composite identifiers of the form
+ * `mcp__<server>__<tool>`. Splitting them correctly is subtle enough that
+ * consumers keep re-implementing it by hand (usually with a plain
+ * `split('__')`, which mangles server names containing single underscores).
+ * This module is the canonical splitter. Browser-safe: no Node imports.
+ *
+ * @module mcpToolName
+ */
+export interface McpToolNameParts {
+    serverName: string;
+    toolName: string;
+}
+/**
+ * Splits a Claude Code MCP tool identifier `mcp__<server>__<tool>` into parts.
+ *
+ * The server name ends at the first double underscore after the prefix, so
+ * single underscores stay inside it (`mcp__plugin_context7_context7__query-docs`
+ * → server `plugin_context7_context7`) and the tool keeps any further double
+ * underscores (`mcp__a__b__c` → tool `b__c`).
+ *
+ * Returns `null` for anything that is not a well-formed MCP tool id: a
+ * non-`mcp__` name, a missing or empty server or tool part, or a
+ * case-mismatched prefix. No trimming is applied.
+ */
+export declare function parseMcpToolName(name: string): McpToolNameParts | null;

package/dist/parsers/mcpToolName.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Claude Code exposes MCP tools under composite identifiers of the form
+ * `mcp__<server>__<tool>`. Splitting them correctly is subtle enough that
+ * consumers keep re-implementing it by hand (usually with a plain
+ * `split('__')`, which mangles server names containing single underscores).
+ * This module is the canonical splitter. Browser-safe: no Node imports.
+ *
+ * @module mcpToolName
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMcpToolName = parseMcpToolName;
+const MCP_TOOL_NAME_PATTERN = /^mcp__([^_]+(?:_[^_]+)*)__(.+)$/;
+/**
+ * Splits a Claude Code MCP tool identifier `mcp__<server>__<tool>` into parts.
+ *
+ * The server name ends at the first double underscore after the prefix, so
+ * single underscores stay inside it (`mcp__plugin_context7_context7__query-docs`
+ * → server `plugin_context7_context7`) and the tool keeps any further double
+ * underscores (`mcp__a__b__c` → tool `b__c`).
+ *
+ * Returns `null` for anything that is not a well-formed MCP tool id: a
+ * non-`mcp__` name, a missing or empty server or tool part, or a
+ * case-mismatched prefix. No trimming is applied.
+ */
+function parseMcpToolName(name) {
+    const match = MCP_TOOL_NAME_PATTERN.exec(name);
+    if (!match)
+        return null;
+    return { serverName: match[1], toolName: match[2] };
+}

package/dist/parsers/sessionActivityDetector.d.ts

@@ -29,3 +29,9 @@ export interface SessionActivityResult {
  * @returns Activity state with classification reason
  */
 export declare function detectSessionActivity(sessionPath: string): SessionActivityResult;
+/**
+ * Refresh a cached classification from its unchanged fingerprint without
+ * re-reading the transcript. An active file remains active until it crosses
+ * the same five-minute staleness boundary used by detectSessionActivity.
+ */
+export declare function refreshSessionActivityState(previous: 'active' | 'idle' | 'ended' | 'unknown', mtimeMs: number, nowMs?: number): 'active' | 'idle' | 'ended' | 'unknown';

package/dist/parsers/sessionActivityDetector.js

@@ -45,6 +45,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectSessionActivity = detectSessionActivity;
+exports.refreshSessionActivityState = refreshSessionActivityState;
 const fs = __importStar(require("fs"));
 // ── Constants ──
 /** How many bytes to read from the end of the file for analysis */
@@ -161,6 +162,22 @@ function detectSessionActivity(sessionPath) {
     }
     return { state: 'ended', lastActivityTime: new Date(stat.mtimeMs), reason: 'no-activity-signal' };
 }
+/**
+ * Refresh a cached classification from its unchanged fingerprint without
+ * re-reading the transcript. An active file remains active until it crosses
+ * the same five-minute staleness boundary used by detectSessionActivity.
+ */
+function refreshSessionActivityState(previous, mtimeMs, nowMs = Date.now()) {
+    if (!Number.isFinite(mtimeMs))
+        return previous;
+    if (nowMs - mtimeMs > STALENESS_THRESHOLD_MS)
+        return 'idle';
+    if (previous === 'ended')
+        return 'ended';
+    if (previous === 'idle')
+        return 'idle';
+    return previous === 'unknown' ? 'unknown' : 'active';
+}
 // ── Helpers ──
 function readTail(filePath, fileSize) {
     const bytesToRead = Math.min(TAIL_BYTES, fileSize);

package/dist/parsers/sessionPathResolver.d.ts

@@ -11,10 +11,17 @@
  */
 import type { ProjectFolderInfo } from '../providers/types';
 /**
- * Encodes a workspace path to Claude Code's directory naming scheme.
- *
- * Claude Code replaces path separators, colons, and underscores with hyphens
- * to create a flat directory structure.
+ * Encodes a workspace path to Claude Code's on-disk directory naming scheme
+ * under `~/.claude/projects/` — every non-ASCII-alphanumeric character
+ * (separators, colons, underscores, dots, spaces) becomes a hyphen, and case
+ * is preserved. Exported from the package root as `encodeClaudeWorkspacePath`.
+ *
+ * Not to be confused with the top-level `encodeWorkspacePath` export from
+ * `paths.ts`: that one is Sidekick's own config-store slug (it keeps dots) and
+ * does NOT match Claude Code's scheme — using it to build a
+ * `~/.claude/projects/` path silently misses for any workspace containing a
+ * dot or space. For lookups, prefer `getClaudeSessionDirectory` or the
+ * mismatch-tolerant `discoverSessionDirectory` over raw string encoding.
  *
  * @param workspacePath - Absolute path to workspace directory
  * @returns Encoded path string (e.g., "-home-user-code-project")

package/dist/parsers/sessionPathResolver.js

@@ -61,10 +61,17 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 /**
- * Encodes a workspace path to Claude Code's directory naming scheme.
- *
- * Claude Code replaces path separators, colons, and underscores with hyphens
- * to create a flat directory structure.
+ * Encodes a workspace path to Claude Code's on-disk directory naming scheme
+ * under `~/.claude/projects/` — every non-ASCII-alphanumeric character
+ * (separators, colons, underscores, dots, spaces) becomes a hyphen, and case
+ * is preserved. Exported from the package root as `encodeClaudeWorkspacePath`.
+ *
+ * Not to be confused with the top-level `encodeWorkspacePath` export from
+ * `paths.ts`: that one is Sidekick's own config-store slug (it keeps dots) and
+ * does NOT match Claude Code's scheme — using it to build a
+ * `~/.claude/projects/` path silently misses for any workspace containing a
+ * dot or space. For lookups, prefer `getClaudeSessionDirectory` or the
+ * mismatch-tolerant `discoverSessionDirectory` over raw string encoding.
  *
  * @param workspacePath - Absolute path to workspace directory
  * @returns Encoded path string (e.g., "-home-user-code-project")

package/dist/paths.d.ts

@@ -54,10 +54,14 @@ export declare function getProjectDataPath(slug: string, subdomain: string): str
  */
 export declare function getGlobalDataPath(filename: string): string;
 /**
- * Encodes a workspace path to Claude Code's directory naming scheme.
- * Replaces path separators, colons, and underscores with hyphens.
+ * Encodes a workspace path into Sidekick's own config-store slug — path
+ * separators, colons, and underscores become hyphens, dots are kept.
  *
- * From: sidekick-vscode/src/services/SessionPathResolver.ts:35-43
+ * This is NOT Claude Code's `~/.claude/projects/` naming scheme, despite the
+ * shared name: Claude Code also replaces dots, spaces, and every other
+ * non-alphanumeric character. To locate Claude Code session directories use
+ * `encodeClaudeWorkspacePath` / `getClaudeSessionDirectory` from
+ * `parsers/sessionPathResolver` instead.
  */
 export declare function encodeWorkspacePath(workspacePath: string): string;
 /**

package/dist/paths.js

@@ -129,10 +129,14 @@ function getGlobalDataPath(filename) {
     return path.join(getConfigDir(), filename);
 }
 /**
- * Encodes a workspace path to Claude Code's directory naming scheme.
- * Replaces path separators, colons, and underscores with hyphens.
+ * Encodes a workspace path into Sidekick's own config-store slug — path
+ * separators, colons, and underscores become hyphens, dots are kept.
  *
- * From: sidekick-vscode/src/services/SessionPathResolver.ts:35-43
+ * This is NOT Claude Code's `~/.claude/projects/` naming scheme, despite the
+ * shared name: Claude Code also replaces dots, spaces, and every other
+ * non-alphanumeric character. To locate Claude Code session directories use
+ * `encodeClaudeWorkspacePath` / `getClaudeSessionDirectory` from
+ * `parsers/sessionPathResolver` instead.
  */
 function encodeWorkspacePath(workspacePath) {
     const normalized = workspacePath.replace(/\\/g, '/');

package/dist/providerIds.d.ts

@@ -0,0 +1,11 @@
+/** Browser-safe provider ID catalogs. Types are derived from these values. */
+export declare const SESSION_PROVIDER_IDS: readonly ["claude-code", "opencode", "codex"];
+export type SessionProviderId = (typeof SESSION_PROVIDER_IDS)[number];
+export declare const ACCOUNT_PROVIDER_IDS: readonly ["claude-code", "codex"];
+export type AccountProviderId = (typeof ACCOUNT_PROVIDER_IDS)[number];
+export declare const QUOTA_PROVIDER_IDS: readonly ["claude-code", "codex", "zai"];
+export type QuotaProviderId = (typeof QUOTA_PROVIDER_IDS)[number];
+export declare const RUNTIME_QUOTA_PROVIDER_IDS: readonly ["claude", "codex", "zai"];
+export type RuntimeQuotaProviderId = (typeof RUNTIME_QUOTA_PROVIDER_IDS)[number];
+export declare const MODEL_PROVIDER_IDS: readonly ["anthropic", "openai", "google", "unknown"];
+export type ModelProviderId = (typeof MODEL_PROVIDER_IDS)[number];

package/dist/providerIds.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_PROVIDER_IDS = exports.RUNTIME_QUOTA_PROVIDER_IDS = exports.QUOTA_PROVIDER_IDS = exports.ACCOUNT_PROVIDER_IDS = exports.SESSION_PROVIDER_IDS = void 0;
+/** Browser-safe provider ID catalogs. Types are derived from these values. */
+exports.SESSION_PROVIDER_IDS = ['claude-code', 'opencode', 'codex'];
+exports.ACCOUNT_PROVIDER_IDS = ['claude-code', 'codex'];
+exports.QUOTA_PROVIDER_IDS = ['claude-code', 'codex', 'zai'];
+exports.RUNTIME_QUOTA_PROVIDER_IDS = ['claude', 'codex', 'zai'];
+exports.MODEL_PROVIDER_IDS = ['anthropic', 'openai', 'google', 'unknown'];

package/dist/providerQuota.d.ts

@@ -1,7 +1,9 @@
 import type { PeakHoursState } from './peakHours';
 import type { QuotaState } from './quota';
 import type { QuotaFailureDescriptor } from './quotaPresentation';
-export type RuntimeQuotaProvider = 'claude' | 'codex' | 'zai';
+import type { RuntimeQuotaProviderId } from './providerIds';
+export { RUNTIME_QUOTA_PROVIDER_IDS } from './providerIds';
+export type RuntimeQuotaProvider = RuntimeQuotaProviderId;
 export interface ProviderQuotaState<TProvider extends RuntimeQuotaProvider = RuntimeQuotaProvider> extends QuotaState {
     runtimeProvider: TProvider;
     accountLabel?: string;

package/dist/providerQuota.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_QUOTA_PROVIDER_IDS = void 0;
+var providerIds_1 = require("./providerIds");
+Object.defineProperty(exports, "RUNTIME_QUOTA_PROVIDER_IDS", { enumerable: true, get: function () { return providerIds_1.RUNTIME_QUOTA_PROVIDER_IDS; } });

package/dist/providers/claudeCode.d.ts

@@ -9,7 +9,7 @@
  */
 import type { ReadSessionContextSnapshotOptions, SessionContextSnapshot } from '../context/sessionContext';
 import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
-import type { SessionProviderBase, SessionReader, SessionFileStats, SearchHit, ProjectFolderInfo, ProviderId } from './types';
+import type { SessionProviderBase, SessionReader, SessionFileInfo, SessionFileStats, SearchHit, ProjectFolderInfo, ProviderId, ProviderOperationStatus, ProviderRuntimeStatus, SessionProviderOptions } from './types';
 /**
  * Session provider for Claude Code CLI.
  *
@@ -20,26 +20,35 @@ import type { SessionProviderBase, SessionReader, SessionFileStats, SearchHit, P
 export declare class ClaudeCodeProvider implements SessionProviderBase {
     readonly id: ProviderId;
     readonly displayName = "Claude Code";
+    private readonly diagnostics;
     /** Runtime-reported context window limit (overrides static map when set). */
     private dynamicContextWindowLimit;
+    constructor(options?: SessionProviderOptions);
     getSessionDirectory(workspacePath: string): string;
     discoverSessionDirectory(workspacePath: string): string | null;
     findActiveSession(workspacePath: string): string | null;
     findAllSessions(workspacePath: string): string[];
+    findSessionById(workspacePath: string, sessionId: string): string | null;
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath: string): string[];
     findSessionsInDirectory(dir: string): string[];
     getAllProjectFolders(workspacePath?: string): ProjectFolderInfo[];
+    listAllSessionFiles(): SessionFileInfo[];
+    listSessionFilesAsync(workspacePath?: string): Promise<SessionFileInfo[]>;
     isSessionFile(filename: string): boolean;
     getSessionId(sessionPath: string): string;
     encodeWorkspacePath(workspacePath: string): string;
     extractSessionLabel(sessionPath: string): string | null;
+    extractSessionLabelsAsync(sessionPaths: readonly string[]): Promise<Map<string, string | null>>;
     createReader(sessionPath: string): SessionReader;
     scanSubagents(sessionDir: string, sessionId: string): SubagentStats[];
     searchInSession(sessionPath: string, query: string, maxResults: number): SearchHit[];
     getProjectsBaseDir(): string;
+    getWatchRoots(): string[];
     readSessionStats(sessionPath: string): SessionFileStats;
     readSessionContextSnapshot(sessionPath: string, options?: ReadSessionContextSnapshotOptions): SessionContextSnapshot;
+    getRuntimeStatus(): ProviderRuntimeStatus;
+    getLastOperationStatus(): ProviderOperationStatus;
     getContextWindowLimit(modelId?: string): number;
     /** Set a runtime-reported context window limit (overrides static map). */
     setDynamicContextWindowLimit(limit: number): void;
@@ -51,4 +60,5 @@ export declare class ClaudeCodeProvider implements SessionProviderBase {
      */
     getCurrentUsageSnapshot(sessionPath: string): TokenUsage | null;
     dispose(): void;
+    private recordHomeStatus;
 }