sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/providers/openCodeDatabase.js

@@ -0,0 +1,419 @@
+/**
+ * Read-only SQLite wrapper for OpenCode's database.
+ * Ported from sidekick-vscode/src/services/providers/OpenCodeDatabase.ts
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execFile, execFileSync } from '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;
+export class OpenCodeDatabase {
+    dbPath;
+    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.runtimeStatus?.kind === 'available')
+            return true;
+        if (this.runtimeStatus &&
+            ['db_missing', 'sqlite_missing', 'sqlite_blocked'].includes(this.runtimeStatus.kind)) {
+            return false;
+        }
+        if (!this.isAvailable()) {
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return false;
+        }
+        try {
+            execFileSync('sqlite3', ['--version'], {
+                encoding: 'utf-8',
+                timeout: 4000,
+                killSignal: 'SIGKILL',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.runtimeStatus = { available: true, kind: 'available' };
+            return true;
+        }
+        catch (error) {
+            this.runtimeStatus = toRuntimeStatus(error);
+            return false;
+        }
+    }
+    close() { }
+    query(sql, params = []) {
+        if (!this.open())
+            return [];
+        let paramIndex = 0;
+        const query = sql.replace(/\?/g, () => {
+            if (paramIndex >= params.length)
+                return '?';
+            const param = params[paramIndex++];
+            if (typeof param === 'number')
+                return Number.isFinite(param) ? String(param) : '0';
+            const escaped = String(param).replace(/'/g, "''");
+            return `'${escaped}'`;
+        });
+        try {
+            const result = execFileSync('sqlite3', ['-json', '-readonly', this.dbPath, query], {
+                encoding: 'utf-8',
+                timeout: 4000,
+                killSignal: 'SIGKILL',
+                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 (error) {
+            this.runtimeStatus = {
+                ...toRuntimeStatus(error, 'query_failed'),
+                // The database and sqlite binary were successfully opened. A failed
+                // query is transient and must not gate the next attempt.
+                available: 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);
+            this.runtimeStatus = { available: true, kind: 'available' };
+            const trimmed = result.trim();
+            return trimmed ? JSON.parse(trimmed) : [];
+        }
+        catch (error) {
+            this.runtimeStatus = toRuntimeStatus(error, 'query_failed');
+            return [];
+        }
+    }
+    queryOne(sql, params = []) {
+        const results = this.query(sql, params);
+        return results[0] ?? null;
+    }
+    findProjectByWorktree(workspacePath) {
+        const normalized = normalizePath(workspacePath);
+        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;
+                }
+            }
+        }
+        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;
+            }
+        }
+        if (!bestProjectId)
+            return null;
+        return this.getAllProjects().find((project) => project.id === bestProjectId) ?? null;
+    }
+    getAllProjects() {
+        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]);
+    }
+    /** Get every root session in one query for global preview enumeration. */
+    getAllSessions() {
+        return this.query('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC');
+    }
+    /** Enumerate root sessions with one non-blocking sqlite3 subprocess. */
+    getAllSessionsAsync() {
+        return this.queryAsync('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC');
+    }
+    /**
+     * Resolve many sessions with non-blocking sqlite3 subprocesses — one per
+     * chunk of ids, so the inlined query stays clear of argv length limits.
+     */
+    async getSessionsByIdsAsync(sessionIds) {
+        const results = [];
+        for (let i = 0; i < sessionIds.length; i += SQL_ID_CHUNK_SIZE) {
+            const chunk = sessionIds.slice(i, i + SQL_ID_CHUNK_SIZE);
+            const placeholders = chunk.map(() => '?').join(', ');
+            results.push(...(await this.queryAsync(`SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE id IN (${placeholders})`, [...chunk])));
+        }
+        return results;
+    }
+    /** Get the most recently updated session for a project (excludes subagent child sessions). */
+    getMostRecentSession(projectId) {
+        return this.queryOne('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 LIMIT 1', [projectId]);
+    }
+    /** Get child sessions (subagents) whose parent_id matches the given session ID. */
+    getChildSessions(parentSessionId) {
+        return this.query('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE parent_id = ? ORDER BY time_created ASC', [parentSessionId]);
+    }
+    getSession(sessionId) {
+        return this.queryOne('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE id = ?', [sessionId]);
+    }
+    getMessagesForSession(sessionId) {
+        return this.query('SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ? ORDER BY time_created ASC', [sessionId]);
+    }
+    /** Get specific messages for a session by message IDs. */
+    getMessagesByIds(sessionId, messageIds) {
+        if (messageIds.length === 0)
+            return [];
+        const placeholders = messageIds.map(() => '?').join(', ');
+        return this.query(`SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ? AND id IN (${placeholders}) ORDER BY time_created ASC`, [sessionId, ...messageIds]);
+    }
+    /** Get messages newer than a given time_updated timestamp (ms epoch). */
+    getMessagesNewerThan(sessionId, afterTimeUpdated) {
+        return this.query('SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ? AND time_updated > ? ORDER BY time_created ASC', [sessionId, afterTimeUpdated]);
+    }
+    /** Get the latest message time_updated for a session. */
+    getLatestMessageTimeUpdated(sessionId) {
+        const row = this.queryOne('SELECT COALESCE(MAX(time_updated), 0) AS maxTimeUpdated FROM message WHERE session_id = ?', [sessionId]);
+        return row?.maxTimeUpdated ?? 0;
+    }
+    /** Get user message IDs that already have an assistant child message. */
+    getProcessedUserMessageIds(sessionId, userMessageIds) {
+        if (userMessageIds.length === 0)
+            return [];
+        const placeholders = userMessageIds.map(() => '?').join(', ');
+        const rows = this.query(`SELECT DISTINCT json_extract(data, '$.parentID') AS parentId
+       FROM message
+       WHERE session_id = ?
+         AND json_extract(data, '$.role') = 'assistant'
+         AND json_extract(data, '$.parentID') IN (${placeholders})`, [sessionId, ...userMessageIds]);
+        return rows
+            .map((r) => r.parentId)
+            .filter((id) => typeof id === 'string' && id.length > 0);
+    }
+    /** Get the latest assistant token usage row with non-zero context signal. */
+    getLatestAssistantContextUsage(sessionId) {
+        return this.queryOne(`SELECT
+         time_created AS timeCreated,
+         COALESCE(json_extract(data, '$.modelID'), 'unknown') AS modelId,
+         COALESCE(json_extract(data, '$.tokens.input'), 0) AS inputTokens,
+         COALESCE(json_extract(data, '$.tokens.output'), 0) AS outputTokens,
+         COALESCE(json_extract(data, '$.tokens.cache.read'), 0) AS cacheReadTokens,
+         COALESCE(json_extract(data, '$.tokens.cache.write'), 0) AS cacheWriteTokens,
+         COALESCE(json_extract(data, '$.tokens.reasoning'), 0) AS reasoningTokens
+       FROM message
+       WHERE session_id = ?
+         AND json_extract(data, '$.role') = 'assistant'
+         AND (
+           COALESCE(json_extract(data, '$.tokens.input'), 0) > 0
+           OR COALESCE(json_extract(data, '$.tokens.output'), 0) > 0
+           OR COALESCE(json_extract(data, '$.tokens.cache.read'), 0) > 0
+           OR COALESCE(json_extract(data, '$.tokens.cache.write'), 0) > 0
+           OR COALESCE(json_extract(data, '$.tokens.reasoning'), 0) > 0
+         )
+       ORDER BY time_created DESC
+       LIMIT 1`, [sessionId]);
+    }
+    /** Get all parts for a message. */
+    getPartsForMessage(messageId) {
+        return this.query('SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE message_id = ? ORDER BY time_created ASC', [messageId]);
+    }
+    /** Get all parts for a set of messages in one query. */
+    getPartsForMessages(sessionId, messageIds) {
+        if (messageIds.length === 0)
+            return [];
+        const placeholders = messageIds.map(() => '?').join(', ');
+        return this.query(`SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ? AND message_id IN (${placeholders}) ORDER BY time_created ASC`, [sessionId, ...messageIds]);
+    }
+    getPartsForSession(sessionId) {
+        return this.query('SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ? ORDER BY time_created ASC', [sessionId]);
+    }
+    /** Get parts newer than a given time_updated timestamp (ms epoch). */
+    getPartsNewerThan(sessionId, afterTimeUpdated) {
+        return this.query('SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ? AND time_updated > ? ORDER BY time_created ASC', [sessionId, afterTimeUpdated]);
+    }
+    /** Get the latest part time_updated for a session. */
+    getLatestPartTimeUpdated(sessionId) {
+        const row = this.queryOne('SELECT COALESCE(MAX(time_updated), 0) AS maxTimeUpdated FROM part WHERE session_id = ?', [sessionId]);
+        return row?.maxTimeUpdated ?? 0;
+    }
+    getProjectSessionStats() {
+        return this.query('SELECT project_id AS projectId, COUNT(*) AS sessionCount, MAX(time_updated) AS maxTimeUpdated FROM session GROUP BY project_id');
+    }
+    /**
+     * Returns assistant messages tagged with the given providerID(s), completed
+     * within `sinceMs`. Used by the z.ai quota accumulator to walk OpenCode's
+     * per-turn token records without re-deriving the session filter.
+     *
+     * Results are ordered oldest-first by `time_created`.
+     */
+    getAssistantMessagesByProviderId(providerIds, sinceMs) {
+        if (providerIds.length === 0)
+            return [];
+        const providerClauses = providerIds
+            .map(() => "json_extract(data, '$.providerID') = ?")
+            .join(' OR ');
+        return this.query(`SELECT
+         time_created AS timeCreated,
+         COALESCE(json_extract(data, '$.modelID'), 'unknown') AS modelId,
+         COALESCE(json_extract(data, '$.providerID'), '') AS providerId,
+         COALESCE(json_extract(data, '$.tokens.input'), 0) AS inputTokens,
+         COALESCE(json_extract(data, '$.tokens.output'), 0) AS outputTokens,
+         COALESCE(json_extract(data, '$.tokens.cache.read'), 0) AS cacheReadTokens,
+         COALESCE(json_extract(data, '$.tokens.cache.write'), 0) AS cacheWriteTokens,
+         COALESCE(json_extract(data, '$.tokens.reasoning'), 0) AS reasoningTokens,
+         json_extract(data, '$.error.message') AS errorMessage,
+         json_extract(data, '$.error.code') AS errorCode
+       FROM message
+       WHERE time_created >= ?
+         AND json_extract(data, '$.role') = 'assistant'
+         AND (${providerClauses})
+       ORDER BY time_created ASC`, [sinceMs, ...providerIds]);
+    }
+    /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */
+    getDbMtime() {
+        try {
+            return fs.statSync(this.dbPath).mtime.getTime();
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+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) {
+    return new Promise((resolve, reject) => {
+        execFile('sqlite3', ['-json', '-readonly', dbPath, query], {
+            encoding: 'utf8',
+            timeout: 4_000,
+            killSignal: 'SIGKILL',
+            maxBuffer: 50 * 1024 * 1024,
+        }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
+function normalizePath(input) {
+    try {
+        return fs.realpathSync(input);
+    }
+    catch {
+        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/esm/providers/rolloutWalker.js

@@ -0,0 +1,252 @@
+/**
+ * One capped walker for Codex rollout files.
+ *
+ * Codex writes `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl`.
+ * Six recursive, uncapped walkers used to exist across the provider and the
+ * quota resolver; this module replaces them with a single walk that caps
+ * depth and file count, visits the newest-dated directories first so a
+ * `limit` can stop early, stats each file exactly once, and returns results
+ * newest first with the size and session id already attached.
+ *
+ * With `limit` or `since`, the early exit is by directory date: a rollout
+ * that was created days ago but is still being written lands in its creation
+ * day's directory, so a very small limit (or a recent `since`) can miss it in
+ * favour of newer-dated, older-modified files. Callers that need exact mtime
+ * order over the whole history omit both (the `maxFiles` cap still applies);
+ * a live session missed this way is picked up by its next watch event.
+ *
+ * The async walker accepts a {@link DirectoryListingCache}: unchanged
+ * directories are then one stat each instead of a readdir plus a stat per
+ * file, which is what makes repeated discovery over a large history cheap.
+ *
+ * @module providers/rolloutWalker
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export const DEFAULT_ROLLOUT_WALK_MAX_DEPTH = 6;
+export const DEFAULT_ROLLOUT_WALK_MAX_FILES = 20_000;
+/** Test if a filename is a Codex rollout file. */
+export function isRolloutFile(filename) {
+    return filename.startsWith('rollout-') && filename.endsWith('.jsonl');
+}
+/**
+ * Extract the session UUID from a rollout filename.
+ * Format: rollout-<timestamp>-<uuid>.jsonl -> <uuid>
+ */
+export function extractRolloutSessionId(filename) {
+    const base = path.basename(filename, '.jsonl');
+    // rollout-YYYYMMDD-HHMMSS-<uuid> or rollout-<timestamp>-<uuid>
+    const parts = base.split('-');
+    // The UUID is typically the last 5 segments (8-4-4-4-12)
+    if (parts.length >= 6) {
+        const possibleUuid = parts.slice(-5).join('-');
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(possibleUuid)) {
+            return possibleUuid;
+        }
+    }
+    // Fallback: use everything after "rollout-"
+    return base.replace(/^rollout-/, '');
+}
+function walkState(options) {
+    const maxFiles = Math.max(0, options.maxFiles ?? DEFAULT_ROLLOUT_WALK_MAX_FILES);
+    const limit = options.limit === undefined ? Infinity : Math.max(0, options.limit);
+    return {
+        results: [],
+        seen: new Set(),
+        cap: Math.min(maxFiles, limit),
+        maxDepth: options.maxDepth ?? DEFAULT_ROLLOUT_WALK_MAX_DEPTH,
+        since: options.since !== undefined && Number.isFinite(options.since) ? options.since : null,
+        sessionId: options.sessionId ? options.sessionId.trim().toLowerCase() : null,
+        includeEmpty: options.includeEmpty ?? false,
+        cache: options.cache ?? null,
+        revalidateRecent: options.revalidateRecent ?? false,
+        stats: options.stats,
+    };
+}
+/** Newest-dated first: directory and file names sort descending. */
+function byNameDescending(a, b) {
+    return b.name.localeCompare(a.name);
+}
+function matchesFilter(state, name) {
+    if (!isRolloutFile(name))
+        return false;
+    return (state.sessionId === null || extractRolloutSessionId(name).toLowerCase() === state.sessionId);
+}
+function record(state, fullPath, name, stat) {
+    if (!state.includeEmpty && stat.size <= 0)
+        return;
+    if (state.since !== null && stat.mtimeMs < state.since)
+        return;
+    if (state.seen.has(fullPath))
+        return;
+    state.seen.add(fullPath);
+    state.results.push({
+        path: fullPath,
+        mtime: new Date(stat.mtimeMs),
+        sizeBytes: stat.size,
+        sessionId: extractRolloutSessionId(name),
+    });
+}
+function finish(state) {
+    return state.results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+}
+/** Slack added to a dated directory's range so a timezone skew cannot prune a live day. */
+const DATE_DIR_SLACK_MS = 24 * 60 * 60_000;
+/**
+ * True when `segments` (the directory names below the root, e.g. `['2026',
+ * '09', '04']`) are all numeric and describe a year, month, or day that ended
+ * more than a day before `since`. Non-numeric names are never pruned.
+ */
+export function isDatedDirectoryBefore(segments, since) {
+    if (segments.length === 0 || segments.length > 3)
+        return false;
+    const numbers = segments.map((segment) => (/^\d+$/.test(segment) ? Number(segment) : NaN));
+    if (numbers.some((value) => !Number.isFinite(value)))
+        return false;
+    const [year, month, day] = numbers;
+    if (year < 1970 || year > 9999)
+        return false;
+    if (segments.length >= 2 && (month < 1 || month > 12))
+        return false;
+    if (segments.length === 3 && (day < 1 || day > 31))
+        return false;
+    const rangeEnd = segments.length === 1
+        ? new Date(year + 1, 0, 1).getTime()
+        : segments.length === 2
+            ? new Date(year, month, 1).getTime()
+            : new Date(year, month - 1, day + 1).getTime();
+    return rangeEnd + DATE_DIR_SLACK_MS < since;
+}
+function visitSync(state, dir, depth, segments) {
+    if (depth > state.maxDepth || state.results.length >= state.cap)
+        return;
+    if (state.since !== null && isDatedDirectoryBefore(segments, state.since))
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    entries.sort(byNameDescending);
+    for (const entry of entries) {
+        if (state.results.length >= state.cap)
+            return;
+        if (!entry.isFile() || !matchesFilter(state, entry.name))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        try {
+            record(state, fullPath, entry.name, fs.statSync(fullPath));
+        }
+        catch {
+            // Skip files that vanish between readdir and stat.
+        }
+    }
+    for (const entry of entries) {
+        if (state.results.length >= state.cap)
+            return;
+        if (entry.isDirectory()) {
+            visitSync(state, path.join(dir, entry.name), depth + 1, [...segments, entry.name]);
+        }
+    }
+}
+/**
+ * Walk one or more `sessions` roots for rollout files, newest first.
+ * Missing or unreadable directories are skipped; paths are deduplicated.
+ */
+export function walkRolloutFiles(roots, options = {}) {
+    const state = walkState(options);
+    for (const root of roots)
+        visitSync(state, root, 0, []);
+    return finish(state);
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+function byStringDescending(a, b) {
+    return b.localeCompare(a);
+}
+async function visitCached(state, cache, dir, depth, segments) {
+    if (depth > state.maxDepth || state.results.length >= state.cap)
+        return;
+    if (state.since !== null && isDatedDirectoryBefore(segments, state.since))
+        return;
+    const listing = await cache.listDirectory(dir, (name) => matchesFilter(state, name), {
+        revalidateRecent: state.revalidateRecent,
+        stats: state.stats,
+    });
+    if (!listing)
+        return;
+    const names = [...listing.files.keys()].sort(byStringDescending);
+    for (const name of names) {
+        if (state.results.length >= state.cap)
+            return;
+        const stat = listing.files.get(name);
+        if (!stat)
+            continue;
+        record(state, path.join(dir, name), name, { size: stat.sizeBytes, mtimeMs: stat.mtimeMs });
+    }
+    await yieldToEventLoop();
+    for (const name of [...listing.subdirectories].sort(byStringDescending)) {
+        if (state.results.length >= state.cap)
+            return;
+        await visitCached(state, cache, path.join(dir, name), depth + 1, [...segments, name]);
+    }
+}
+async function visitAsync(state, dir, depth, segments) {
+    if (depth > state.maxDepth || state.results.length >= state.cap)
+        return;
+    if (state.since !== null && isDatedDirectoryBefore(segments, state.since))
+        return;
+    let entries;
+    try {
+        entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        if (state.stats)
+            state.stats.directoriesListed = (state.stats.directoriesListed ?? 0) + 1;
+    }
+    catch {
+        return;
+    }
+    entries.sort(byNameDescending);
+    let sinceYield = 0;
+    for (const entry of entries) {
+        if (state.results.length >= state.cap)
+            return;
+        if (!entry.isFile() || !matchesFilter(state, entry.name))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        try {
+            const stat = await fs.promises.stat(fullPath);
+            if (state.stats)
+                state.stats.filesStatted = (state.stats.filesStatted ?? 0) + 1;
+            record(state, fullPath, entry.name, stat);
+        }
+        catch {
+            // Skip files that vanish between readdir and stat.
+        }
+        if (++sinceYield >= 200) {
+            sinceYield = 0;
+            await yieldToEventLoop();
+        }
+    }
+    await yieldToEventLoop();
+    for (const entry of entries) {
+        if (state.results.length >= state.cap)
+            return;
+        if (entry.isDirectory()) {
+            await visitAsync(state, path.join(dir, entry.name), depth + 1, [...segments, entry.name]);
+        }
+    }
+}
+/** Async twin of {@link walkRolloutFiles} that yields between directories. */
+export async function walkRolloutFilesAsync(roots, options = {}) {
+    const state = walkState(options);
+    for (const root of roots) {
+        if (state.cache)
+            await visitCached(state, state.cache, root, 0, []);
+        else
+            await visitAsync(state, root, 0, []);
+    }
+    return finish(state);
+}

package/dist/esm/providers/types.js

@@ -0,0 +1,12 @@
+/**
+ * Shared provider interface and types for session providers.
+ *
+ * SessionProviderBase is the expanded interface that both the VS Code extension
+ * and CLI can use. The VS Code extension extends it with vscode.Disposable and
+ * optional VS Code-specific methods.
+ *
+ * SessionProvider is the original simplified interface maintained for backward
+ * compatibility with existing CLI code.
+ */
+/** Stable runtime list for consumers that must enumerate session providers. */
+export { SESSION_PROVIDER_IDS } from '../providerIds';