@ccpocket/bridge 1.59.0 → 1.59.1

package/dist/sessions-index.d.ts

@@ -75,6 +75,10 @@ export declare function isWorktreeSlug(dirSlug: string, projectSlug: string): bo
  */
 export declare function scanJsonlDir(dirPath: string, options?: ScanJsonlDirOptions): Promise<SessionIndexEntry[]>;
 export declare function getAllRecentSessions(options?: GetRecentSessionsOptions): Promise<GetRecentSessionsResult>;
+export interface CodexSessionIndexMetadata {
+    codexSettings?: SessionIndexEntry["codexSettings"];
+    resumeCwd?: string;
+}
 /**
  * Look up the saved name (customTitle) for a Claude Code session.
  * Returns the name if found, or undefined.
@@ -98,6 +102,7 @@ export declare function saveCodexSessionAdditionalWritableRoots(threadId: string
  * Passing `null` or empty name writes an empty thread_name to effectively clear it.
  */
 export declare function renameCodexSession(threadId: string, name: string | null): Promise<boolean>;
+export declare function getCodexSessionIndexMetadata(threadIds: readonly string[]): Promise<Map<string, CodexSessionIndexMetadata>>;
 type SessionHistoryContentItem = {
     type: string;
     text?: string;

package/dist/sessions-index.js

@@ -85,6 +85,8 @@ 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
+const CODEX_HEAD_BYTES = 131072; // 128KB — Codex turn_context can be large
+const CODEX_TAIL_BYTES = 16384;
 /**
  * Run async tasks with a concurrency limit.
  * Returns results in the same order as the input tasks.
@@ -112,6 +114,10 @@ const RE_IS_SIDECHAIN = /"isSidechain"\s*:\s*true/;
 const RE_PERMISSION_MODE = /"permissionMode"\s*:\s*"([^"]+)"/;
 const RE_TYPE_CUSTOM_TITLE = /"type"\s*:\s*"custom-title"/;
 const RE_CUSTOM_TITLE = /"customTitle"\s*:\s*"([^"]+)"/;
+const RE_CODEX_PARTIAL_TIMESTAMP = /"timestamp"\s*:\s*"([^"]+)"/;
+const RE_CODEX_PARTIAL_USER_MESSAGE = /"type"\s*:\s*"event_msg"[\s\S]*"payload"\s*:\s*\{[\s\S]*"type"\s*:\s*"user_message"[\s\S]*"message"\s*:\s*"((?:\\.|[^"\\])*)/;
+const RE_CODEX_PARTIAL_AGENT_MESSAGE = /"type"\s*:\s*"event_msg"[\s\S]*"payload"\s*:\s*\{[\s\S]*"type"\s*:\s*"agent_message"[\s\S]*"message"\s*:\s*"((?:\\.|[^"\\])*)/;
+const RE_CODEX_PARTIAL_OUTPUT_TEXT = /"type"\s*:\s*"response_item"[\s\S]*"role"\s*:\s*"assistant"[\s\S]*"type"\s*:\s*"output_text"[\s\S]*"text"\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
@@ -124,6 +130,43 @@ function isSystemInjectedText(text) {
 function isCodexAutoRenameSession(firstPrompt, model) {
     return model === CODEX_ASSIST_MODEL && isAutoRenamePromptText(firstPrompt);
 }
+function decodeJsonStringPrefix(fragment) {
+    let candidate = fragment;
+    while (candidate.length > 0) {
+        try {
+            return JSON.parse(`"${candidate}"`);
+        }
+        catch {
+            candidate = candidate.slice(0, -1);
+        }
+    }
+    return "";
+}
+function parsePartialCodexLine(line) {
+    const timestamp = line.match(RE_CODEX_PARTIAL_TIMESTAMP)?.[1];
+    const userMessage = line.match(RE_CODEX_PARTIAL_USER_MESSAGE)?.[1];
+    if (userMessage !== undefined) {
+        return {
+            timestamp,
+            userMessage: decodeJsonStringPrefix(userMessage),
+        };
+    }
+    const agentMessage = line.match(RE_CODEX_PARTIAL_AGENT_MESSAGE)?.[1];
+    if (agentMessage !== undefined) {
+        return {
+            timestamp,
+            assistantText: decodeJsonStringPrefix(agentMessage),
+        };
+    }
+    const outputText = line.match(RE_CODEX_PARTIAL_OUTPUT_TEXT)?.[1];
+    if (outputText !== undefined) {
+        return {
+            timestamp,
+            assistantText: decodeJsonStringPrefix(outputText),
+        };
+    }
+    return timestamp ? { timestamp } : {};
+}
 /** Extract user prompt text from a parsed JSONL entry. */
 function extractUserPromptText(entry) {
     const message = entry.message;
@@ -919,6 +962,22 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
             entry = JSON.parse(line);
         }
         catch {
+            const partial = parsePartialCodexLine(line);
+            if (partial.timestamp) {
+                if (!created)
+                    created = partial.timestamp;
+                modified = partial.timestamp;
+            }
+            if (partial.userMessage !== undefined) {
+                hasMessages = true;
+                if (!firstPrompt)
+                    firstPrompt = partial.userMessage;
+                lastPrompt = partial.userMessage;
+            }
+            if (partial.assistantText) {
+                hasMessages = true;
+                lastAssistantText = partial.assistantText;
+            }
             continue;
         }
         const timestamp = entry.timestamp;
@@ -994,6 +1053,12 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
                     firstPrompt = payload.message;
                 lastPrompt = payload.message;
             }
