sidekick-shared 0.13.5 → 0.13.6

package/dist/index.d.ts

@@ -25,7 +25,7 @@ export { readHistory } from './readers/history';
 export { readLatestHandoff } from './readers/handoff';
 export { readPlans, getLatestPlan, writePlans, getPlanAnalytics, readClaudeCodePlanFiles } from './readers/plans';
 export type { ReadPlansOptions, PlanAnalytics } from './readers/plans';
-export type { ProviderId, SessionProvider, SessionProviderBase, SessionFileStats, SessionFileInfo, SearchHit, ProjectFolderInfo, SessionReader } from './providers/types';
+export type { ProviderId, SessionProvider, SessionProviderBase, SessionFileStats, SessionFileInfo, SearchHit, ProjectFolderInfo, SessionReader, ProviderRuntimeStatus } from './providers/types';
 export { detectProvider, getAllDetectedProviders } from './providers/detect';
 export { ClaudeCodeProvider } from './providers/claudeCode';
 export { OpenCodeProvider } from './providers/openCode';

package/dist/providers/detect.js

@@ -47,6 +47,11 @@ function getOpenCodeDataDir() {
     const xdg = process.env.XDG_DATA_HOME;
     if (xdg)
         return path.join(xdg, 'opencode');
+    if (process.platform === 'darwin')
+        return path.join(os.homedir(), 'Library', 'Application Support', 'opencode');
+    if (process.platform === 'win32') {
+        return path.join(process.env.LOCALAPPDATA || process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'opencode');
+    }
     return path.join(os.homedir(), '.local', 'share', 'opencode');
 }
 function getCodexHome() {

package/dist/providers/openCode.d.ts

@@ -15,7 +15,7 @@
  *
  * @module providers/openCode
  */
-import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileStats, ProviderId } from './types';
+import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileStats, ProviderId, ProviderRuntimeStatus } from './types';
 import type { TokenUsage, SubagentStats, ContextAttribution } from '../types/sessionEvent';
 /**
  * Session provider for OpenCode CLI.
@@ -28,10 +28,14 @@ export declare class OpenCodeProvider implements SessionProviderBase {
     readonly displayName = "OpenCode";
     private db;
     private dbInitialized;
+    private dbStatus;
     /** Cache of session metadata populated during listing */
     private sessionMetaCache;
     /** Lazy-initialize the database connection. */
     private ensureDb;
+    getRuntimeStatus(): ProviderRuntimeStatus;
+    canMonitorDirectory(dir: string): boolean;
+    private mapDbSessions;
     getSessionDirectory(workspacePath: string): string;
     discoverSessionDirectory(workspacePath: string): string | null;
     findActiveSession(workspacePath: string): string | null;

package/dist/providers/openCode.js

@@ -69,6 +69,12 @@ function getOpenCodeDataDir() {
     if (xdg) {
         return path.join(xdg, 'opencode');
     }
+    if (process.platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'opencode');
+    }
+    if (process.platform === 'win32') {
+        return path.join(process.env.LOCALAPPDATA || process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'opencode');
+    }
     return path.join(os.homedir(), '.local', 'share', 'opencode');
 }
 /**
@@ -170,12 +176,18 @@ function extractParentIdFromDbMessage(row) {
  *
  * Tries DB first, then file-based project metadata, then git root commit hash.
  */
