sidekick-shared 0.24.5 → 0.26.0

package/dist/providers/codexDatabase.d.ts

@@ -3,14 +3,18 @@
  * Ported from sidekick-vscode/src/services/providers/CodexDatabase.ts
  */
 import type { CodexDbThread } from '../types/codex';
+import type { ProviderRuntimeStatus } from './types';
 export declare class CodexDatabase {
     private readonly dbPath;
     private sqlite3Available;
+    private runtimeStatus;
     constructor(codexHome: string);
     isAvailable(): boolean;
     open(): boolean;
+    getRuntimeStatus(): ProviderRuntimeStatus;
     close(): void;
     private query;
+    private queryAsync;
     private queryOne;
     getThreadsByCwd(cwd: string): CodexDbThread[];
     getMostRecentThread(cwd: string): CodexDbThread | null;
@@ -20,6 +24,11 @@ export declare class CodexDatabase {
         lastUpdated: number;
     }>;
     getThread(id: string): CodexDbThread | null;
+    /**
+     * Resolve many thread ids with non-blocking sqlite3 subprocesses — one per
+     * chunk of ids, so the inlined query stays clear of argv length limits.
+     */
+    getThreadsByIdsAsync(ids: readonly string[]): Promise<CodexDbThread[]>;
     /** Get all threads forked from a given session ID. */
     getThreadsByForkedFromId(parentId: string): CodexDbThread[];
     /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */

package/dist/providers/codexDatabase.js

@@ -41,9 +41,15 @@ exports.CodexDatabase = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+/**
+ * Ids per inlined `IN (…)` query. Values are passed inside a single argv
+ * element to sqlite3, so an unbounded list would hit E2BIG on large stores.
+ */
+const SQL_ID_CHUNK_SIZE = 400;
 class CodexDatabase {
     dbPath;
     sqlite3Available = null;
+    runtimeStatus = null;
     constructor(codexHome) {
         this.dbPath = findLatestStateDatabase(codexHome) ?? path.join(codexHome, 'state.sqlite');
     }
@@ -58,6 +64,11 @@ class CodexDatabase {
     open() {
         if (this.sqlite3Available !== null)
             return this.sqlite3Available;
+        if (!this.isAvailable()) {
+            this.sqlite3Available = false;
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return false;
+        }
         try {
             (0, child_process_1.execFileSync)('sqlite3', ['--version'], {
                 encoding: 'utf-8',
@@ -66,13 +77,26 @@ class CodexDatabase {
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
             this.sqlite3Available = true;
+            this.runtimeStatus = { available: true, kind: 'available' };
             return true;
         }
-        catch {
+        catch (error) {
             this.sqlite3Available = false;
+            this.runtimeStatus = classifySqliteError(error);
             return false;
         }
     }
+    getRuntimeStatus() {
+        if (this.runtimeStatus)
+            return this.runtimeStatus;
+        if (!this.isAvailable())
+            return { available: false, kind: 'db_missing' };
+        return {
+            available: false,
+            kind: 'query_failed',
+            message: 'Codex database has not been initialized yet.',
+        };
+    }
     close() { }
     query(sql, params = []) {
         if (!this.sqlite3Available)
@@ -103,7 +127,34 @@ class CodexDatabase {
                 return [];
             return JSON.parse(trimmed);
         }
-        catch {
+        catch (error) {
+            this.runtimeStatus = {
+                ...classifySqliteError(error, 'query_failed'),
+                available: this.sqlite3Available === true,
+            };
+            return [];
+        }
+    }
+    async queryAsync(sql, params = []) {
+        if (!this.isAvailable()) {
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return [];
+        }
+        const query = bindSqlParams(sql, params);
+        try {
+            const result = await execSqlite(this.dbPath, query, 10 * 1024 * 1024);
+            this.sqlite3Available = true;
+            this.runtimeStatus = { available: true, kind: 'available' };
+            const trimmed = result.trim();
+            return trimmed ? JSON.parse(trimmed) : [];
+        }
+        catch (error) {
+            const status = classifySqliteError(error, 'query_failed');
+            // Only a missing sqlite3 binary gates future attempts. A failed query
+            // is transient and must not latch the database off (mirrors query()).
+            if (status.kind === 'sqlite_missing')
+                this.sqlite3Available = false;
+            this.runtimeStatus = status;
             return [];
         }
     }
@@ -132,6 +183,19 @@ class CodexDatabase {
     getThread(id) {
         return this.queryOne('SELECT * FROM threads WHERE id = ?', [id]);
     }
+    /**
+     * Resolve many thread ids with non-blocking sqlite3 subprocesses — one per
+     * chunk of ids, so the inlined query stays clear of argv length limits.
+     */
+    async getThreadsByIdsAsync(ids) {
+        const results = [];
+        for (let i = 0; i < ids.length; i += SQL_ID_CHUNK_SIZE) {
+            const chunk = ids.slice(i, i + SQL_ID_CHUNK_SIZE);
+            const placeholders = chunk.map(() => '?').join(', ');
+            results.push(...(await this.queryAsync(`SELECT * FROM threads WHERE id IN (${placeholders})`, [...chunk])));
+        }
+        return results;
+    }
     /** Get all threads forked from a given session ID. */
     getThreadsByForkedFromId(parentId) {
         return this.query('SELECT * FROM threads WHERE forked_from_id = ? ORDER BY created_at ASC', [parentId]);
@@ -147,6 +211,47 @@ class CodexDatabase {
     }
 }
 exports.CodexDatabase = CodexDatabase;
+function classifySqliteError(error, fallback = 'sqlite_blocked') {
+    const code = error?.code;
+    if (code === 'ENOENT') {
+        return {
+            available: false,
+            kind: 'sqlite_missing',
+            message: 'The sqlite3 executable was not found.',
+        };
+    }
+    return {
+        available: false,
+        kind: fallback,
+        message: error instanceof Error ? error.message : 'sqlite3 could not be executed.',
+    };
+}
+function bindSqlParams(sql, params) {
+    let paramIndex = 0;
+    return sql.replace(/\?/g, () => {
+        if (paramIndex >= params.length)
+            return '?';
+        const param = params[paramIndex++];
+        if (typeof param === 'number')
+            return Number.isFinite(param) ? String(param) : '0';
+        return `'${String(param).replace(/'/g, "''")}'`;
+    });
+}
+function execSqlite(dbPath, query, maxBuffer) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)('sqlite3', ['-json', '-readonly', dbPath, query], {
+            encoding: 'utf8',
+            timeout: 4_000,
+            killSignal: 'SIGKILL',
+            maxBuffer,
+        }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
 function findLatestStateDatabase(codexHome) {
     try {
         const entries = fs.readdirSync(codexHome, { withFileTypes: true });

package/dist/providers/detect.d.ts

@@ -4,6 +4,8 @@
  * without VS Code dependency (no vscode.workspace.getConfiguration).
  */
 import type { ProviderId } from './types';
+/** Forget the memoised ranking. Test-only. */
+export declare function _resetProviderDetectionCache(): void;
 /**
  * Returns all provider IDs whose data directories exist on the filesystem.
  * Ordered by most-recent activity first.

package/dist/providers/detect.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports._resetProviderDetectionCache = _resetProviderDetectionCache;
 exports.getAllDetectedProviders = getAllDetectedProviders;
 exports.detectProvider = detectProvider;
 const fs = __importStar(require("fs"));
@@ -169,11 +170,25 @@ function getProviderPaths() {
         codexHomes,
     };
 }
+/** Ranked detection results are reused within a process for this long. */
+const DETECTION_CACHE_TTL_MS = 5_000;
+let detectionCache = null;
+/** Forget the memoised ranking. Test-only. */
+function _resetProviderDetectionCache() {
+    detectionCache = null;
+}
 /**
- * Returns all provider IDs whose data directories exist on the filesystem.
- * Ordered by most-recent activity first.
+ * Providers with data on disk, most recently active first.
+ *
+ * Detection walks every provider's session corpus (a recursive stat over
+ * `~/.claude/projects`, every Codex home, and the OpenCode data dir), so the
+ * ranking is memoised briefly: the CLI resolves the provider several times per
+ * command and the extension asks again on every settings-driven re-detect.
  */
-function getAllDetectedProviders() {
+function rankDetectedProviders(now = Date.now()) {
+    if (detectionCache && now - detectionCache.at < DETECTION_CACHE_TTL_MS) {
+        return detectionCache.ranked;
+    }
     const { claudeBase, openCodeDbPath, openCodeStorageDir, codexHomes } = getProviderPaths();
     const hasClaude = fs.existsSync(claudeBase);
     const hasOpenCode = fs.existsSync(openCodeStorageDir) || fs.existsSync(openCodeDbPath);
@@ -186,7 +201,16 @@ function getAllDetectedProviders() {
     if (hasCodex)
         available.push({ id: 'codex', mtime: getCodexActivityMtime() });
     available.sort((a, b) => b.mtime - a.mtime);
-    return available.map((a) => a.id);
+    const ranked = available.map((a) => a.id);
+    detectionCache = { at: now, ranked };
+    return ranked;
+}
+/**
+ * Returns all provider IDs whose data directories exist on the filesystem.
+ * Ordered by most-recent activity first.
+ */
+function getAllDetectedProviders() {
+    return [...rankDetectedProviders()];
 }
 /**
  * Detects the most appropriate provider based on filesystem presence and recency.
@@ -195,24 +219,5 @@ function getAllDetectedProviders() {
 function detectProvider(override) {
     if (override && override !== 'auto')
         return override;
-    const { claudeBase, openCodeDbPath, openCodeStorageDir, codexHomes } = getProviderPaths();
-    const hasClaude = fs.existsSync(claudeBase);
-    const hasOpenCode = fs.existsSync(openCodeStorageDir) || fs.existsSync(openCodeDbPath);
-    const hasCodex = codexHomes.some((codexHome) => fs.existsSync(path.join(codexHome, 'sessions')) || hasCodexStateDb(codexHome));
-    const available = [];
-    if (hasClaude) {
-        available.push({ id: 'claude-code', mtime: getClaudeActivityMtime(claudeBase) });
-    }
-    if (hasOpenCode) {
-        available.push({ id: 'opencode', mtime: getOpenCodeActivityMtime() });
-    }
-    if (hasCodex) {
-        available.push({ id: 'codex', mtime: getCodexActivityMtime() });
-    }
-    if (available.length === 0)
-        return 'claude-code';
-    if (available.length === 1)
-        return available[0].id;
-    available.sort((a, b) => b.mtime - a.mtime);
-    return available[0].id;
+    return rankDetectedProviders()[0] ?? 'claude-code';
 }

package/dist/providers/diagnostics.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderId, ProviderOperationStatus, ProviderRuntimeStatus, SessionProviderDiagnostic, SessionProviderOptions } from './types';
+/** Small per-provider diagnostic state; it never stores transcript or environment contents. */
+export declare class ProviderDiagnosticTracker {
+    private readonly providerId;
+    private readonly options;
+    private lastEmittedSignature;
+    private lastStatus;
+    constructor(providerId: ProviderId, options?: SessionProviderOptions);
+    available(operation: string): void;
+    degraded(operation: string, runtimeStatus: ProviderRuntimeStatus, diagnostic: Omit<SessionProviderDiagnostic, 'providerId'>, usable?: boolean): void;
+    getLastOperationStatus(): ProviderOperationStatus;
+}
+export declare function diagnosticFromRuntimeStatus(providerId: ProviderId, phase: SessionProviderDiagnostic['phase'], status: ProviderRuntimeStatus): SessionProviderDiagnostic | null;

package/dist/providers/diagnostics.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderDiagnosticTracker = void 0;
+exports.diagnosticFromRuntimeStatus = diagnosticFromRuntimeStatus;
+const AVAILABLE_STATUS = { available: true, kind: 'available' };
+/** Small per-provider diagnostic state; it never stores transcript or environment contents. */
+class ProviderDiagnosticTracker {
+    providerId;
+    options;
+    lastEmittedSignature = null;
+    lastStatus = {
+        operation: 'construct',
+        usable: true,
+        degraded: false,
+        runtimeStatus: AVAILABLE_STATUS,
+        diagnostics: [],
+    };
+    constructor(providerId, options = {}) {
+        this.providerId = providerId;
+        this.options = options;
+    }
+    available(operation) {
+        this.lastEmittedSignature = null;
+        this.lastStatus = {
+            operation,
+            usable: true,
+            degraded: false,
+            runtimeStatus: AVAILABLE_STATUS,
+            diagnostics: [],
+        };
+    }
+    degraded(operation, runtimeStatus, diagnostic, usable = true) {
+        const value = { providerId: this.providerId, ...diagnostic };
+        this.lastStatus = {
+            operation,
+            usable,
+            degraded: true,
+            runtimeStatus,
+            diagnostics: [value],
+        };
+        const signature = `${value.kind}\0${value.severity}\0${value.phase}\0${value.message}`;
+        if (signature === this.lastEmittedSignature)
+            return;
+        this.lastEmittedSignature = signature;
+        try {
+            this.options.onDiagnostic?.(value);
+        }
+        catch {
+            // Diagnostics are observational and cannot break provider operations.
+        }
+    }
+    getLastOperationStatus() {
+        return {
+            ...this.lastStatus,
+            runtimeStatus: { ...this.lastStatus.runtimeStatus },
+            diagnostics: [...this.lastStatus.diagnostics],
+        };
+    }
+}
+exports.ProviderDiagnosticTracker = ProviderDiagnosticTracker;
+function diagnosticFromRuntimeStatus(providerId, phase, status) {
+    if (status.kind === 'available')
+        return null;
+    const kind = status.kind;
+    return {
+        providerId,
+        kind,
+        severity: status.kind === 'query_failed' ? 'error' : 'warning',
+        phase,
+        message: status.message ?? defaultRuntimeMessage(providerId, status.kind),
+    };
+}
+function defaultRuntimeMessage(providerId, kind) {
+    switch (kind) {
+        case 'home_unavailable':
+            return `${providerId} data home is unavailable.`;
+        case 'config_unreadable':
+            return `${providerId} configuration is unreadable.`;
+        case 'db_missing':
+            return `${providerId} database is unavailable; file fallback is active.`;
+        case 'sqlite_missing':
+            return 'The sqlite3 executable is unavailable; file fallback is active.';
+        case 'sqlite_blocked':
+            return 'The sqlite3 executable could not be started; file fallback is active.';
+        case 'query_failed':
+            return `${providerId} database query failed; fallback data may be incomplete.`;
+    }
+}

package/dist/providers/factory.d.ts

@@ -0,0 +1,20 @@
+import type { ProviderId, SessionProviderBase, SessionProviderDiagnostic } from './types';
+export interface CreateSessionProvidersOptions {
+    providerIds?: readonly ProviderId[];
+    onDiagnostic?: (diagnostic: SessionProviderDiagnostic) => void;
+}
+export interface CreateSessionProvidersResult {
+    providers: SessionProviderBase[];
+    /**
+     * Live, not a snapshot: the providers keep the emit closure and update
+     * entries in place (one per provider/kind/phase) as they run, so this array
+     * reflects the latest diagnostics whenever it is read. Copy it to freeze a
+     * point in time; use `onDiagnostic` to observe each emission.
+     */
+    diagnostics: SessionProviderDiagnostic[];
+}
+/**
+ * Constructs built-in providers without probing the filesystem or binaries.
+ * A broken provider is isolated and reported instead of aborting host startup.
+ */
+export declare function createSessionProviders(options?: CreateSessionProvidersOptions): CreateSessionProvidersResult;

package/dist/providers/factory.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionProviders = createSessionProviders;
+const claudeCode_1 = require("./claudeCode");
+const codex_1 = require("./codex");
+const openCode_1 = require("./openCode");
+const types_1 = require("./types");
+/**
+ * Constructs built-in providers without probing the filesystem or binaries.
+ * A broken provider is isolated and reported instead of aborting host startup.
+ */
+function createSessionProviders(options = {}) {
+    const diagnostics = [];
+    const diagnosticIndexes = new Map();
+    const providers = [];
+    const selected = new Set(options.providerIds ?? types_1.SESSION_PROVIDER_IDS);
+    const emit = (diagnostic) => {
+        const key = `${diagnostic.providerId}\0${diagnostic.kind}\0${diagnostic.phase}`;
+        const existingIndex = diagnosticIndexes.get(key);
+        if (existingIndex === undefined) {
+            diagnosticIndexes.set(key, diagnostics.length);
+            diagnostics.push(diagnostic);
+        }
+        else {
+            diagnostics[existingIndex] = diagnostic;
+        }
+        try {
+            options.onDiagnostic?.(diagnostic);
+        }
+        catch {
+            // A host diagnostic callback cannot break provider setup.
+        }
+    };
+    for (const providerId of types_1.SESSION_PROVIDER_IDS) {
+        if (!selected.has(providerId))
+            continue;
+        try {
+            const providerOptions = { onDiagnostic: emit };
+            providers.push(providerId === 'claude-code'
+                ? new claudeCode_1.ClaudeCodeProvider(providerOptions)
+                : providerId === 'opencode'
+                    ? new openCode_1.OpenCodeProvider(providerOptions)
+                    : new codex_1.CodexProvider(providerOptions));
+        }
+        catch {
+            const diagnostic = {
+                providerId,
+                kind: 'construction_failed',
+                severity: 'error',
+                phase: 'construct',
+                message: `${providerId} could not be constructed and was omitted.`,
+            };
+            emit(diagnostic);
+        }
+    }
+    return { providers, diagnostics };
+}

package/dist/providers/openCode.d.ts

@@ -18,7 +18,7 @@
 import type { ReadSessionContextSnapshotOptions, SessionContextSnapshot } from '../context/sessionContext';
 import type { ZaiTier } from '../zaiQuota';
 import type { QuotaState } from '../quota';
-import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileStats, ProviderId, ProviderRuntimeStatus } from './types';
+import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileStats, ProviderId, ProviderRuntimeStatus, ProviderOperationStatus, SessionFileInfo, SessionProviderOptions } from './types';
 import type { TokenUsage, SubagentStats, ContextAttribution } from '../types/sessionEvent';
 /**
  * Gets the OpenCode data directory.
@@ -42,13 +42,23 @@ export declare class OpenCodeProvider implements SessionProviderBase {
     private db;
     private dbInitialized;
     private dbStatus;
+    private readonly diagnostics;
     /** Cache of session metadata populated during listing */
     private sessionMetaCache;
     /** Runtime-reported context window limit (overrides static map when set). */
     private dynamicContextWindowLimit;
+    constructor(options?: SessionProviderOptions);
     /** Lazy-initialize the database connection. */
     private ensureDb;
+    private ensureDbAsync;
+    /**
+     * Cache an async-created database only after an operation proved it usable.
+     * Sync paths treat a cached `db` as "open() succeeded", so adopting an
+     * unproven instance would cut them off from the file-storage fallback.
+     */
+    private adoptDbIfAvailable;
     getRuntimeStatus(): ProviderRuntimeStatus;
+    getLastOperationStatus(): ProviderOperationStatus;
     canMonitorDirectory(dir: string): boolean;
     private mapDbSessions;
     getSessionDirectory(workspacePath: string): string;
@@ -58,14 +68,20 @@ export declare class OpenCodeProvider implements SessionProviderBase {
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath: string): string[];
     findAllSessions(workspacePath: string): string[];
+    findSessionById(workspacePath: string, sessionId: string): string | null;
     findSessionsInDirectory(dir: string): string[];
     private findSessionsInDirectoryFromFiles;
+    listAllSessionFiles(): SessionFileInfo[];
+    listSessionFilesAsync(workspacePath?: string): Promise<SessionFileInfo[]>;
     getAllProjectFolders(workspacePath?: string): ProjectFolderInfo[];
     private getAllProjectFoldersFromFiles;
     isSessionFile(filename: string): boolean;
     getSessionId(sessionPath: string): string;
     encodeWorkspacePath(workspacePath: string): string;
+    /** Session title from the metadata cache or the database; null without either. */
+    private extractSessionLabelFromMetadata;
     extractSessionLabel(sessionPath: string): string | null;
+    extractSessionLabelsAsync(sessionPaths: readonly string[]): Promise<Map<string, string | null>>;
     private extractSessionLabelFromFiles;
     createReader(sessionPath: string): SessionReader;
     scanSubagents(_sessionDir: string, sessionId: string): SubagentStats[];
@@ -73,11 +89,15 @@ export declare class OpenCodeProvider implements SessionProviderBase {
     private searchInSessionFromDb;
     private searchInSessionFromFiles;
     getProjectsBaseDir(): string;
+    getWatchRoots(): string[];
     readSessionStats(sessionPath: string): SessionFileStats;
     readSessionContextSnapshot(sessionPath: string, options?: ReadSessionContextSnapshotOptions): SessionContextSnapshot;
     getSessionMetadata(sessionPath: string): {
         mtime: Date;
     } | null;
+    getSessionMetadataAsync(sessionPath: string): Promise<{
+        mtime: Date;
+    } | null>;
     /**
      * Returns the latest assistant message's token snapshot for context window sizing.
      * Cumulative session totals are derived from readNew() events processed by SessionMonitor.
@@ -89,6 +109,7 @@ export declare class OpenCodeProvider implements SessionProviderBase {
     /** Set a runtime-reported context window limit (overrides static map). */
     setDynamicContextWindowLimit(limit: number): void;
     dispose(): void;
+    private recordDatabaseStatus;
     /**
      * Derives a z.ai coding-plan `QuotaState` from OpenCode assistant turns
      * tagged with `providerID ∈ {zai, zai-coding-plan}`.