+            else if (payload?.type === "agent_message"
+                && typeof payload.message === "string"
+                && payload.message.trim().length > 0) {
+                hasMessages = true;
+                lastAssistantText = payload.message;
+            }
             continue;
         }
         if (entry.type === "response_item") {
@@ -1059,6 +1124,43 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
         },
     };
 }
+/**
+ * Fast parse a Codex JSONL file for recent-session list metadata.
+ * The first chunk contains session_meta / first prompt; the tail chunk contains
+ * the latest prompt, latest assistant summary, and modified timestamp.
+ */
+async function parseCodexSessionJsonlFast(filePath, fallbackSessionId) {
+    let fh;
+    try {
+        fh = await open(filePath, "r");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const fileStat = await fh.stat();
+        const fileSize = fileStat.size;
+        if (fileSize === 0)
+            return null;
+        if (fileSize <= CODEX_HEAD_BYTES + CODEX_TAIL_BYTES) {
+            const buf = Buffer.alloc(fileSize);
+            await fh.read(buf, 0, fileSize, 0);
+            return parseCodexSessionJsonl(buf.toString("utf-8"), fallbackSessionId);
+        }
+        const headBuf = Buffer.alloc(CODEX_HEAD_BYTES);
+        await fh.read(headBuf, 0, CODEX_HEAD_BYTES, 0);
+        const tailBuf = Buffer.alloc(CODEX_TAIL_BYTES);
+        await fh.read(tailBuf, 0, CODEX_TAIL_BYTES, fileSize - CODEX_TAIL_BYTES);
+        const tailRaw = tailBuf.toString("utf-8");
+        const firstNewline = tailRaw.indexOf("\n");
+        const cleanTail = firstNewline >= 0 ? tailRaw.slice(firstNewline + 1) : "";
+        const partialRaw = `${headBuf.toString("utf-8")}\n${cleanTail}`;
+        return parseCodexSessionJsonl(partialRaw, fallbackSessionId);
+    }
+    finally {
+        await fh.close();
+    }
+}
 function isCodexInternalSessionSource(source) {
     const sourceObj = asObject(source);
     return sourceObj?.subagent !== undefined;
@@ -1343,17 +1445,12 @@ async function getAllRecentCodexSessions(options = {}) {
     const threadNames = await loadCodexSessionNames();
     const threadProfiles = await loadCodexSessionProfiles();
     const threadAdditionalWritableRoots = await loadCodexSessionAdditionalWritableRoots();
-    for (const filePath of files) {
-        let raw;
-        try {
-            raw = await readFile(filePath, "utf-8");
-        }
-        catch {
-            continue;
-        }
-        options.perfStats && (options.perfStats.filesRead += 1);
+    const parsedResults = await parallelMap(files, PARALLEL_FILE_READ_LIMIT, async (filePath) => {
         const fallbackSessionId = basename(filePath, ".jsonl");
-        const parsed = parseCodexSessionJsonl(raw, fallbackSessionId);
+        return parseCodexSessionJsonlFast(filePath, fallbackSessionId);
+    });
+    for (const parsed of parsedResults) {
+        options.perfStats && (options.perfStats.filesRead += 1);
         if (!parsed)
             continue;
         if (normalizedProjectPath && parsed.entry.projectPath !== normalizedProjectPath) {
@@ -1383,6 +1480,49 @@ async function getAllRecentCodexSessions(options = {}) {
     }
     return entries;
 }
+function matchingCodexThreadIdFromFilePath(filePath, wantedThreadIds) {
+    const fallbackSessionId = basename(filePath, ".jsonl");
+    if (wantedThreadIds.has(fallbackSessionId))
+        return fallbackSessionId;
+    for (const threadId of wantedThreadIds) {
+        if (fallbackSessionId.endsWith(`-${threadId}`))
+            return threadId;
+    }
+    return null;
+}
+export async function getCodexSessionIndexMetadata(threadIds) {
+    const wantedThreadIds = new Set(threadIds.filter((id) => id.length > 0));
+    const result = new Map();
+    if (wantedThreadIds.size === 0)
+        return result;
+    const files = await listCodexSessionFiles();
+    const targets = [];
+    const matchedThreadIds = new Set();
+    for (const filePath of files) {
+        const threadId = matchingCodexThreadIdFromFilePath(filePath, wantedThreadIds);
+        if (!threadId || matchedThreadIds.has(threadId))
+            continue;
+        targets.push(filePath);
+        matchedThreadIds.add(threadId);
+        if (matchedThreadIds.size === wantedThreadIds.size)
+            break;
+    }
+    const parsedResults = await parallelMap(targets, PARALLEL_FILE_READ_LIMIT, async (filePath) => {
+        const fallbackSessionId = basename(filePath, ".jsonl");
+        return parseCodexSessionJsonlFast(filePath, fallbackSessionId);
+    });
+    for (const parsed of parsedResults) {
+        if (!parsed || !wantedThreadIds.has(parsed.threadId))
+            continue;
+        result.set(parsed.threadId, {
+            ...(parsed.entry.codexSettings
+                ? { codexSettings: parsed.entry.codexSettings }
+                : {}),
+            ...(parsed.entry.resumeCwd ? { resumeCwd: parsed.entry.resumeCwd } : {}),
+        });
+    }
+    return result;
+}
 export function codexUserTurnUuid(ordinal) {
     return `codex:user-turn:${ordinal}`;
 }