sidekick-shared 0.24.5 → 0.25.0

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,14 @@
+import type { ProviderId, SessionProviderBase, SessionProviderDiagnostic } from './types';
+export interface CreateSessionProvidersOptions {
+    providerIds?: readonly ProviderId[];
+    onDiagnostic?: (diagnostic: SessionProviderDiagnostic) => void;
+}
+export interface CreateSessionProvidersResult {
+    providers: SessionProviderBase[];
+    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,18 @@ 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;
     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 +87,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 +107,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}`.