@ccpocket-base-auth/bridge 1.26.0

package/dist/sessions-index.js

@@ -0,0 +1,1767 @@
+import { readdir, readFile, writeFile, appendFile, stat, open } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { basename, join } from "node:path";
+import { homedir } from "node:os";
+function createRecentSessionsPerfStats() {
+    return {
+        claudeProjectDirs: 0,
+        claudeIndexDirs: 0,
+        claudeJsonlOnlyDirs: 0,
+        claudeIndexEntries: 0,
+        claudeJsonlFilesTotal: 0,
+        claudeJsonlFilesExcluded: 0,
+        claudeJsonlFilesRead: 0,
+        claudeJsonlEntries: 0,
+        codexFilesTotal: 0,
+        codexFilesRead: 0,
+        codexEntries: 0,
+        claudeNamedOnlyFastPathUsed: false,
+        counts: {
+            beforeArchive: 0,
+            afterArchive: 0,
+            afterProvider: 0,
+            afterNamedOnly: 0,
+            afterSearch: 0,
+            returned: 0,
+        },
+    };
+}
+function markDuration(durations, key, startedAt) {
+    const elapsedMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+    durations[key] = elapsedMs;
+}
+function shouldLogRecentSessionsPerf() {
+    const v = process.env.BRIDGE_RECENT_SESSIONS_PROFILE;
+    return v === "1" || v === "true";
+}
+function logRecentSessionsPerf(options, durations, stats) {
+    if (!shouldLogRecentSessionsPerf())
+        return;
+    const projectPath = options.projectPath;
+    const projectPathLabel = projectPath
+        ? projectPath.length > 72
+            ? `${projectPath.slice(0, 69)}...`
+            : projectPath
+        : "";
+    const payload = {
+        options: {
+            limit: options.limit ?? 20,
+            offset: options.offset ?? 0,
+            projectPath: projectPathLabel || undefined,
+            provider: options.provider ?? "all",
+            namedOnly: options.namedOnly ?? false,
+            searchQuery: options.searchQuery ? "<set>" : "<none>",
+            archivedSessionIds: options.archivedSessionIds?.size ?? 0,
+        },
+        durationsMs: Object.fromEntries(Object.entries(durations).map(([k, v]) => [k, Number(v.toFixed(1))])),
+        stats,
+    };
+    console.info(`[recent-sessions][perf] ${JSON.stringify(payload)}`);
+}
+/** Convert a filesystem path to Claude's project directory slug (e.g. /foo/bar → -foo-bar). */
+export function pathToSlug(p) {
+    return p.replaceAll("/", "-").replaceAll("_", "-");
+}
+/**
+ * Normalize a worktree cwd back to the main project path.
+ * e.g. /path/to/project-worktrees/branch → /path/to/project
+ */
+export function normalizeWorktreePath(p) {
+    const match = p.match(/^(.+)-worktrees\/[^/]+$/);
+    return match?.[1] ?? p;
+}
+/**
+ * Check if a directory slug represents a worktree directory for a given project slug.
+ * e.g. "-Users-x-proj-worktrees-branch" is a worktree dir for "-Users-x-proj".
+ */
+export function isWorktreeSlug(dirSlug, projectSlug) {
+    return dirSlug.startsWith(projectSlug + "-worktrees-");
+}
+/** Concurrency limit for parallel file reads to avoid fd exhaustion. */
+const PARALLEL_FILE_READ_LIMIT = 32;
+/** Head/Tail byte sizes for partial JSONL reads. */
+const HEAD_BYTES = 16384; // 16KB — covers first user entry + metadata
+const TAIL_BYTES = 8192; // 8KB — covers last entries for modified/lastPrompt
+/**
+ * Run async tasks with a concurrency limit.
+ * Returns results in the same order as the input tasks.
+ */
+async function parallelMap(items, concurrency, fn) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            const i = nextIndex++;
+            results[i] = await fn(items[i]);
+        }
+    }
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+// Regexes for fast field extraction without JSON.parse
+const RE_TYPE_USER = /"type"\s*:\s*"user"/;
+const RE_TYPE_ASSISTANT = /"type"\s*:\s*"assistant"/;
+const RE_TIMESTAMP = /"timestamp"\s*:\s*"([^"]+)"/;
+const RE_GIT_BRANCH = /"gitBranch"\s*:\s*"([^"]+)"/;
+const RE_CWD = /"cwd"\s*:\s*"([^"]+)"/;
+const RE_IS_SIDECHAIN = /"isSidechain"\s*:\s*true/;
+const RE_TYPE_CUSTOM_TITLE = /"type"\s*:\s*"custom-title"/;
+const RE_CUSTOM_TITLE = /"customTitle"\s*:\s*"([^"]+)"/;
+/**
+ * Detect system-injected messages that should be skipped when determining
+ * the user's first/last prompt text (e.g. local-command-caveat, stderr/stdout
+ * captures, team notifications, skill loading).
+ */
+const RE_SYSTEM_INJECTED = /^<(?:local-command-caveat|local-command-std(?:err|out)|task-notification|teammate-message|bash-(?:input|stdout))>/;
+function isSystemInjectedText(text) {
+    return RE_SYSTEM_INJECTED.test(text) || text.startsWith("Base directory for this skill:");
+}
+/** Extract user prompt text from a parsed JSONL entry. */
+function extractUserPromptText(entry) {
+    const message = entry.message;
+    if (!message?.content)
+        return "";
+    if (typeof message.content === "string")
+        return message.content;
+    if (Array.isArray(message.content)) {
+        const textBlock = message.content.find((c) => c.type === "text" && c.text);
+        return textBlock?.text ?? "";
+    }
+    return "";
+}
+function parseFromChunks(sessionId, head, tail) {
+    let firstPrompt = "";
+    let lastPrompt = "";
+    let created = "";
+    let modified = "";
+    let gitBranch = "";
+    let projectPath = "";
+    let customTitle = "";
+    let isSidechain = false;
+    let hasAnyMessage = false;
+    let headFoundFirstPrompt = false;
+    let headFoundProjectPath = false;
+    let headFoundGitBranch = false;
+    // --- Scan head lines ---
+    const headLines = head.split("\n");
+    for (const line of headLines) {
+        if (!line.trim())
+            continue;
+        // Extract custom-title (typically the first line in the JSONL)
+        if (!customTitle && RE_TYPE_CUSTOM_TITLE.test(line)) {
+            const ctMatch = line.match(RE_CUSTOM_TITLE);
+            if (ctMatch)
+                customTitle = ctMatch[1];
+            continue;
+        }
+        const isUser = RE_TYPE_USER.test(line);
+        const isAssistant = !isUser && RE_TYPE_ASSISTANT.test(line);
+        if (!isUser && !isAssistant)
+            continue;
+        hasAnyMessage = true;
+        const tsMatch = line.match(RE_TIMESTAMP);
+        if (tsMatch) {
+            if (!created)
+                created = tsMatch[1];
+            modified = tsMatch[1];
+        }
+        if (!gitBranch) {
+            const gbMatch = line.match(RE_GIT_BRANCH);
+            if (gbMatch) {
+                gitBranch = gbMatch[1];
+                headFoundGitBranch = true;
+            }
+        }
+        if (!projectPath) {
+            const cwdMatch = line.match(RE_CWD);
+            if (cwdMatch) {
+                projectPath = normalizeWorktreePath(cwdMatch[1]);
+                headFoundProjectPath = true;
+            }
+        }
+        if (!isSidechain && RE_IS_SIDECHAIN.test(line)) {
+            isSidechain = true;
+        }
+        if (isUser && !firstPrompt) {
+            // JSON.parse only user lines to extract prompt text, skipping
+            // system-injected messages (e.g. <local-command-caveat>)
+            try {
+                const entry = JSON.parse(line);
+                const text = extractUserPromptText(entry);
+                if (text && !isSystemInjectedText(text)) {
+                    firstPrompt = text;
+                    headFoundFirstPrompt = true;
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    // --- Scan tail lines (if separate from head) ---
+    if (tail) {
+        const tailLines = tail.split("\n");
+        // Find last timestamp and last user prompt from tail (scan in reverse)
+        let lastUserLine = null;
+        for (let i = tailLines.length - 1; i >= 0; i--) {
+            const line = tailLines[i];
+            if (!line.trim())
+                continue;
+            const isUser = RE_TYPE_USER.test(line);
+            const isAssistant = !isUser && RE_TYPE_ASSISTANT.test(line);
+            if (!isUser && !isAssistant)
+                continue;
+            hasAnyMessage = true;
+            // Get the last modified timestamp
+            if (!modified || true) {
+                // Always update modified from tail (tail is later in file)
+                const tsMatch = line.match(RE_TIMESTAMP);
+                if (tsMatch) {
+                    modified = tsMatch[1];
+                    // We found the last message — we're done with timestamps
+                    if (isUser && !lastUserLine)
+                        lastUserLine = line;
+                    break;
+                }
+            }
+        }
+        // Also find last user line if not found in reverse timestamp scan
+        if (!lastUserLine) {
+            for (let i = tailLines.length - 1; i >= 0; i--) {
+                const line = tailLines[i];
+                if (!line.trim())
+                    continue;
+                if (RE_TYPE_USER.test(line)) {
+                    lastUserLine = line;
+                    break;
+                }
+            }
+        }
+        // JSON.parse only the last user line for lastPrompt
+        if (lastUserLine) {
+            try {
+                const entry = JSON.parse(lastUserLine);
+                const text = extractUserPromptText(entry);
+                if (text && !isSystemInjectedText(text))
+                    lastPrompt = text;
+            }
+            catch { /* skip */ }
+        }
+        // Fill in metadata from tail if head didn't have it
+        if (!gitBranch || !projectPath) {
+            for (const line of tailLines) {
+                if (!line.trim())
+                    continue;
+                if (!RE_TYPE_USER.test(line) && !RE_TYPE_ASSISTANT.test(line))
+                    continue;
+                if (!gitBranch) {
+                    const gbMatch = line.match(RE_GIT_BRANCH);
+                    if (gbMatch)
+                        gitBranch = gbMatch[1];
+                }
+                if (!projectPath) {
+                    const cwdMatch = line.match(RE_CWD);
+                    if (cwdMatch)
+                        projectPath = normalizeWorktreePath(cwdMatch[1]);
+                }
+                if (gitBranch && projectPath)
+                    break;
+            }
+        }
+    }
+    if (!hasAnyMessage) {
+        return {
+            entry: null,
+            headFoundFirstPrompt,
+            headFoundProjectPath,
+            headFoundGitBranch,
+        };
+    }
+    return {
+        entry: {
+            sessionId,
+            provider: "claude",
+            firstPrompt,
+            ...(lastPrompt && lastPrompt !== firstPrompt ? { lastPrompt } : {}),
+            ...(customTitle ? { name: customTitle } : {}),
+            created,
+            modified,
+            gitBranch,
+            projectPath,
+            isSidechain,
+        },
+        headFoundFirstPrompt,
+        headFoundProjectPath,
+        headFoundGitBranch,
+    };
+}
+/**
+ * Fast parse a Claude JSONL file using partial (head+tail) reads.
+ * Only reads the first 16KB and last 8KB of the file, avoiding full I/O.
+ * JSON.parse is called at most twice (first + last user lines).
+ */
+async function parseClaudeJsonlFileFast(sessionId, filePath) {
+    let fh;
+    try {
+        fh = await open(filePath, "r");
+    }
+    catch {
+        return null;
+    }
+    let parsedChunks;
+    try {
+        const fileStat = await fh.stat();
+        const fileSize = fileStat.size;
+        if (fileSize === 0)
+            return null;
+        // Small files: read entirely (no benefit from partial reads)
+        if (fileSize <= HEAD_BYTES + TAIL_BYTES) {
+            const buf = Buffer.alloc(fileSize);
+            await fh.read(buf, 0, fileSize, 0);
+            return parseFromChunks(sessionId, buf.toString("utf-8"), null).entry;
+        }
+        // Head read
+        const headBuf = Buffer.alloc(HEAD_BYTES);
+        await fh.read(headBuf, 0, HEAD_BYTES, 0);
+        const headStr = headBuf.toString("utf-8");
+        // Tail read — discard the first partial line
+        const tailBuf = Buffer.alloc(TAIL_BYTES);
+        await fh.read(tailBuf, 0, TAIL_BYTES, fileSize - TAIL_BYTES);
+        const tailRaw = tailBuf.toString("utf-8");
+        const firstNewline = tailRaw.indexOf("\n");
+        const cleanTail = firstNewline >= 0 ? tailRaw.slice(firstNewline + 1) : "";
+        parsedChunks = parseFromChunks(sessionId, headStr, cleanTail);
+    }
+    finally {
+        await fh.close();
+    }
+    const result = parsedChunks.entry;
+    // If the first large JSONL line pushed early metadata outside HEAD_BYTES,
+    // the tail supplement may incorrectly pick a later cwd/gitBranch. Stream
+    // from the start whenever head parsing missed these fields so resume uses
+    // the original session cwd rather than a later in-session directory.
+    if (result
+        && (!result.firstPrompt
+            || !parsedChunks.headFoundProjectPath
+            || !parsedChunks.headFoundGitBranch)) {
+        const missing = await extractMissingFieldsStreaming(filePath, !result.firstPrompt, !parsedChunks.headFoundProjectPath, !parsedChunks.headFoundGitBranch);
+        if (!result.firstPrompt && missing.firstPrompt) {
+            result.firstPrompt = missing.firstPrompt;
+        }
+        if (missing.projectPath) {
+            result.projectPath = missing.projectPath;
+        }
+        if (missing.gitBranch) {
+            result.gitBranch = missing.gitBranch;
+        }
+    }
+    return result;
+}
+async function hydrateClaudeIndexedEntry(dirPath, entry) {
+    const base = {
+        sessionId: entry.sessionId,
+        provider: "claude",
+        ...(entry.customTitle ? { name: entry.customTitle } : {}),
+        ...(entry.summary ? { summary: entry.summary } : {}),
+        firstPrompt: entry.firstPrompt ?? "",
+        created: entry.created ?? "",
+        modified: entry.modified ?? "",
+        gitBranch: entry.gitBranch ?? "",
+        projectPath: normalizeWorktreePath(entry.projectPath ?? ""),
+        isSidechain: entry.isSidechain ?? false,
+    };
+    const needsJsonlRepair = !base.firstPrompt ||
+        !base.projectPath ||
+        !base.gitBranch ||
+        !base.created ||
+        !base.modified;
+    if (!needsJsonlRepair)
+        return base;
+    const fallbackPath = entry.fullPath || join(dirPath, `${entry.sessionId}.jsonl`);
+    const parsed = await parseClaudeJsonlFileFast(entry.sessionId, fallbackPath);
+    if (!parsed)
+        return base;
+    return {
+        ...base,
+        firstPrompt: base.firstPrompt || parsed.firstPrompt,
+        created: base.created || parsed.created,
+        modified: base.modified || parsed.modified,
+        gitBranch: base.gitBranch || parsed.gitBranch,
+        projectPath: base.projectPath || parsed.projectPath,
+        isSidechain: base.isSidechain || parsed.isSidechain,
+        ...(base.lastPrompt || !parsed.lastPrompt ? {} : { lastPrompt: parsed.lastPrompt }),
+    };
+}
+/**
+ * Fallback: stream a JSONL file line-by-line to find missing fields.
+ * Called when the fast head-read could not extract firstPrompt/projectPath
+ * (e.g. the first user message line is very large due to embedded images
+ * and got truncated within HEAD_BYTES).
+ * Reads only until all needed fields are found, then stops.
+ */
+async function extractMissingFieldsStreaming(filePath, needFirstPrompt, needProjectPath, needGitBranch) {
+    return new Promise((resolve) => {
+        const stream = createReadStream(filePath, { encoding: "utf-8" });
+        const rl = createInterface({ input: stream, crlfDelay: Infinity });
+        let firstPrompt = "";
+        let projectPath = "";
+        let gitBranch = "";
+        let done = false;
+        function checkDone() {
+            const promptDone = !needFirstPrompt || firstPrompt !== "";
+            const pathDone = !needProjectPath || projectPath !== "";
+            const branchDone = !needGitBranch || gitBranch !== "";
+            if (promptDone && pathDone && branchDone) {
+                done = true;
+                rl.close();
+                stream.destroy();
+                resolve({ firstPrompt, projectPath, gitBranch });
+            }
+        }
+        rl.on("line", (line) => {
+            if (done)
+                return;
+            const isUser = RE_TYPE_USER.test(line);
+            const isAssistant = !isUser && RE_TYPE_ASSISTANT.test(line);
+            if (!isUser && !isAssistant)
+                return;
+            // Extract projectPath/gitBranch from cwd field (available on any user/assistant line)
+            if (needProjectPath && !projectPath) {
+                const cwdMatch = line.match(RE_CWD);
+                if (cwdMatch) {
+                    projectPath = normalizeWorktreePath(cwdMatch[1]);
+                }
+            }
+            if (needGitBranch && !gitBranch) {
+                const gbMatch = line.match(RE_GIT_BRANCH);
+                if (gbMatch)
+                    gitBranch = gbMatch[1];
+            }
+            // Extract firstPrompt from user lines
+            if (needFirstPrompt && isUser && !firstPrompt) {
+                try {
+                    const entry = JSON.parse(line);
+                    const text = extractUserPromptText(entry);
+                    if (text && !isSystemInjectedText(text)) {
+                        firstPrompt = text;
+                    }
+                }
+                catch {
+                    // Line might be malformed — skip
+                }
+            }
+            checkDone();
+        });
+        rl.on("close", () => {
+            if (!done)
+                resolve({ firstPrompt, projectPath, gitBranch });
+        });
+        stream.on("error", () => {
+            if (!done)
+                resolve({ firstPrompt, projectPath, gitBranch });
+        });
+    });
+}
+/**
+ * Maximum bytes to read from file tail when searching for lastPrompt.
+ * Claude sessions often have large tool-result lines (diffs, etc.) near the
+ * end, so 8KB is rarely enough.  We grow the read window in steps up to this
+ * cap to balance speed and coverage.
+ */
+const LAST_PROMPT_MAX_TAIL = 131072; // 128KB
+/**
+ * Fast tail-read to extract the last user prompt from a JSONL file.
+ * Starts at TAIL_BYTES and doubles up to LAST_PROMPT_MAX_TAIL until a real
+ * user text prompt is found.  No full-file scan is ever performed.
+ * Used to supplement sessions-index.json entries that lack lastPrompt.
+ */
+async function extractLastPromptFromTail(filePath) {
+    let fh;
+    try {
+        fh = await open(filePath, "r");
+    }
+    catch {
+        return "";
+    }
+    try {
+        const fileSize = (await fh.stat()).size;
+        if (fileSize === 0)
+            return "";
+        // Grow tail window: 8KB → 16KB → 32KB → 64KB → 128KB
+        for (let tailSize = TAIL_BYTES; tailSize <= LAST_PROMPT_MAX_TAIL; tailSize *= 2) {
+            const readSize = Math.min(fileSize, tailSize);
+            const readOffset = fileSize - readSize;
+            const buf = Buffer.alloc(readSize);
+            await fh.read(buf, 0, readSize, readOffset);
+            let raw = buf.toString("utf-8");
+            // Discard the first partial line if reading from middle of file
+            if (readOffset > 0) {
+                const nl = raw.indexOf("\n");
+                if (nl >= 0)
+                    raw = raw.slice(nl + 1);
+            }
+            // Scan in reverse to find the last user line with real text
+            const lines = raw.split("\n");
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const line = lines[i];
+                if (!line.trim())
+                    continue;
+                if (!RE_TYPE_USER.test(line))
+                    continue;
+                try {
+                    const entry = JSON.parse(line);
+                    const text = extractUserPromptText(entry);
+                    if (text && !isSystemInjectedText(text))
+                        return text;
+                }
+                catch {
+                    // Truncated line — skip
+                }
+            }
+            // If we already read the entire file, stop
+            if (readSize >= fileSize)
+                break;
+        }
+        return "";
+    }
+    finally {
+        await fh.close();
+    }
+}
+/**
+ * Scan a directory for JSONL session files and create SessionIndexEntry objects.
+ * Used as a fallback when sessions-index.json is missing (common for worktree sessions).
+ * File reads are parallelized and use head+tail partial reads for performance.
+ */
+export async function scanJsonlDir(dirPath, options = {}) {
+    const scanStats = options.stats;
+    let files;
+    try {
+        files = await readdir(dirPath);
+    }
+    catch {
+        return [];
+    }
+    // Filter to JSONL files and apply exclusions
+    const targets = [];
+    for (const file of files) {
+        if (!file.endsWith(".jsonl"))
+            continue;
+        scanStats && (scanStats.filesTotal += 1);
+        const sessionId = basename(file, ".jsonl");
+        if (options.excludeSessionIds?.has(sessionId)) {
+            scanStats && (scanStats.filesExcluded += 1);
+            continue;
+        }
+        targets.push({ sessionId, filePath: join(dirPath, file) });
+    }
+    // Read and parse files in parallel using fast head+tail reads
+    const results = await parallelMap(targets, PARALLEL_FILE_READ_LIMIT, async ({ sessionId, filePath }) => {
+        const entry = await parseClaudeJsonlFileFast(sessionId, filePath);
+        if (entry) {
+            scanStats && (scanStats.filesRead += 1);
+            scanStats && (scanStats.entriesReturned += 1);
+        }
+        else {
+            scanStats && (scanStats.filesRead += 1);
+        }
+        return entry;
+    });
+    return results.filter((e) => e !== null);
+}
+export async function getAllRecentSessions(options = {}) {
+    const totalStartedAt = process.hrtime.bigint();
+    const durations = {};
+    const perfStats = createRecentSessionsPerfStats();
+    const limit = options.limit ?? 20;
+    const offset = options.offset ?? 0;
+    const filterProjectPath = options.projectPath;
+    const shouldLoadClaude = options.provider !== "codex";
+    const shouldLoadCodex = options.provider !== "claude";
+    const includeOnlyNamedClaude = options.namedOnly === true;
+    const projectsDir = join(homedir(), ".claude", "projects");
+    const entries = [];
+    let projectDirs;
+    const loadProjectDirsStartedAt = process.hrtime.bigint();
+    try {
+        projectDirs = await readdir(projectsDir);
+    }
+    catch {
+        // ~/.claude/projects doesn't exist
+        projectDirs = [];
+    }
+    markDuration(durations, "loadClaudeProjectDirs", loadProjectDirsStartedAt);
+    // Compute worktree slug prefix for projectPath filtering
+    const projectSlug = filterProjectPath
+        ? pathToSlug(filterProjectPath)
+        : null;
+    // --- Load Claude and Codex sessions in parallel ---
+    const loadClaudeStartedAt = process.hrtime.bigint();
+    const claudeEntriesPromise = (async () => {
+        if (!shouldLoadClaude)
+            return [];
+        // Filter directories first (sync), then process in parallel
+        const relevantDirs = [];
+        for (const dirName of projectDirs) {
+            if (dirName.startsWith("."))
+                continue;
+            const isProjectDir = projectSlug ? dirName === projectSlug : false;
+            const isWorktreeDir = projectSlug
+                ? isWorktreeSlug(dirName, projectSlug)
+                : false;
+            if (filterProjectPath && !isProjectDir && !isWorktreeDir)
+                continue;
+            relevantDirs.push(dirName);
+        }
+        perfStats.claudeProjectDirs = relevantDirs.length;
+        // Process directories in parallel
+        const dirResults = await parallelMap(relevantDirs, PARALLEL_FILE_READ_LIMIT, async (dirName) => {
+            const dirPath = join(projectsDir, dirName);
+            const indexPath = join(dirPath, "sessions-index.json");
+            let raw = null;
+            try {
+                raw = await readFile(indexPath, "utf-8");
+            }
+            catch {
+                // No sessions-index.json — will try JSONL scan for worktree dirs
+            }
+            const result = {
+                entries: [],
+                indexDirs: 0,
+                indexEntries: 0,
+                jsonlOnlyDirs: 0,
+                jsonlStats: { filesTotal: 0, filesExcluded: 0, filesRead: 0, entriesReturned: 0 },
+            };
+            if (raw !== null) {
+                result.indexDirs = 1;
+                let index;
+                try {
+                    index = JSON.parse(raw);
+                }
+                catch {
+                    console.error(`[sessions-index] Failed to parse ${indexPath}`);
+                    return result;
+                }
+                if (!Array.isArray(index.entries))
+                    return result;
+                const indexedIds = new Set();
+                for (const entry of index.entries) {
+                    const name = entry.customTitle || undefined;
+                    if (includeOnlyNamedClaude && (!name || name === "")) {
+                        continue;
+                    }
+                    indexedIds.add(entry.sessionId);
+                    result.entries.push(await hydrateClaudeIndexedEntry(dirPath, entry));
+                    result.indexEntries += 1;
+                }
+                if (!includeOnlyNamedClaude) {
+                    const scanned = await scanJsonlDir(dirPath, {
+                        excludeSessionIds: indexedIds,
+                        stats: result.jsonlStats,
+                    });
+                    result.entries.push(...scanned);
+                }
+                else {
+                    perfStats.claudeNamedOnlyFastPathUsed = true;
+                }
+            }
+            else {
+                if (includeOnlyNamedClaude) {
+                    perfStats.claudeNamedOnlyFastPathUsed = true;
+                    return result;
+                }
+                result.jsonlOnlyDirs = 1;
+                const scanned = await scanJsonlDir(dirPath, { stats: result.jsonlStats });
+                result.entries.push(...scanned);
+            }
+            return result;
+        });
+        // Aggregate stats and entries
+        const allEntries = [];
+        for (const r of dirResults) {
+            allEntries.push(...r.entries);
+            perfStats.claudeIndexDirs += r.indexDirs;
+            perfStats.claudeIndexEntries += r.indexEntries;
+            perfStats.claudeJsonlOnlyDirs += r.jsonlOnlyDirs;
+            perfStats.claudeJsonlFilesTotal += r.jsonlStats.filesTotal;
+            perfStats.claudeJsonlFilesExcluded += r.jsonlStats.filesExcluded;
+            perfStats.claudeJsonlFilesRead += r.jsonlStats.filesRead;
+            perfStats.claudeJsonlEntries += r.jsonlStats.entriesReturned;
+        }
+        return allEntries;
+    })();
+    const loadCodexStartedAt = process.hrtime.bigint();
+    const codexEntriesPromise = (async () => {
+        if (!shouldLoadCodex)
+            return [];
+        const codexPerf = {
+            filesTotal: 0,
+            filesRead: 0,
+            entriesReturned: 0,
+        };
+        const codexEntries = await getAllRecentCodexSessions({
+            projectPath: filterProjectPath,
+            perfStats: codexPerf,
+        });
+        perfStats.codexFilesTotal = codexPerf.filesTotal;
+        perfStats.codexFilesRead = codexPerf.filesRead;
+        perfStats.codexEntries = codexPerf.entriesReturned;
+        return codexEntries;
+    })();
+    // Wait for both Claude and Codex loading to complete in parallel
+    const [claudeEntries, codexEntries] = await Promise.all([
+        claudeEntriesPromise,
+        codexEntriesPromise,
+    ]);
+    markDuration(durations, "loadClaudeSessions", loadClaudeStartedAt);
+    markDuration(durations, "loadCodexSessions", loadCodexStartedAt);
+    // Combine results
+    entries.push(...claudeEntries, ...codexEntries);
+    // Filter out archived sessions
+    const archivedIds = options.archivedSessionIds;
+    let filtered = archivedIds
+        ? entries.filter((e) => !archivedIds.has(e.sessionId))
+        : [...entries];
+    perfStats.counts.beforeArchive = entries.length;
+    perfStats.counts.afterArchive = filtered.length;
+    // Filter by provider
+    if (options.provider) {
+        filtered = filtered.filter((e) => e.provider === options.provider);
+    }
+    perfStats.counts.afterProvider = filtered.length;
+    // Filter named only
+    if (options.namedOnly) {
+        filtered = filtered.filter((e) => e.name != null && e.name !== "");
+    }
+    perfStats.counts.afterNamedOnly = filtered.length;
+    // Filter by search query (name, firstPrompt, lastPrompt, summary)
+    if (options.searchQuery) {
+        const q = options.searchQuery.toLowerCase();
+        filtered = filtered.filter((e) => e.name?.toLowerCase().includes(q) ||
+            e.firstPrompt?.toLowerCase().includes(q) ||
+            e.lastPrompt?.toLowerCase().includes(q) ||
+            e.summary?.toLowerCase().includes(q));
+    }
+    perfStats.counts.afterSearch = filtered.length;
+    // Sort by modified descending
+    const sortStartedAt = process.hrtime.bigint();
+    filtered.sort((a, b) => {
+        const ta = new Date(a.modified).getTime();
+        const tb = new Date(b.modified).getTime();
+        return tb - ta;
+    });
+    markDuration(durations, "sortSessions", sortStartedAt);
+    const paginateStartedAt = process.hrtime.bigint();
+    const sliced = filtered.slice(offset, offset + limit);
+    const hasMore = offset + limit < filtered.length;
+    perfStats.counts.returned = sliced.length;
+    markDuration(durations, "paginate", paginateStartedAt);
+    // Supplement missing lastPrompt for Claude sessions (sessions-index.json
+    // doesn't include lastPrompt).  Only the paginated page is processed so at
+    // most `limit` tail reads are needed — lightweight enough to keep inline.
+    const supplementStartedAt = process.hrtime.bigint();
+    const needLastPrompt = sliced.filter((e) => e.provider === "claude" && !e.lastPrompt && e.projectPath);
+    if (needLastPrompt.length > 0) {
+        const projectsDir = join(homedir(), ".claude", "projects");
+        await parallelMap(needLastPrompt, PARALLEL_FILE_READ_LIMIT, async (entry) => {
+            const slug = pathToSlug(entry.projectPath);
+            const jsonlPath = join(projectsDir, slug, `${entry.sessionId}.jsonl`);
+            const lp = await extractLastPromptFromTail(jsonlPath);
+            if (lp && lp !== entry.firstPrompt) {
+                entry.lastPrompt = lp;
+            }
+        });
+    }
+    markDuration(durations, "supplementLastPrompt", supplementStartedAt);
+    markDuration(durations, "total", totalStartedAt);
+    logRecentSessionsPerf(options, durations, perfStats);
+    return { sessions: sliced, hasMore };
+}
+async function listCodexSessionFiles() {
+    const root = join(homedir(), ".codex", "sessions");
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let children;
+        try {
+            children = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const child of children) {
+            const p = join(dir, child.name);
+            if (child.isDirectory()) {
+                stack.push(p);
+            }
+            else if (child.isFile() && p.endsWith(".jsonl")) {
+                files.push(p);
+            }
+        }
+    }
+    return files;
+}
+function parseCodexSessionJsonl(raw, fallbackSessionId) {
+    const lines = raw.split("\n");
+    let threadId = fallbackSessionId;
+    let projectPath = "";
+    let resumeCwd = "";
+    let gitBranch = "";
+    let created = "";
+    let modified = "";
+    let firstPrompt = "";
+    let lastPrompt = "";
+    let summary = "";
+    let hasMessages = false;
+    let lastAssistantText = "";
+    let agentNickname;
+    let agentRole;
+    // Settings extracted from the first turn_context entry
+    let approvalPolicy;
+    let sandboxMode;
+    let model;
+    let modelReasoningEffort;
+    let networkAccessEnabled;
+    let webSearchMode;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const timestamp = entry.timestamp;
+        if (timestamp) {
+            if (!created)
+                created = timestamp;
+            modified = timestamp;
+        }
+        if (entry.type === "session_meta") {
+            const payload = entry.payload;
+            if (payload) {
+                if (typeof payload.id === "string" && payload.id.length > 0) {
+                    threadId = payload.id;
+                }
+                if (typeof payload.cwd === "string" && payload.cwd.length > 0) {
+                    resumeCwd = payload.cwd;
+                    projectPath = normalizeWorktreePath(payload.cwd);
+                }
+                const git = payload.git;
+                if (git && typeof git.branch === "string") {
+                    gitBranch = git.branch;
+                }
+                if (typeof payload.agent_nickname === "string" && payload.agent_nickname.length > 0) {
+                    agentNickname = payload.agent_nickname;
+                }
+                if (typeof payload.agent_role === "string" && payload.agent_role.length > 0) {
+                    agentRole = payload.agent_role;
+                }
+            }
+            continue;
+        }
+        // Extract codex settings from turn_context.
+        // Always update (no guard) so the **last** turn_context wins — this is
+        // important when sandbox mode or other settings change mid-session.
+        if (entry.type === "turn_context") {
+            const payload = entry.payload;
+            if (payload) {
+                if (typeof payload.approval_policy === "string") {
+                    approvalPolicy = payload.approval_policy;
+                }
+                const sp = payload.sandbox_policy;
+                if (sp && typeof sp.type === "string") {
+                    sandboxMode = sp.type;
+                }
+                if (typeof payload.model === "string") {
+                    model = payload.model;
+                }
+                const collaborationMode = payload.collaboration_mode;
+                const collaborationSettings = collaborationMode?.settings;
+                if (typeof collaborationSettings?.reasoning_effort === "string") {
+                    modelReasoningEffort = collaborationSettings.reasoning_effort;
+                }
+                if (typeof sp?.network_access === "boolean") {
+                    networkAccessEnabled = sp.network_access;
+                }
+                if (typeof payload.web_search === "string") {
+                    webSearchMode = payload.web_search;
+                }
+            }
+            continue;
+        }
+        if (entry.type === "event_msg") {
+            const payload = entry.payload;
+            if (payload?.type === "user_message" && typeof payload.message === "string") {
+                hasMessages = true;
+                if (!firstPrompt)
+                    firstPrompt = payload.message;
+                lastPrompt = payload.message;
+            }
+            continue;
+        }
+        if (entry.type === "response_item") {
+            const payload = entry.payload;
+            if (!payload || payload.type !== "message" || payload.role !== "assistant") {
+                continue;
+            }
+            const content = payload.content;
+            if (!Array.isArray(content))
+                continue;
+            const text = content
+                .filter((item) => item.type === "output_text" && typeof item.text === "string")
+                .map((item) => item.text)
+                .join("\n")
+                .trim();
+            if (text.length > 0) {
+                hasMessages = true;
+                lastAssistantText = text;
+            }
+        }
+    }
+    if (!projectPath || !hasMessages)
+        return null;
+    summary = lastAssistantText || summary;
+    const codexSettings = (approvalPolicy
+        || sandboxMode
+        || model
+        || modelReasoningEffort
+        || networkAccessEnabled !== undefined
+        || webSearchMode)
+        ? {
+            approvalPolicy,
+            sandboxMode,
+            model,
+            modelReasoningEffort,
+            networkAccessEnabled,
+            webSearchMode,
+        }
+        : undefined;
+    return {
+        threadId,
+        entry: {
+            sessionId: threadId,
+            provider: "codex",
+            ...(agentNickname ? { agentNickname } : {}),
+            ...(agentRole ? { agentRole } : {}),
+            summary: summary || undefined,
+            firstPrompt,
+            ...(lastPrompt && lastPrompt !== firstPrompt ? { lastPrompt } : {}),
+            created,
+            modified,
+            gitBranch,
+            projectPath,
+            ...(resumeCwd && resumeCwd !== projectPath ? { resumeCwd } : {}),
+            isSidechain: false,
+            codexSettings,
+        },
+    };
+}
+/**
+ * Look up the saved name (customTitle) for a Claude Code session.
+ * Returns the name if found, or undefined.
+ */
+export async function getClaudeSessionName(projectPath, claudeSessionId) {
+    const slug = pathToSlug(projectPath);
+    const indexPath = join(homedir(), ".claude", "projects", slug, "sessions-index.json");
+    let raw;
+    try {
+        raw = await readFile(indexPath, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+    let index;
+    try {
+        index = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(index.entries))
+        return undefined;
+    const entry = index.entries.find((e) => e.sessionId === claudeSessionId);
+    return entry?.customTitle || undefined;
+}
+/**
+ * Rename a Claude Code session by writing customTitle to sessions-index.json.
+ * This is the same mechanism the CLI uses for /rename.
+ */
+export async function renameClaudeSession(projectPath, claudeSessionId, name) {
+    const slug = pathToSlug(projectPath);
+    const dirPath = join(homedir(), ".claude", "projects", slug);
+    const indexPath = join(dirPath, "sessions-index.json");
+    let index = null;
+    try {
+        const raw = await readFile(indexPath, "utf-8");
+        index = JSON.parse(raw);
+    }
+    catch {
+        // File doesn't exist or is invalid — will create below if needed
+    }
+    if (index && Array.isArray(index.entries)) {
+        const entry = index.entries.find((e) => e.sessionId === claudeSessionId);
+        if (entry) {
+            if (name) {
+                entry.customTitle = name;
+            }
+            else {
+                delete entry.customTitle;
+            }
+            await writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+            return true;
+        }
+    }
+    // Entry not found in index (or index doesn't exist yet).
+    // The CLI may not have created the index entry for short-lived or new sessions.
+    // Create a minimal entry so customTitle is persisted and picked up by
+    // getAllRecentSessions() on next read.
+    if (!name)
+        return false; // Nothing to persist when clearing name
+    if (!index || !Array.isArray(index.entries)) {
+        index = { version: 1, entries: [] };
+    }
+    // Build a minimal entry from the JSONL file if available
+    const jsonlPath = join(dirPath, `${claudeSessionId}.jsonl`);
+    let firstPrompt = "";
+    let created = new Date().toISOString();
+    let modified = created;
+    let gitBranch = "";
+    try {
+        const raw = await readFile(jsonlPath, "utf-8");
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                const type = entry.type;
+                if (type !== "user" && type !== "assistant")
+                    continue;
+                const ts = entry.timestamp;
+                if (ts) {
+                    if (!firstPrompt)
+                        created = ts;
+                    modified = ts;
+                }
+                if (!gitBranch && entry.gitBranch)
+                    gitBranch = entry.gitBranch;
+                if (type === "user" && !firstPrompt) {
+                    const msg = entry.message;
+                    if (msg?.content) {
+                        if (typeof msg.content === "string")
+                            firstPrompt = msg.content;
+                        else if (Array.isArray(msg.content)) {
+                            const tb = msg.content
+                                .find((c) => c.type === "text" && c.text);
+                            if (tb?.text)
+                                firstPrompt = tb.text;
+                        }
+                    }
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+    }
+    catch { /* JSONL not available */ }
+    index.entries.push({
+        sessionId: claudeSessionId,
+        fullPath: jsonlPath,
+        fileMtime: Date.now(),
+        firstPrompt,
+        customTitle: name,
+        messageCount: 0,
+        created,
+        modified,
+        gitBranch,
+        projectPath,
+        isSidechain: false,
+    });
+    // Ensure directory exists (may not for brand-new projects)
+    const { mkdir } = await import("node:fs/promises");
+    await mkdir(dirPath, { recursive: true });
+    await writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    return true;
+}
+/**
+ * Read the Codex session_index.jsonl and build a threadId → name map.
+ */
+export async function loadCodexSessionNames() {
+    const indexPath = join(homedir(), ".codex", "session_index.jsonl");
+    const names = new Map();
+    let raw;
+    try {
+        raw = await readFile(indexPath, "utf-8");
+    }
+    catch {
+        return names;
+    }
+    // Append-only: later entries override earlier ones for the same id
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (entry.id && entry.thread_name) {
+                names.set(entry.id, entry.thread_name);
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return names;
+}
+/**
+ * Rename a Codex session by appending to ~/.codex/session_index.jsonl.
+ * Passing `null` or empty name writes an empty thread_name to effectively clear it.
+ */
+export async function renameCodexSession(threadId, name) {
+    try {
+        const indexPath = join(homedir(), ".codex", "session_index.jsonl");
+        const entry = JSON.stringify({
+            id: threadId,
+            thread_name: name ?? "",
+            updated_at: new Date().toISOString(),
+        });
+        await appendFile(indexPath, entry + "\n");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getAllRecentCodexSessions(options = {}) {
+    const files = await listCodexSessionFiles();
+    const entries = [];
+    options.perfStats && (options.perfStats.filesTotal = files.length);
+    const normalizedProjectPath = options.projectPath
+        ? normalizeWorktreePath(options.projectPath)
+        : null;
+    // Load thread names from session_index.jsonl
+    const threadNames = await loadCodexSessionNames();
+    for (const filePath of files) {
+        let raw;
+        try {
+            raw = await readFile(filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        options.perfStats && (options.perfStats.filesRead += 1);
+        const fallbackSessionId = basename(filePath, ".jsonl");
+        const parsed = parseCodexSessionJsonl(raw, fallbackSessionId);
+        if (!parsed)
+            continue;
+        if (normalizedProjectPath && parsed.entry.projectPath !== normalizedProjectPath) {
+            continue;
+        }
+        // Attach thread name if available
+        const threadName = threadNames.get(parsed.threadId);
+        if (threadName) {
+            parsed.entry.name = threadName;
+        }
+        entries.push(parsed.entry);
+        options.perfStats && (options.perfStats.entriesReturned += 1);
+    }
+    return entries;
+}
+function asObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function parseObjectLike(value) {
+    if (typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            return asObject(parsed) ?? { value: parsed };
+        }
+        catch {
+            return { value };
+        }
+    }
+    return asObject(value) ?? {};
+}
+function appendTextMessage(messages, role, text, timestamp) {
+    const normalized = text.trim();
+    if (!normalized)
+        return;
+    const last = messages.at(-1);
+    if (last
+        && last.role === role
+        && last.content.length === 1
+        && last.content[0].type === "text"
+        && typeof last.content[0].text === "string"
+        && last.content[0].text.trim() === normalized) {
+        return;
+    }
+    messages.push({
+        role,
+        content: [{ type: "text", text }],
+        ...(timestamp ? { timestamp } : {}),
+    });
+}
+function appendToolUseMessage(messages, id, name, input) {
+    const normalizedName = name.trim();
+    if (!normalizedName)
+        return;
+    const last = messages.at(-1);
+    if (last
+        && last.role === "assistant"
+        && last.content.length === 1
+        && last.content[0].type === "tool_use"
+        && last.content[0].id === id
+        && last.content[0].name === normalizedName) {
+        return;
+    }
+    messages.push({
+        role: "assistant",
+        content: [
+            {
+                type: "tool_use",
+                id,
+                name: normalizedName,
+                input,
+            },
+        ],
+    });
+}
+function normalizeCodexToolName(name) {
+    if (name === "exec_command" || name === "write_stdin") {
+        return "Bash";
+    }
+    // Codex function names for MCP tools look like: mcp__server__tool_name
+    if (name.startsWith("mcp__")) {
+        const [server, ...toolParts] = name.slice("mcp__".length).split("__");
+        if (server && toolParts.length > 0) {
+            return `mcp:${server}/${toolParts.join("__")}`;
+        }
+    }
+    return name;
+}
+function isCodexInjectedUserContext(text) {
+    const normalized = text.trimStart();
+    return (normalized.startsWith("# AGENTS.md instructions for ")
+        || normalized.startsWith("<environment_context>")
+        || normalized.startsWith("<permissions instructions>"));
+}
+function getCodexSearchInput(payload) {
+    const action = asObject(payload.action);
+    const input = {};
+    if (typeof action?.query === "string") {
+        input.query = action.query;
+    }
+    if (Array.isArray(action?.queries)) {
+        const queries = action.queries.filter((q) => typeof q === "string" && q.length > 0);
+        if (queries.length > 0) {
+            input.queries = queries;
+        }
+    }
+    return input;
+}
+/**
+ * Find the JSONL file path for a given sessionId by searching sessions-index.json files,
+ * then falling back to scanning directories for the JSONL file directly.
+ */
+async function findSessionJsonlPath(sessionId) {
+    const projectsDir = join(homedir(), ".claude", "projects");
+    let projectDirs;
+    try {
+        projectDirs = await readdir(projectsDir);
+    }
+    catch {
+        return null;
+    }
+    // First pass: check sessions-index.json files
+    for (const dirName of projectDirs) {
+        if (dirName.startsWith("."))
+            continue;
+        const indexPath = join(projectsDir, dirName, "sessions-index.json");
+        let raw;
+        try {
+            raw = await readFile(indexPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let index;
+        try {
+            index = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!Array.isArray(index.entries))
+            continue;
+        const entry = index.entries.find((e) => e.sessionId === sessionId);
+        if (entry?.fullPath) {
+            return entry.fullPath;
+        }
+    }
+    // Fallback: scan directories for the JSONL file directly
+    // This handles worktree sessions without sessions-index.json
+    const jsonlFileName = `${sessionId}.jsonl`;
+    for (const dirName of projectDirs) {
+        if (dirName.startsWith("."))
+            continue;
+        const candidatePath = join(projectsDir, dirName, jsonlFileName);
+        try {
+            await stat(candidatePath);
+            return candidatePath;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function findCodexSessionJsonlPath(threadId) {
+    const files = await listCodexSessionFiles();
+    for (const filePath of files) {
+        const fallbackSessionId = basename(filePath, ".jsonl");
+        if (fallbackSessionId === threadId) {
+            return filePath;
+        }
+        let raw;
+        try {
+            raw = await readFile(filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const parsed = parseCodexSessionJsonl(raw, fallbackSessionId);
+        if (parsed?.threadId === threadId) {
+            return filePath;
+        }
+    }
+    return null;
+}
+/**
+ * Read past conversation messages from a session's JSONL file.
+ * Returns user and assistant messages suitable for display.
+ */
+export async function getSessionHistory(sessionId) {
+    const jsonlPath = await findSessionJsonlPath(sessionId);
+    if (!jsonlPath)
+        return [];
+    let raw;
+    try {
+        raw = await readFile(jsonlPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const messages = [];
+    const lines = raw.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = entry.type;
+        if (type !== "user" && type !== "assistant")
+            continue;
+        // Skip context compaction and transcript-only messages (not real user input)
+        if (type === "user") {
+            if (entry.isCompactSummary === true || entry.isVisibleInTranscriptOnly === true) {
+                continue;
+            }
+        }
+        const message = entry.message;
+        if (!message?.content)
+            continue;
+        const role = message.role;
+        const isMeta = role === "user" && entry.isMeta === true ? true : undefined;
+        // Handle string content (e.g. user message after interrupt)
+        if (typeof message.content === "string") {
+            if (message.content) {
+                const uuid = entry.uuid;
+                const ts = entry.timestamp;
+                messages.push({
+                    role,
+                    content: [{ type: "text", text: message.content }],
+                    ...(uuid ? { uuid } : {}),
+                    ...(ts ? { timestamp: ts } : {}),
+                    ...(isMeta ? { isMeta } : {}),
+                });
+            }
+            continue;
+        }
+        if (!Array.isArray(message.content))
+            continue;
+        // Filter content to only text and tool_use (skip tool_result for cleaner display)
+        const content = [];
+        let imageCount = 0;
+        for (const c of message.content) {
+            if (typeof c !== "object" || c === null)
+                continue;
+            const item = c;
+            const contentType = item.type;
+            if (contentType === "text" && item.text) {
+                content.push({ type: "text", text: item.text });
+            }
+            else if (contentType === "tool_use") {
+                content.push({
+                    type: "tool_use",
+                    id: item.id,
+                    name: item.name,
+                    input: item.input ?? {},
+                });
+            }
+            else if (contentType === "image") {
+                imageCount++;
+            }
+        }
+        if (content.length > 0 || imageCount > 0) {
+            const uuid = entry.uuid;
+            const ts = entry.timestamp;
+            // If there are only images and no text, add a placeholder
+            if (content.length === 0 && imageCount > 0) {
+                content.push({
+                    type: "text",
+                    text: `[Image attached${imageCount > 1 ? ` x${imageCount}` : ""}]`,
+                });
+            }
+            messages.push({
+                role,
+                content,
+                ...(uuid ? { uuid } : {}),
+                ...(ts ? { timestamp: ts } : {}),
+                ...(isMeta ? { isMeta } : {}),
+                ...(imageCount > 0 ? { imageCount } : {}),
+            });
+        }
+    }
+    return messages;
+}
+/**
+ * Extract image base64 data from a Claude Code session JSONL for a specific message UUID.
+ */
+export async function extractMessageImages(sessionId, messageUuid) {
+    // Try Claude Code first, then Codex
+    const claudeImages = await extractClaudeMessageImages(sessionId, messageUuid);
+    if (claudeImages.length > 0)
+        return claudeImages;
+    return extractCodexMessageImages(sessionId, messageUuid);
+}
+async function extractClaudeMessageImages(sessionId, messageUuid) {
+    const jsonlPath = await findSessionJsonlPath(sessionId);
+    if (!jsonlPath)
+        return [];
+    let raw;
+    try {
+        raw = await readFile(jsonlPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const lines = raw.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "user")
+            continue;
+        if (entry.uuid !== messageUuid)
+            continue;
+        const message = entry.message;
+        if (!message?.content || !Array.isArray(message.content))
+            continue;
+        const images = [];
+        for (const c of message.content) {
+            if (typeof c !== "object" || c === null)
+                continue;
+            const item = c;
+            if (item.type !== "image")
+                continue;
+            const source = item.source;
+            if (!source || source.type !== "base64")
+                continue;
+            const data = source.data;
+            const mediaType = source.media_type;
+            if (data && mediaType) {
+                images.push({ base64: data, mimeType: mediaType });
+            }
+        }
+        return images;
+    }
+    return [];
+}
+async function extractCodexMessageImages(sessionId, messageUuid) {
+    const jsonlPath = await findCodexSessionJsonlPath(sessionId);
+    if (!jsonlPath)
+        return [];
+    let raw;
+    try {
+        raw = await readFile(jsonlPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    // Codex doesn't have per-message UUIDs in the same way.
+    // We scan for event_msg with user_message that has images and match by line index
+    // encoded in the UUID (format: "codex-line-{index}").
+    const lineIndex = messageUuid.startsWith("codex-line-")
+        ? parseInt(messageUuid.slice("codex-line-".length), 10)
+        : -1;
+    if (lineIndex < 0)
+        return [];
+    const lines = raw.split("\n");
+    if (lineIndex >= lines.length)
+        return [];
+    const line = lines[lineIndex];
+    if (!line?.trim())
+        return [];
+    let entry;
+    try {
+        entry = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (entry.type !== "event_msg")
+        return [];
+    const payload = asObject(entry.payload);
+    if (!payload || payload.type !== "user_message")
+        return [];
+    const images = [];
+    // Parse payload.images (Data URI format: "data:image/png;base64,...")
+    if (Array.isArray(payload.images)) {
+        for (const img of payload.images) {
+            if (typeof img !== "string")
+                continue;
+            const match = img.match(/^data:(image\/[^;]+);base64,(.+)$/);
+            if (match) {
+                images.push({ base64: match[2], mimeType: match[1] });
+            }
+        }
+    }
+    return images;
+}
+export async function getCodexSessionHistory(threadId) {
+    const jsonlPath = await findCodexSessionJsonlPath(threadId);
+    if (!jsonlPath)
+        return [];
+    let raw;
+    try {
+        raw = await readFile(jsonlPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const messages = [];
+    const lines = raw.split("\n");
+    for (const [index, line] of lines.entries()) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const entryTimestamp = entry.timestamp;
+        if (entry.type === "event_msg") {
+            const payload = asObject(entry.payload);
+            if (!payload)
+                continue;
+            if (payload.type === "user_message") {
+                const rawMessage = typeof payload.message === "string" ? payload.message : "";
+                const images = Array.isArray(payload.images) ? payload.images.length : 0;
+                const localImages = Array.isArray(payload.local_images)
+                    ? payload.local_images.length
+                    : 0;
+                const imageCount = images + localImages;
+                const text = rawMessage.trim().length > 0
+                    ? rawMessage
+                    : imageCount > 0
+                        ? `[Image attached${imageCount > 1 ? ` x${imageCount}` : ""}]`
+                        : "";
+                if (imageCount > 0) {
+                    // Push directly to include imageCount metadata
+                    const normalized = text.trim();
+                    if (normalized) {
+                        messages.push({
+                            role: "user",
+                            content: [{ type: "text", text }],
+                            imageCount,
+                            ...(entryTimestamp ? { timestamp: entryTimestamp } : {}),
+                        });
+                    }
+                }
+                else {
+                    appendTextMessage(messages, "user", text, entryTimestamp);
+                }
+                continue;
+            }
+            if (payload.type === "agent_message" && typeof payload.message === "string") {
+                appendTextMessage(messages, "assistant", payload.message, entryTimestamp);
+            }
+            continue;
+        }
+        if (entry.type === "response_item") {
+            const payload = asObject(entry.payload);
+            if (!payload)
+                continue;
+            if (payload.type === "message") {
+                const content = Array.isArray(payload.content)
+                    ? payload.content
+                    : [];
+                if (payload.role === "assistant") {
+                    const text = content
+                        .filter((item) => item.type === "output_text" && typeof item.text === "string")
+                        .map((item) => item.text)
+                        .join("\n");
+                    appendTextMessage(messages, "assistant", text, entryTimestamp);
+                    continue;
+                }
+                if (payload.role === "user") {
+                    const text = content
+                        .filter((item) => item.type === "input_text" && typeof item.text === "string")
+                        .map((item) => item.text)
+                        .join("\n");
+                    if (!isCodexInjectedUserContext(text)) {
+                        appendTextMessage(messages, "user", text, entryTimestamp);
+                    }
+                    continue;
+                }
+            }
+            if (payload.type === "function_call") {
+                const id = typeof payload.call_id === "string" ? payload.call_id : `tool-${index}`;
+                const rawName = typeof payload.name === "string" ? payload.name : "tool";
+                appendToolUseMessage(messages, id, normalizeCodexToolName(rawName), parseObjectLike(payload.arguments));
+                continue;
+            }
+            if (payload.type === "custom_tool_call") {
+                const id = typeof payload.call_id === "string" ? payload.call_id : `tool-${index}`;
+                const rawName = typeof payload.name === "string" ? payload.name : "custom_tool";
+                appendToolUseMessage(messages, id, normalizeCodexToolName(rawName), parseObjectLike(payload.input));
+                continue;
+            }
+            if (payload.type === "web_search_call") {
+                appendToolUseMessage(messages, typeof payload.call_id === "string" ? payload.call_id : `web-search-${index}`, "WebSearch", getCodexSearchInput(payload));
+                continue;
+            }
+            // Backward/forward compatibility with older/newer Codex JSONL schemas.
+            if (payload.type === "command_execution") {
+                const id = typeof payload.id === "string"
+                    ? payload.id
+                    : typeof payload.call_id === "string"
+                        ? payload.call_id
+                        : `cmd-${index}`;
+                const input = typeof payload.command === "string"
+                    ? { command: payload.command }
+                    : parseObjectLike(payload);
+                appendToolUseMessage(messages, id, "Bash", input);
+                continue;
+            }
+            if (payload.type === "mcp_tool_call") {
+                const id = typeof payload.id === "string"
+                    ? payload.id
+                    : typeof payload.call_id === "string"
+                        ? payload.call_id
+                        : `mcp-${index}`;
+                const server = typeof payload.server === "string" ? payload.server : "unknown";
+                const tool = typeof payload.tool === "string" ? payload.tool : "tool";
+                appendToolUseMessage(messages, id, `mcp:${server}/${tool}`, parseObjectLike(payload.arguments));
+                continue;
+            }
+            if (payload.type === "file_change") {
+                const id = typeof payload.id === "string"
+                    ? payload.id
+                    : typeof payload.call_id === "string"
+                        ? payload.call_id
+                        : `file-change-${index}`;
+                const input = Array.isArray(payload.changes)
+                    ? { changes: payload.changes }
+                    : parseObjectLike(payload.changes);
+                appendToolUseMessage(messages, id, "FileChange", input);
+                continue;
+            }
+            if (payload.type === "web_search") {
+                const id = typeof payload.id === "string"
+                    ? payload.id
+                    : typeof payload.call_id === "string"
+                        ? payload.call_id
+                        : `web-search-${index}`;
+                const input = typeof payload.query === "string"
+                    ? { query: payload.query }
+                    : getCodexSearchInput(payload);
+                appendToolUseMessage(messages, id, "WebSearch", input);
+            }
+        }
+    }
+    return messages;
+}
+/**
+ * Look up session metadata for a set of Claude CLI sessionIds.
+ * Returns a map from sessionId to a subset of session metadata.
+ * More efficient than getAllRecentSessions when you only need a few entries.
+ */
+export async function findSessionsByClaudeIds(ids) {
+    if (ids.size === 0)
+        return new Map();
+    const result = new Map();
+    const remaining = new Set(ids);
+    const projectsDir = join(homedir(), ".claude", "projects");
+    let projectDirs;
+    try {
+        projectDirs = await readdir(projectsDir);
+    }
+    catch {
+        return result;
+    }
+    for (const dirName of projectDirs) {
+        if (remaining.size === 0)
+            break;
+        if (dirName.startsWith("."))
+            continue;
+        const indexPath = join(projectsDir, dirName, "sessions-index.json");
+        let raw;
+        try {
+            raw = await readFile(indexPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let index;
+        try {
+            index = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!Array.isArray(index.entries))
+            continue;
+        for (const entry of index.entries) {
+            const sid = entry.sessionId;
+            if (!sid || !remaining.has(sid))
+                continue;
+            result.set(sid, {
+                summary: entry.summary,
+                firstPrompt: entry.firstPrompt ?? "",
+                lastPrompt: entry.lastPrompt,
+                projectPath: normalizeWorktreePath(entry.projectPath ?? ""),
+            });
+            remaining.delete(sid);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=sessions-index.js.map