sidekick-shared 0.24.4 → 0.25.0

package/dist/providers/claudeCode.js

@@ -49,6 +49,7 @@ const path = __importStar(require("path"));
 const string_decoder_1 = require("string_decoder");
 const sessionContext_1 = require("../context/sessionContext");
 const jsonl_1 = require("../parsers/jsonl");
+const diagnostics_1 = require("./diagnostics");
 const sessionPathResolver_1 = require("../parsers/sessionPathResolver");
 const subagentScanner_1 = require("../parsers/subagentScanner");
 const modelContext_1 = require("../modelContext");
@@ -88,6 +89,42 @@ function extractSearchableText(event) {
     }
     return '';
 }
+function extractClaudeLabelFromPrefix(chunk) {
+    for (const line of chunk.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const event = JSON.parse(trimmed);
+            if (event.type !== 'user')
+                continue;
+            const content = event.message?.content;
+            if (!content)
+                continue;
+            let text = null;
+            if (typeof content === 'string') {
+                text = content.trim();
+            }
+            else if (Array.isArray(content)) {
+                const textBlock = content.find((block) => isTypedBlock(block) &&
+                    block.type === 'text' &&
+                    typeof block.text === 'string' &&
+                    block.text.trim().length > 0);
+                if (textBlock && isTypedBlock(textBlock) && typeof textBlock.text === 'string') {
+                    text = textBlock.text.trim();
+                }
+            }
+            if (text) {
+                const compact = text.replace(/\s+/g, ' ');
+                return compact.length > 60 ? compact.substring(0, 57) + '...' : compact;
+            }
+        }
+        catch {
+            // Skip malformed lines.
+        }
+    }
+    return null;
+}
 /**
  * Incremental JSONL reader for Claude Code session files.
  *
@@ -234,8 +271,12 @@ function normalizeClaudeUsage(event) {
 class ClaudeCodeProvider {
     id = 'claude-code';
     displayName = 'Claude Code';
+    diagnostics;
     /** Runtime-reported context window limit (overrides static map when set). */
     dynamicContextWindowLimit = null;
