sidekick-shared 0.24.4 → 0.25.0

package/dist/providers/codex.js

@@ -44,6 +44,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodexProvider = void 0;
+exports.findCodexRolloutFile = findCodexRolloutFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const string_decoder_1 = require("string_decoder");
@@ -52,6 +53,7 @@ const sessionContext_1 = require("../context/sessionContext");
 const codexParser_1 = require("../parsers/codexParser");
 const codexDatabase_1 = require("./codexDatabase");
 const codexProfiles_1 = require("../codexProfiles");
+const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
 const observedContextWindows_1 = require("../observedContextWindows");
 const usageNormalization_1 = require("../usageNormalization");
@@ -164,6 +166,94 @@ function findRolloutFilesInConfiguredHomes() {
     }
     return results;
 }
+async function findRolloutFilesAsync(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...(await findRolloutFilesAsync(fullPath)));
+        }
+        else if (entry.isFile() && isRolloutFile(entry.name)) {
+            try {
+                const stats = await fs.promises.stat(fullPath);
+                if (stats.size > 0) {
+                    results.push({
+                        path: fullPath,
+                        mtime: stats.mtime,
+                        sizeBytes: stats.size,
+                        sessionId: extractSessionId(entry.name),
+                    });
+                }
+            }
+            catch {
+                // Skip inaccessible files.
+            }
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return results;
+}
+/**
+ * Locates the rollout file for a Codex session id by walking
+ * `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`.
+ *
+ * Filename-only match, case-insensitive on the id — no file contents are read
+ * and files are only stat'ed once their name matches, so the walk stays cheap
+ * even over a large history. When the same id exists in more than one home,
+ * the most recently modified copy wins. Returns `null` for an unknown, empty,
+ * or whitespace id. Consumers who want the database's answer instead can query
+ * the already-public `CodexDatabase` (requires the external `sqlite3` binary).
+ */
+function findCodexRolloutFile(sessionId, options = {}) {
+    const normalizedId = sessionId.trim().toLowerCase();
+    if (!normalizedId)
+        return null;
+    const sessionsDirs = options.codexHome
+        ? [path.join(options.codexHome, 'sessions')]
+        : getSessionsDirs();
+    let best = null;
+    for (const dir of sessionsDirs) {
+        for (const candidate of findRolloutFilesById(dir, normalizedId)) {
+            if (!best || candidate.mtimeMs > best.mtimeMs)
+                best = candidate;
+        }
+    }
+    return best?.path ?? null;
+}
+function findRolloutFilesById(dir, normalizedId) {
+    const results = [];
+    try {
+        if (!fs.existsSync(dir))
+            return results;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...findRolloutFilesById(fullPath, normalizedId));
+            }
+            else if (entry.isFile() &&
+                isRolloutFile(entry.name) &&
+                extractSessionId(entry.name).toLowerCase() === normalizedId) {
+                try {
+                    results.push({ path: fullPath, mtimeMs: fs.statSync(fullPath).mtimeMs });
+                }
+                catch {
+                    // Skip files that vanish between readdir and stat.
+                }
+            }
+        }
+    }
+    catch {
+        // Skip inaccessible directories.
+    }
+    return results;
+}
 /** Pick the best sessions directory for UI/search entrypoints. */
 function getSessionsDir() {
     const dirs = getSessionsDirs();
@@ -243,6 +333,41 @@ function readSessionMeta(rolloutPath) {
     }
     return null;
 }