-function resolveProjectId(workspacePath, db) {
+function resolveProjectId(workspacePath, db, runtimeStatus) {
     // Strategy 1: DB lookup
     if (db) {
         const dbProject = db.findProjectByWorktree(workspacePath);
         if (dbProject)
             return dbProject.id;
+        const byDirectory = db.findProjectBySessionDirectory(workspacePath);
+        if (byDirectory)
+            return byDirectory.id;
+    }
+    if (runtimeStatus.kind !== 'db_missing') {
+        return null;
     }
     // Strategy 2: scan project files to find matching path
     return resolveProjectIdFromFiles(workspacePath);
@@ -596,6 +608,7 @@ class OpenCodeProvider {
     displayName = 'OpenCode';
     db = null;
     dbInitialized = false;
+    dbStatus = { available: false, kind: 'db_missing' };
     /** Cache of session metadata populated during listing */
     sessionMetaCache = new Map();
     /** Lazy-initialize the database connection. */
@@ -605,15 +618,47 @@ class OpenCodeProvider {
         this.dbInitialized = true;
         const dataDir = getOpenCodeDataDir();
         const db = new openCodeDatabase_1.OpenCodeDatabase(dataDir);
-        if (db.isAvailable() && db.open()) {
+        if (db.open()) {
             this.db = db;
         }
+        this.dbStatus = db.getRuntimeStatus();
         return this.db;
     }
+    getRuntimeStatus() {
+        const db = this.ensureDb();
+        if (db)
+            return db.getRuntimeStatus();
+        return this.dbStatus;
+    }
+    canMonitorDirectory(dir) {
+        if (fs.existsSync(dir))
+            return true;
+        const db = this.ensureDb();
+        if (!db)
+            return false;
+        const projectId = extractProjectIdFromDbPath(dir + path.sep + 'dummy.json') || path.basename(dir);
+        return projectId.length > 0 && db.hasProject(projectId);
+    }
+    mapDbSessions(projectId) {
+        const db = this.ensureDb();
+        if (!db)
+            return [];
+        const sessions = db.getSessionsForProject(projectId);
+        const dataDir = getOpenCodeDataDir();
+        return sessions.map(session => {
+            const syntheticPath = makeDbSessionPath(dataDir, projectId, session.id);
+            this.sessionMetaCache.set(syntheticPath, {
+                title: session.title,
+                timeUpdated: session.time_updated,
+            });
+            return syntheticPath;
+        });
+    }
     // --- Path resolution ---
     getSessionDirectory(workspacePath) {
         const db = this.ensureDb();
-        const projectId = resolveProjectId(workspacePath, db);
+        const dbStatus = this.getRuntimeStatus();
+        const projectId = resolveProjectId(workspacePath, db, dbStatus);
         if (projectId) {
             // For DB sessions, return a synthetic directory path
             if (db) {
@@ -621,20 +666,26 @@ class OpenCodeProvider {
             }
             return path.join(getStorageDir(), 'session', projectId);
         }
+        if (dbStatus.kind !== 'db_missing') {
+            return path.join(getOpenCodeDataDir(), DB_SESSION_PREFIX);
+        }
         return path.join(getStorageDir(), 'session');
     }
     discoverSessionDirectory(workspacePath) {
         const db = this.ensureDb();
-        const projectId = resolveProjectId(workspacePath, db);
+        const dbStatus = this.getRuntimeStatus();
+        const projectId = resolveProjectId(workspacePath, db, dbStatus);
         if (!projectId)
             return null;
         // DB: check if project has sessions
         if (db) {
-            const sessions = db.getSessionsForProject(projectId);
-            if (sessions.length > 0) {
+            if (db.hasProject(projectId)) {
                 return path.join(getOpenCodeDataDir(), DB_SESSION_PREFIX, projectId);
             }
         }
+        if (dbStatus.kind !== 'db_missing') {
+            return null;
+        }
         // File fallback
         const dir = path.join(getStorageDir(), 'session', projectId);
         return fs.existsSync(dir) ? dir : null;
@@ -642,7 +693,8 @@ class OpenCodeProvider {
     // --- Session discovery ---
     findActiveSession(workspacePath) {
         const db = this.ensureDb();
-        const projectId = resolveProjectId(workspacePath, db);
+        const dbStatus = this.getRuntimeStatus();
+        const projectId = resolveProjectId(workspacePath, db, dbStatus);
         if (!projectId)
             return null;
         // DB primary
@@ -657,6 +709,9 @@ class OpenCodeProvider {
                 return syntheticPath;
             }
         }
+        if (dbStatus.kind !== 'db_missing') {
+            return null;
+        }
         // File fallback
         return this.findActiveSessionFromFiles(projectId);
     }
@@ -717,23 +772,16 @@ class OpenCodeProvider {
     }
     findAllSessions(workspacePath) {
         const db = this.ensureDb();
-        const projectId = resolveProjectId(workspacePath, db);
+        const dbStatus = this.getRuntimeStatus();
+        const projectId = resolveProjectId(workspacePath, db, dbStatus);
         if (!projectId)
             return [];
         // DB primary
         if (db) {
-            const sessions = db.getSessionsForProject(projectId);
-            if (sessions.length > 0) {
-                const dataDir = getOpenCodeDataDir();
-                return sessions.map(s => {
-                    const syntheticPath = makeDbSessionPath(dataDir, projectId, s.id);
-                    this.sessionMetaCache.set(syntheticPath, {
-                        title: s.title,
-                        timeUpdated: s.time_updated,
-                    });
-                    return syntheticPath;
-                });
-            }
+            return this.mapDbSessions(projectId);
+        }
+        if (dbStatus.kind !== 'db_missing') {
+            return [];
         }
         // File fallback
         const sessionDir = path.join(getStorageDir(), 'session', projectId);
@@ -741,39 +789,25 @@ class OpenCodeProvider {
     }
     findSessionsInDirectory(dir) {
         const db = this.ensureDb();
+        const dbStatus = this.getRuntimeStatus();
         // Check if this is a synthetic DB session directory
         if (db && dir.includes(path.sep + DB_SESSION_PREFIX + path.sep)) {
             const projectId = extractProjectIdFromDbPath(dir + path.sep + 'dummy.json');
             if (projectId) {
-                const sessions = db.getSessionsForProject(projectId);
-                const dataDir = getOpenCodeDataDir();
-                return sessions.map(s => {
-                    const syntheticPath = makeDbSessionPath(dataDir, projectId, s.id);
-                    this.sessionMetaCache.set(syntheticPath, {
-                        title: s.title,
-                        timeUpdated: s.time_updated,
-                    });
-                    return syntheticPath;
-                });
+                return this.mapDbSessions(projectId);
             }
         }
         // For a DB-backed directory path ending with the project ID,
         // try to extract project ID from dir name
         if (db) {
             const dirName = path.basename(dir);
-            const sessions = db.getSessionsForProject(dirName);
-            if (sessions.length > 0) {
-                const dataDir = getOpenCodeDataDir();
-                return sessions.map(s => {
-                    const syntheticPath = makeDbSessionPath(dataDir, dirName, s.id);
-                    this.sessionMetaCache.set(syntheticPath, {
-                        title: s.title,
-                        timeUpdated: s.time_updated,
-                    });
-                    return syntheticPath;
-                });
+            if (db.hasProject(dirName)) {
+                return this.mapDbSessions(dirName);
             }
         }
+        if (dbStatus.kind !== 'db_missing') {
+            return [];
+        }
         // File fallback
         return this.findSessionsInDirectoryFromFiles(dir);
     }
@@ -804,6 +838,7 @@ class OpenCodeProvider {
     getAllProjectFolders(workspacePath) {
         const db = this.ensureDb();
         const folders = [];
+        const dbStatus = this.getRuntimeStatus();
         // DB primary
         if (db) {
             const projects = db.getAllProjects();
@@ -811,7 +846,7 @@ class OpenCodeProvider {
             const statsMap = new Map(stats.map(s => [s.projectId, s]));
             let currentProjectId = null;
             if (workspacePath) {
-                currentProjectId = resolveProjectId(workspacePath, db);
+                currentProjectId = resolveProjectId(workspacePath, db, dbStatus);
             }
             const dataDir = getOpenCodeDataDir();
             for (const project of projects) {
@@ -841,6 +876,9 @@ class OpenCodeProvider {
             if (folders.length > 0)
                 return folders;
         }
+        if (dbStatus.kind !== 'db_missing') {
+            return [];
+        }
         // File fallback
         return this.getAllProjectFoldersFromFiles(workspacePath);
     }
@@ -935,7 +973,7 @@ class OpenCodeProvider {
     }
     encodeWorkspacePath(workspacePath) {
         const db = this.ensureDb();
-        return resolveProjectId(workspacePath, db) || workspacePath;
+        return resolveProjectId(workspacePath, db, this.getRuntimeStatus()) || workspacePath;
     }
     extractSessionLabel(sessionPath) {
         const db = this.ensureDb();

package/dist/providers/openCodeDatabase.d.ts

@@ -6,6 +6,7 @@ export interface DbProject {
     id: string;
     worktree: string;
     name: string | null;
+    sandboxes: string[];
     time_created: number;
     time_updated: number;
 }
@@ -32,17 +33,25 @@ export interface DbPart {
     time_updated: number;
     data: string;
 }
+export interface OpenCodeDbRuntimeStatus {
+    available: boolean;
+    kind: 'available' | 'db_missing' | 'sqlite_missing' | 'sqlite_blocked' | 'query_failed';
+    message?: string;
+}
 export declare class OpenCodeDatabase {
     private readonly dbPath;
-    private sqlite3Available;
+    private runtimeStatus;
     constructor(dataDir: string);
     isAvailable(): boolean;
+    getRuntimeStatus(): OpenCodeDbRuntimeStatus;
     open(): boolean;
     close(): void;
     private query;
     private queryOne;
     findProjectByWorktree(workspacePath: string): DbProject | null;
+    findProjectBySessionDirectory(workspacePath: string): DbProject | null;
     getAllProjects(): DbProject[];
+    hasProject(projectId: string): boolean;
     getSessionsForProject(projectId: string): DbSession[];
     /** Get the most recently updated session for a project (excludes subagent child sessions). */
     getMostRecentSession(projectId: string): DbSession | null;

package/dist/providers/openCodeDatabase.js

@@ -43,27 +43,40 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 class OpenCodeDatabase {
     dbPath;
-    sqlite3Available = null;
+    runtimeStatus = null;
     constructor(dataDir) {
         this.dbPath = path.join(dataDir, 'opencode.db');
     }
     isAvailable() { return fs.existsSync(this.dbPath); }
+    getRuntimeStatus() {
+        if (this.runtimeStatus)
+            return this.runtimeStatus;
+        if (!this.isAvailable()) {
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return this.runtimeStatus;
+        }
+        return { available: false, kind: 'query_failed', message: 'OpenCode database has not been initialized yet.' };
+    }
     open() {
-        if (this.sqlite3Available !== null)
-            return this.sqlite3Available;
+        if (this.runtimeStatus)
+            return this.runtimeStatus.available;
+        if (!this.isAvailable()) {
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return false;
+        }
         try {
             (0, child_process_1.execFileSync)('sqlite3', ['--version'], { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] });
-            this.sqlite3Available = true;
+            this.runtimeStatus = { available: true, kind: 'available' };
             return true;
         }
-        catch {
-            this.sqlite3Available = false;
+        catch (error) {
+            this.runtimeStatus = toRuntimeStatus(error);
             return false;
         }
     }
     close() { }
     query(sql, params = []) {
-        if (!this.sqlite3Available)
+        if (!this.open())
             return [];
         let query = sql;
         for (const param of params) {
@@ -78,12 +91,14 @@ class OpenCodeDatabase {
             const result = (0, child_process_1.execFileSync)('sqlite3', ['-json', '-readonly', this.dbPath, query], {
                 encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: 50 * 1024 * 1024,
             });
+            this.runtimeStatus = { available: true, kind: 'available' };
             const trimmed = result.trim();
             if (!trimmed)
                 return [];
             return JSON.parse(trimmed);
         }
-        catch {
+        catch (error) {
+            this.runtimeStatus = toRuntimeStatus(error, 'query_failed');
             return [];
         }
     }
@@ -93,27 +108,50 @@ class OpenCodeDatabase {
     }
     findProjectByWorktree(workspacePath) {
         const normalized = normalizePath(workspacePath);
-        const exact = this.queryOne('SELECT id, worktree, name, time_created, time_updated FROM project WHERE worktree = ?', [normalized]);
-        if (exact)
-            return exact;
-        const all = this.query('SELECT id, worktree, name, time_created, time_updated FROM project');
-        const matches = [];
-        for (const proj of all) {
-            const projPath = normalizePath(proj.worktree);
-            if (projPath === normalized)
-                return proj;
-            if (normalized.startsWith(projPath + path.sep) || projPath.startsWith(normalized + path.sep)) {
-                matches.push({ ...proj, pathLen: projPath.length });
+        const all = this.getAllProjects();
+        let best = null;
+        let bestScore = -1;
+        for (const project of all) {
+            const worktreeScore = pathMatchScore(project.worktree, normalized);
+            if (worktreeScore > bestScore) {
+                best = project;
+                bestScore = worktreeScore;
+            }
+            for (const sandbox of project.sandboxes) {
+                const sandboxScore = pathMatchScore(sandbox, normalized);
+                if (sandboxScore > bestScore) {
+                    best = project;
+                    bestScore = sandboxScore;
+                }
             }
         }
-        if (matches.length > 0) {
-            matches.sort((a, b) => b.pathLen - a.pathLen);
-            return matches[0];
+        return bestScore >= 0 ? best : null;
+    }
+    findProjectBySessionDirectory(workspacePath) {
+        const normalized = normalizePath(workspacePath);
+        const sessions = this.query('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC');
+        let bestProjectId = null;
+        let bestScore = -1;
+        for (const session of sessions) {
+            const score = pathMatchScore(session.directory, normalized);
+            if (score > bestScore) {
+                bestProjectId = session.project_id;
+                bestScore = score;
+            }
         }
-        return null;
+        if (!bestProjectId)
+            return null;
+        return this.getAllProjects().find(project => project.id === bestProjectId) ?? null;
     }
     getAllProjects() {
-        return this.query('SELECT id, worktree, name, time_created, time_updated FROM project');
+        return this.query('SELECT id, worktree, name, sandboxes, time_created, time_updated FROM project')
+            .map(project => ({
+            ...project,
+            sandboxes: parseStringArray(project.sandboxes),
+        }));
+    }
+    hasProject(projectId) {
+        return this.queryOne('SELECT id FROM project WHERE id = ? LIMIT 1', [projectId]) !== null;
     }
     getSessionsForProject(projectId) {
         return this.query('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE project_id = ? AND parent_id IS NULL ORDER BY time_updated DESC', [projectId]);
@@ -230,3 +268,55 @@ function normalizePath(input) {
         return path.resolve(input);
     }
 }
+function parseStringArray(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((entry) => typeof entry === 'string' && entry.length > 0).map(normalizePath)
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeForCompare(input) {
+    const normalized = normalizePath(input);
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function pathMatchScore(candidate, workspacePath) {
+    if (!candidate)
+        return -1;
+    const normalizedCandidate = normalizeForCompare(candidate);
+    const normalizedWorkspace = normalizeForCompare(workspacePath);
+    if (normalizedCandidate === normalizedWorkspace)
+        return 10_000 + normalizedCandidate.length;
+    const candidatePrefix = normalizedCandidate.endsWith(path.sep)
+        ? normalizedCandidate
+        : normalizedCandidate + path.sep;
+    const workspacePrefix = normalizedWorkspace.endsWith(path.sep)
+        ? normalizedWorkspace
+        : normalizedWorkspace + path.sep;
+    if (normalizedWorkspace.startsWith(candidatePrefix))
+        return 5_000 + normalizedCandidate.length;
+    if (normalizedCandidate.startsWith(workspacePrefix))
+        return 1_000 + normalizedCandidate.length;
+    return -1;
+}
+function toRuntimeStatus(error, fallback = 'sqlite_missing') {
+    if (isErrno(error, 'ENOENT')) {
+        return { available: false, kind: 'sqlite_missing', message: 'sqlite3 executable not found in PATH.' };
+    }
+    if (isErrno(error, 'EPERM') || isErrno(error, 'EACCES')) {
+        return { available: false, kind: 'sqlite_blocked', message: 'sqlite3 exists but could not be executed.' };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { available: false, kind: fallback, message };
+}
+function isErrno(error, code) {
+    return typeof error === 'object'
+        && error !== null
+        && 'code' in error
+        && error.code === code;
+}

package/dist/providers/types.d.ts

@@ -55,6 +55,11 @@ export interface ProjectFolderInfo {
     sessionCount: number;
     lastModified: Date;
 }
+export interface ProviderRuntimeStatus {
+    available: boolean;
+    kind: 'available' | 'db_missing' | 'sqlite_missing' | 'sqlite_blocked' | 'query_failed';
+    message?: string;
+}
 /**
  * Incremental reader for session data.
  *
@@ -133,6 +138,10 @@ export interface SessionProviderBase {
     getCurrentUsageSnapshot?(sessionPath: string): TokenUsage | null;
     /** Gets context attribution breakdown from provider data, if available. */
     getContextAttribution?(sessionPath: string): ContextAttribution | null;
+    /** Reports provider runtime readiness for DB-backed providers. */
+    getRuntimeStatus?(): ProviderRuntimeStatus;
+    /** Tests whether a provider can monitor a directory path, including synthetic DB-backed paths. */
+    canMonitorDirectory?(dir: string): boolean;
     /** Release resources. */
     dispose(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",