+    constructor(options = {}) {
+        this.diagnostics = new diagnostics_1.ProviderDiagnosticTracker(this.id, options);
+    }
     // --- Path resolution ---
     getSessionDirectory(workspacePath) {
         return (0, sessionPathResolver_1.getSessionDirectory)(workspacePath);
@@ -250,6 +291,43 @@ class ClaudeCodeProvider {
     findAllSessions(workspacePath) {
         return (0, sessionPathResolver_1.findAllSessions)(workspacePath);
     }
+    findSessionById(workspacePath, sessionId) {
+        const normalizedId = sessionId.trim();
+        if (!normalizedId || path.basename(normalizedId) !== normalizedId)
+            return null;
+        try {
+            const directories = new Set();
+            directories.add(this.getSessionDirectory(workspacePath));
+            const discovered = this.discoverSessionDirectory(workspacePath);
+            if (discovered)
+                directories.add(discovered);
+            for (const folder of this.getAllProjectFolders(workspacePath))
+                directories.add(folder.dir);
+            for (const directory of directories) {
+                const direct = path.join(directory, `${normalizedId}.jsonl`);
+                try {
+                    if (fs.statSync(direct).isFile()) {
+                        this.diagnostics.available('findSessionById');
+                        return direct;
+                    }
+                }
+                catch {
+                    // Continue with directory-shaped lookup for worktree layouts.
+                }
+                const match = this.findSessionsInDirectory(directory).find((candidate) => this.getSessionId(candidate) === normalizedId);
+                if (match) {
+                    this.diagnostics.available('findSessionById');
+                    return match;
+                }
+            }
+            this.recordHomeStatus('findSessionById');
+            return null;
+        }
+        catch {
+            this.recordHomeStatus('findSessionById');
+            return null;
+        }
+    }
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath) {
         return this.findAllSessions(workspacePath);
@@ -260,6 +338,97 @@ class ClaudeCodeProvider {
     getAllProjectFolders(workspacePath) {
         return (0, sessionPathResolver_1.getAllProjectFolders)(workspacePath);
     }
+    listAllSessionFiles() {
+        const results = [];
+        const seen = new Set();
+        for (const folder of this.getAllProjectFolders()) {
+            for (const sessionPath of this.findSessionsInDirectory(folder.dir)) {
+                if (seen.has(sessionPath))
+                    continue;
+                seen.add(sessionPath);
+                try {
+                    results.push({ path: sessionPath, mtime: fs.statSync(sessionPath).mtime });
+                }
+                catch {
+                    // Skip files that vanish between listing and stat.
+                }
+            }
+        }
+        this.recordHomeStatus('listAllSessionFiles');
+        return results;
+    }
+    async listSessionFilesAsync(workspacePath) {
+        const projectsRoot = this.getProjectsBaseDir();
+        let projectEntries = [];
+        try {
+            projectEntries = await fs.promises.readdir(projectsRoot, { withFileTypes: true });
+        }
+        catch {
+            this.recordHomeStatus('listSessionFilesAsync');
+            return [];
+        }
+        const encodedWorkspace = workspacePath ? (0, sessionPathResolver_1.encodeWorkspacePath)(workspacePath).toLowerCase() : null;
+        const workspaceBasename = workspacePath
+            ? path
+                .basename(workspacePath)
+                .replace(/[^a-zA-Z0-9]/g, '-')
+                .toLowerCase()
+            : null;
+        const directories = [];
+        for (const entry of projectEntries) {
+            const directory = path.join(projectsRoot, entry.name);
+            try {
+                const stat = entry.isDirectory() ? null : await fs.promises.stat(directory);
+                if (!entry.isDirectory() && !stat?.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const name = entry.name.toLowerCase();
+            if (encodedWorkspace &&
+                name !== encodedWorkspace &&
+                !name.startsWith(`${encodedWorkspace}-`) &&
+                name !== workspaceBasename &&
+                !name.endsWith(`-${workspaceBasename}`)) {
+                continue;
+            }
+            directories.push(directory);
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        const results = [];
+        for (const directory of directories) {
+            let entries = [];
+            try {
+                entries = await fs.promises.readdir(directory, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isFile() || !this.isSessionFile(entry.name))
+                    continue;
+                const sessionPath = path.join(directory, entry.name);
+                try {
+                    const stat = await fs.promises.stat(sessionPath);
+                    if (stat.size > 0) {
+                        results.push({
+                            path: sessionPath,
+                            mtime: stat.mtime,
+                            sizeBytes: stat.size,
+                            sessionId: this.getSessionId(sessionPath),
+                        });
+                    }
+                }
+                catch {
+                    // Skip files that vanish between discovery and stat.
+                }
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        }
+        this.recordHomeStatus('listSessionFilesAsync');
+        return results.sort((left, right) => right.mtime.getTime() - left.mtime.getTime());
+    }
     // --- File identification ---
     isSessionFile(filename) {
         return filename.endsWith('.jsonl');
@@ -278,50 +447,32 @@ class ClaudeCodeProvider {
             fs.closeSync(fd);
             if (bytesRead === 0)
                 return null;
-            const chunk = buffer.toString('utf-8', 0, bytesRead);
-            const lines = chunk.split('\n');
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed)
-                    continue;
-                try {
-                    const event = JSON.parse(trimmed);
-                    if (event.type !== 'user')
-                        continue;
-                    const content = event.message?.content;
-                    if (!content)
-                        continue;
-                    let text = null;
-                    if (typeof content === 'string') {
-                        text = content.trim();
-                    }
-                    else if (Array.isArray(content)) {
-                        const textBlock = content.find((block) => isTypedBlock(block) &&
-                            block.type === 'text' &&
-                            typeof block.text === 'string' &&
-                            block.text.trim().length > 0);
-                        if (textBlock && isTypedBlock(textBlock) && typeof textBlock.text === 'string') {
-                            text = textBlock.text.trim();
-                        }
-                    }
-                    if (text && text.length > 0) {
-                        text = text.replace(/\s+/g, ' ');
-                        if (text.length > 60) {
-                            text = text.substring(0, 57) + '...';
-                        }
-                        return text;
-                    }
-                }
-                catch {
-                    // Skip malformed lines
-                }
-            }
-            return null;
+            return extractClaudeLabelFromPrefix(buffer.toString('utf-8', 0, bytesRead));
         }
         catch {
             return null;
         }
     }
+    async extractSessionLabelsAsync(sessionPaths) {
+        const results = new Map();
+        for (const sessionPath of sessionPaths) {
+            let handle = null;
+            try {
+                handle = await fs.promises.open(sessionPath, 'r');
+                const buffer = Buffer.alloc(8192);
+                const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+                results.set(sessionPath, extractClaudeLabelFromPrefix(buffer.toString('utf8', 0, bytesRead)));
+            }
+            catch {
+                results.set(sessionPath, null);
+            }
+            finally {
+                await handle?.close().catch(() => undefined);
+            }
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        return results;
+    }
     // --- Data reading ---
     createReader(sessionPath) {
         return new ClaudeCodeReader(sessionPath);
@@ -379,6 +530,9 @@ class ClaudeCodeProvider {
     getProjectsBaseDir() {
         return path.join(os.homedir(), '.claude', 'projects');
     }
+    getWatchRoots() {
+        return [this.getProjectsBaseDir()];
+    }
     // --- Stats ---
     readSessionStats(sessionPath) {
         const sessionId = path.basename(sessionPath, '.jsonl');
@@ -473,6 +627,22 @@ class ClaudeCodeProvider {
         return (0, sessionContext_1.readSessionContextSnapshot)(this, sessionPath, options);
     }
     // --- Optional methods ---
+    getRuntimeStatus() {
+        try {
+            fs.accessSync(this.getProjectsBaseDir(), fs.constants.R_OK);
+            return { available: true, kind: 'available' };
+        }
+        catch {
+            return {
+                available: false,
+                kind: 'home_unavailable',
+                message: 'Claude Code session home is unavailable.',
+            };
+        }
+    }
+    getLastOperationStatus() {
+        return this.diagnostics.getLastOperationStatus();
+    }
     getContextWindowLimit(modelId) {
         if (this.dynamicContextWindowLimit)
             return this.dynamicContextWindowLimit;
@@ -534,5 +704,18 @@ class ClaudeCodeProvider {
     dispose() {
         this.dynamicContextWindowLimit = null;
     }
+    recordHomeStatus(operation) {
+        const status = this.getRuntimeStatus();
+        if (status.available) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        this.diagnostics.degraded(operation, status, {
+            kind: 'home_unavailable',
+            severity: 'info',
+            phase: 'enumerate',
+            message: status.message ?? 'Claude Code session home is unavailable.',
+        });
+    }
 }
 exports.ClaudeCodeProvider = ClaudeCodeProvider;

package/dist/providers/codex.d.ts

@@ -9,9 +9,29 @@
  * Ported from sidekick-vscode/src/services/providers/CodexSessionProvider.ts
  */
 import type { ReadSessionContextSnapshotOptions, SessionContextSnapshot } from '../context/sessionContext';
-import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileStats, ProviderId } from './types';
+import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileInfo, SessionFileStats, ProviderId, ProviderOperationStatus, ProviderRuntimeStatus, SessionProviderOptions } from './types';
 import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
 import type { CodexRateLimits } from '../types/codex';
+export interface FindCodexRolloutFileOptions {
+    /**
+     * Codex home whose `sessions/` subtree to search. Defaults to every
+     * monitored home: `$CODEX_HOME` if set, else `~/.codex`, plus managed
+     * profile homes that recorded sessions.
+     */
+    codexHome?: string;
+}
+/**
+ * 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).
+ */
+export declare function findCodexRolloutFile(sessionId: string, options?: FindCodexRolloutFileOptions): string | null;
 /**
  * Session provider for Codex CLI.
  *
@@ -23,23 +43,39 @@ export declare class CodexProvider implements SessionProviderBase {
     readonly displayName = "Codex CLI";
     private db;
     private dbInitialized;
+    private dbStatus;
+    private readonly diagnostics;
     private dynamicContextWindowLimit;
     private lastRateLimitsData;
     private lastTokenUsageData;
+    constructor(options?: SessionProviderOptions);
     /** Lazy-initialize 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 silently disable their file fallbacks.
+     */
+    private adoptDbIfAvailable;
+    getRuntimeStatus(): ProviderRuntimeStatus;
+    getLastOperationStatus(): ProviderOperationStatus;
     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[];
+    listAllSessionFiles(): SessionFileInfo[];
+    listSessionFilesAsync(workspacePath?: string): Promise<SessionFileInfo[]>;
     getAllProjectFolders(workspacePath?: string): ProjectFolderInfo[];
     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[];
     /**
@@ -48,6 +84,7 @@ export declare class CodexProvider implements SessionProviderBase {
     private buildSubagentStats;
     searchInSession(sessionPath: string, query: string, maxResults: number): SearchHit[];
     getProjectsBaseDir(): string;
+    getWatchRoots(): string[];
     readSessionStats(sessionPath: string): SessionFileStats;
     readSessionContextSnapshot(sessionPath: string, options?: ReadSessionContextSnapshotOptions): SessionContextSnapshot;
     getContextWindowLimit(modelId?: string): number;
@@ -56,4 +93,5 @@ export declare class CodexProvider implements SessionProviderBase {
     /** Get the last rate limits data received from token_count events. */
     getLastRateLimits(): CodexRateLimits | null;
     dispose(): void;
+    private recordDatabaseFallback;
 }