+async function readSessionMetaAsync(rolloutPath) {
+    // Mirrors readSessionMeta()/readFirstLines(): chunk-read until the first
+    // line is complete under the same 256 KiB cap — session_meta carries
+    // `instructions` and can far exceed a single chunk.
+    const maxBytes = 256 * 1024;
+    const chunkSize = 64 * 1024;
+    let handle = null;
+    try {
+        handle = await fs.promises.open(rolloutPath, 'r');
+        const chunks = [];
+        let totalRead = 0;
+        let newlineFound = false;
+        while (totalRead < maxBytes && !newlineFound) {
+            const buffer = Buffer.alloc(Math.min(chunkSize, maxBytes - totalRead));
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, totalRead);
+            if (bytesRead === 0)
+                break;
+            const chunk = buffer.subarray(0, bytesRead);
+            chunks.push(chunk);
+            totalRead += bytesRead;
+            newlineFound = chunk.includes(0x0a);
+        }
+        const firstLine = Buffer.concat(chunks).toString('utf8').split('\n', 1)[0]?.trim();
+        if (!firstLine)
+            return null;
+        const parsed = JSON.parse(firstLine);
+        return parsed.type === 'session_meta' ? parsed.payload : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
 /** Read the CWD from a rollout file's session_meta. Cached. */
 const cwdCache = new Map();
 function readSessionCwd(rolloutPath) {
@@ -254,6 +379,16 @@ function readSessionCwd(rolloutPath) {
     cwdCache.set(rolloutPath, cwd);
     return cwd;
 }
+/** Async twin of readSessionCwd, sharing its cache so repeat listings do no content reads. */
+async function readSessionCwdAsync(rolloutPath) {
+    const cached = cwdCache.get(rolloutPath);
+    if (cached !== undefined)
+        return cached;
+    const meta = await readSessionMetaAsync(rolloutPath);
+    const cwd = meta?.cwd || null;
+    cwdCache.set(rolloutPath, cwd);
+    return cwd;
+}
 /** Check if a session's CWD matches a workspace path. */
 function cwdMatches(sessionCwd, workspacePath) {
     const normalizedSession = normalizePath(sessionCwd);
@@ -278,48 +413,65 @@ function normalizePath(input) {
  */
 function extractFirstUserMessage(rolloutPath) {
     try {
-        const lines = readFirstLines(rolloutPath, 20);
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const parsed = JSON.parse(trimmed);
-                // Check response_item with user message
-                if (parsed.type === 'response_item') {
-                    const payload = parsed.payload;
-                    if (payload.role === 'user') {
-                        const content = payload.content;
-                        if (typeof content === 'string' && content.trim() && !isSystemInjection(content)) {
-                            return truncate(content, 60);
-                        }
-                        if (Array.isArray(content)) {
-                            for (const part of content) {
-                                const p = part;
-                                if (p.text?.trim() && !isSystemInjection(p.text)) {
-                                    return truncate(p.text, 60);
-                                }
+        return extractFirstUserMessageFromLines(readFirstLines(rolloutPath, 20));
+    }
+    catch {
+        return null;
+    }
+}
+function extractFirstUserMessageFromLines(lines) {
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            // Check response_item with user message
+            if (parsed.type === 'response_item') {
+                const payload = parsed.payload;
+                if (payload.role === 'user') {
+                    const content = payload.content;
+                    if (typeof content === 'string' && content.trim() && !isSystemInjection(content)) {
+                        return truncate(content, 60);
+                    }
+                    if (Array.isArray(content)) {
+                        for (const part of content) {
+                            const p = part;
+                            if (p.text?.trim() && !isSystemInjection(p.text)) {
+                                return truncate(p.text, 60);
                             }
                         }
                     }
                 }
-                // Check event_msg with user_message
-                if (parsed.type === 'event_msg') {
-                    const payload = parsed.payload;
-                    if (payload.type === 'user_message' && payload.message?.trim()) {
-                        return truncate(payload.message, 60);
-                    }
-                }
             }
-            catch {
-                // Skip malformed lines
+            // Check event_msg with user_message
+            if (parsed.type === 'event_msg') {
+                const payload = parsed.payload;
+                if (payload.type === 'user_message' && payload.message?.trim()) {
+                    return truncate(payload.message, 60);
+                }
             }
         }
-        return null;
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return null;
+}
+async function extractFirstUserMessageAsync(rolloutPath) {
+    let handle = null;
+    try {
+        handle = await fs.promises.open(rolloutPath, 'r');
+        const buffer = Buffer.alloc(256 * 1024);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        return extractFirstUserMessageFromLines(buffer.toString('utf8', 0, bytesRead).split('\n').slice(0, 20));
     }
     catch {
         return null;
     }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
 }
 /** Extract searchable text from a rollout line. */
 function extractSearchableText(line) {
@@ -606,9 +758,14 @@ class CodexProvider {
     displayName = 'Codex CLI';
     db = null;
     dbInitialized = false;
+    dbStatus = { available: false, kind: 'db_missing' };
+    diagnostics;
     dynamicContextWindowLimit = null;
     lastRateLimitsData = null;
     lastTokenUsageData = null;
+    constructor(options = {}) {
+        this.diagnostics = new diagnostics_1.ProviderDiagnosticTracker(this.id, options);
+    }
     // --- Database ---
     /** Lazy-initialize database connection. */
     ensureDb() {
@@ -620,8 +777,34 @@ class CodexProvider {
         if (db.isAvailable() && db.open()) {
             this.db = db;
         }
+        if (typeof db.getRuntimeStatus === 'function') {
+            this.dbStatus = db.getRuntimeStatus();
+        }
         return this.db;
     }
+    async ensureDbAsync() {
+        if (this.db)
+            return this.db;
+        return new codexDatabase_1.CodexDatabase(getCodexHome());
+    }
+    /**
+     * 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 silently disable their file fallbacks.
+     */
+    adoptDbIfAvailable(db) {
+        if (this.db || !db.getRuntimeStatus().available)
+            return;
+        this.db = db;
+        this.dbInitialized = true;
+    }
+    getRuntimeStatus() {
+        const db = this.ensureDb();
+        return db && typeof db.getRuntimeStatus === 'function' ? db.getRuntimeStatus() : this.dbStatus;
+    }
+    getLastOperationStatus() {
+        return this.diagnostics.getLastOperationStatus();
+    }
     // --- Path resolution ---
     getSessionDirectory(workspacePath) {
         // Codex doesn't use workspace-encoded directories like Claude Code.
@@ -631,10 +814,13 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path) {
+                this.recordDatabaseFallback('getSessionDirectory', true);
                 return path.dirname(thread.rollout_path);
             }
         }
-        return getSessionsDir();
+        const directory = getSessionsDir();
+        this.recordDatabaseFallback('getSessionDirectory', true);
+        return directory;
     }
     discoverSessionDirectory(workspacePath) {
         // DB: find latest rollout directory for this workspace
@@ -642,23 +828,29 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path && fs.existsSync(thread.rollout_path)) {
+                this.recordDatabaseFallback('discoverSessionDirectory', true);
                 return path.dirname(thread.rollout_path);
             }
         }
         // File scan: look for any rollout file whose session_meta.cwd matches
         const files = findRolloutFilesInConfiguredHomes();
-        if (files.length === 0)
+        if (files.length === 0) {
+            this.recordDatabaseFallback('discoverSessionDirectory', true);
             return null;
+        }
         // Sort by mtime descending
         files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         for (const file of files) {
             const meta = readSessionMeta(file.path);
             if (meta && cwdMatches(meta.cwd, workspacePath)) {
+                this.recordDatabaseFallback('discoverSessionDirectory', true);
                 return path.dirname(file.path);
             }
         }
         // Fallback: return the most relevant base sessions dir if one exists
-        return getSessionsDir();
+        const directory = getSessionsDir();
+        this.recordDatabaseFallback('discoverSessionDirectory', true);
+        return directory;
     }
     // --- Session discovery ---
     findActiveSession(workspacePath) {
@@ -667,6 +859,7 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path && fs.existsSync(thread.rollout_path)) {
+                this.recordDatabaseFallback('findActiveSession', true);
                 return thread.rollout_path;
             }
         }
@@ -676,9 +869,11 @@ class CodexProvider {
         for (const file of files) {
             const meta = readSessionMeta(file.path);
             if (meta && cwdMatches(meta.cwd, workspacePath)) {
+                this.recordDatabaseFallback('findActiveSession', true);
                 return file.path;
             }
         }
+        this.recordDatabaseFallback('findActiveSession', true);
         return null;
     }
     findAllSessions(workspacePath) {
@@ -689,18 +884,33 @@ class CodexProvider {
             const dbPaths = threads
                 .filter((t) => t.rollout_path && fs.existsSync(t.rollout_path))
                 .map((t) => t.rollout_path);
-            if (dbPaths.length > 0)
+            if (dbPaths.length > 0) {
+                this.recordDatabaseFallback('findAllSessions', true);
                 return dbPaths;
+            }
         }
         // File scan
         const files = findRolloutFilesInConfiguredHomes();
         files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return files
+        const sessions = files
             .filter((f) => {
             const meta = readSessionMeta(f.path);
             return meta && cwdMatches(meta.cwd, workspacePath);
         })
             .map((f) => f.path);
+        this.recordDatabaseFallback('findAllSessions', true);
+        return sessions;
+    }
+    findSessionById(_workspacePath, sessionId) {
+        try {
+            const found = findCodexRolloutFile(sessionId);
+            this.recordDatabaseFallback('findSessionById', true);
+            return found;
+        }
+        catch {
+            this.recordDatabaseFallback('findSessionById', false);
+            return null;
+        }
     }
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath) {
@@ -711,6 +921,30 @@ class CodexProvider {
         files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         return files.map((f) => f.path);
     }
+    listAllSessionFiles() {
+        const files = findRolloutFilesInConfiguredHomes();
+        this.recordDatabaseFallback('listAllSessionFiles', true);
+        return files;
+    }
+    async listSessionFilesAsync(workspacePath) {
+        const seen = new Set();
+        const results = [];
+        for (const sessionsDir of getSessionsDirs()) {
+            for (const file of await findRolloutFilesAsync(sessionsDir)) {
+                if (seen.has(file.path))
+                    continue;
+                seen.add(file.path);
+                if (workspacePath) {
+                    const cwd = await readSessionCwdAsync(file.path);
+                    if (!cwd || !cwdMatches(cwd, workspacePath))
+                        continue;
+                    file.workspacePath = cwd;
+                }
+                results.push(file);
+            }
+        }
+        return results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    }
     getAllProjectFolders(workspacePath) {
         const folders = [];
         const seenCwds = new Map();
@@ -765,6 +999,7 @@ class CodexProvider {
             }
             return b.lastModified.getTime() - a.lastModified.getTime();
         });
+        this.recordDatabaseFallback('getAllProjectFolders', true);
         return folders;
     }
     // --- File identification ---
@@ -784,13 +1019,43 @@ class CodexProvider {
         if (db) {
             const sessionId = this.getSessionId(sessionPath);
             const thread = db.getThread(sessionId);
-            if (thread?.title)
+            if (thread?.title) {
+                this.recordDatabaseFallback('extractSessionLabel', true);
                 return truncate(thread.title, 60);
-            if (thread?.first_user_message)
+            }
+            if (thread?.first_user_message) {
+                this.recordDatabaseFallback('extractSessionLabel', true);
                 return truncate(thread.first_user_message, 60);
+            }
         }
         // File fallback: parse first user message
-        return extractFirstUserMessage(sessionPath);
+        const label = extractFirstUserMessage(sessionPath);
+        this.recordDatabaseFallback('extractSessionLabel', true);
+        return label;
+    }
+    async extractSessionLabelsAsync(sessionPaths) {
+        const results = new Map();
+        const byId = new Map(sessionPaths.map((sessionPath) => [this.getSessionId(sessionPath), sessionPath]));
+        const db = await this.ensureDbAsync();
+        const threads = await db.getThreadsByIdsAsync([...byId.keys()]);
+        for (const thread of threads) {
+            const sessionPath = byId.get(thread.id);
+            if (!sessionPath)
+                continue;
+            const label = thread.title ?? thread.first_user_message;
+            if (label)
+                results.set(sessionPath, truncate(label, 60));
+        }
+        this.dbStatus = db.getRuntimeStatus();
+        this.adoptDbIfAvailable(db);
+        for (const sessionPath of sessionPaths) {
+            if (!results.has(sessionPath)) {
+                results.set(sessionPath, await extractFirstUserMessageAsync(sessionPath));
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        }
+        this.recordDatabaseFallback('extractSessionLabelsAsync', true);
+        return results;
     }
     // --- Data reading ---
     createReader(sessionPath) {
@@ -957,6 +1222,9 @@ class CodexProvider {
     getProjectsBaseDir() {
         return getSessionsDir();
     }
+    getWatchRoots() {
+        return getSessionsDirs();
+    }
     // --- Stats ---
     readSessionStats(sessionPath) {
         const sessionId = extractSessionId(path.basename(sessionPath));
@@ -1036,9 +1304,28 @@ class CodexProvider {
         this.db?.close();
         this.db = null;
         this.dbInitialized = false;
+        this.dbStatus = { available: false, kind: 'db_missing' };
         this.dynamicContextWindowLimit = null;
         this.lastRateLimitsData = null;
         this.lastTokenUsageData = null;
     }
+    recordDatabaseFallback(operation, usable) {
+        if (!this.dbInitialized) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        const status = this.getRuntimeStatus();
+        const diagnostic = (0, diagnostics_1.diagnosticFromRuntimeStatus)(this.id, 'query', status);
+        if (!diagnostic) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        this.diagnostics.degraded(operation, status, {
+            kind: diagnostic.kind,
+            severity: diagnostic.severity,
+            phase: diagnostic.phase,
+            message: diagnostic.message,
+        }, usable);
+    }
 }
 exports.CodexProvider = CodexProvider;

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. */