@ccpocket/bridge 1.86.2 → 1.87.0

package/dist/sessions-index.js

@@ -145,6 +145,7 @@ 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;
+const CODEX_MAX_TAIL_BYTES = 4 * 1024 * 1024;
 /**
  * Run async tasks with a concurrency limit.
  * Returns results in the same order as the input tasks.
@@ -1165,12 +1166,28 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
         }
         if (entry.type === "response_item") {
             const payload = entry.payload;
-            if (!payload || payload.type !== "message" || payload.role !== "assistant") {
+            if (!payload || payload.type !== "message") {
                 continue;
             }
             const content = payload.content;
             if (!Array.isArray(content))
                 continue;
+            if (payload.role === "user") {
+                const text = content
+                    .filter((item) => item.type === "input_text" && typeof item.text === "string")
+                    .map((item) => item.text)
+                    .join("\n")
+                    .trim();
+                if (text && !isCodexInjectedUserContext(text)) {
+                    hasMessages = true;
+                    if (!firstPrompt)
+                        firstPrompt = text;
+                    lastPrompt = text;
+                }
+                continue;
+            }
+            if (payload.role !== "assistant")
+                continue;
             const text = content
                 .filter((item) => item.type === "output_text" && typeof item.text === "string")
                 .map((item) => item.text)
@@ -1228,6 +1245,39 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
         codexRepositoryUrls.set(entry, repositoryUrl);
     return { threadId, entry };
 }
+function hasCodexUserMessage(raw) {
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const payload = entry.payload;
+        if (entry.type === "event_msg"
+            && payload?.type === "user_message"
+            && typeof payload.message === "string"
+            && !isCodexInjectedUserContext(payload.message)) {
+            return true;
+        }
+        if (entry.type === "response_item"
+            && payload?.type === "message"
+            && payload.role === "user"
+            && Array.isArray(payload.content)) {
+            const text = payload.content
+                .filter((item) => item.type === "input_text" && typeof item.text === "string")
+                .map((item) => item.text)
+                .join("\n")
+                .trim();
+            if (text && !isCodexInjectedUserContext(text))
+                return true;
+        }
+    }
+    return false;
+}
 /**
  * Fast parse a Codex JSONL file for recent-session list metadata.
  * The first chunk contains session_meta / first prompt; the tail chunk contains
@@ -1253,13 +1303,21 @@ async function parseCodexSessionJsonlFast(filePath, 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);
+        let tailBytes = CODEX_TAIL_BYTES;
+        while (true) {
+            const tailBuf = Buffer.alloc(tailBytes);
+            await fh.read(tailBuf, 0, tailBytes, fileSize - tailBytes);
+            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}`;
+            const parsed = parseCodexSessionJsonl(partialRaw, fallbackSessionId);
+            if (hasCodexUserMessage(cleanTail)
+                || tailBytes >= Math.min(fileSize, CODEX_MAX_TAIL_BYTES)) {
+                return parsed;
+            }
+            tailBytes = Math.min(tailBytes * 2, fileSize, CODEX_MAX_TAIL_BYTES);
+        }
     }
     finally {
         await fh.close();
@@ -1413,8 +1471,13 @@ export async function loadCodexSessionNames() {
             continue;
         try {
             const entry = JSON.parse(line);
-            if (entry.id && entry.thread_name) {
-                names.set(entry.id, entry.thread_name);
+            if (entry.id && typeof entry.thread_name === "string") {
+                if (entry.thread_name) {
+                    names.set(entry.id, entry.thread_name);
+                }
+                else {
+                    names.delete(entry.id);
+                }
             }
         }
         catch {
@@ -1583,8 +1646,10 @@ function matchingCodexThreadIdFromFilePath(filePath, wantedThreadIds) {
     if (wantedThreadIds.has(fallbackSessionId))
         return fallbackSessionId;
     for (const threadId of wantedThreadIds) {
-        if (fallbackSessionId.endsWith(`-${threadId}`))
+        if (fallbackSessionId.endsWith(`-${threadId}`)
+            || fallbackSessionId.includes(`-${threadId}_`)) {
             return threadId;
+        }
     }
     return null;
 }
@@ -1594,25 +1659,30 @@ export async function getCodexSessionIndexMetadata(threadIds) {
     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 targets = files.filter((filePath) => matchingCodexThreadIdFromFilePath(filePath, wantedThreadIds) !== null);
     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) {
+        const parsed = await parseCodexSessionJsonlFast(filePath, fallbackSessionId);
         if (!parsed || !wantedThreadIds.has(parsed.threadId))
+            return null;
+        try {
+            return { parsed, modified: (await stat(filePath)).mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    });
+    const newestByThread = new Map();
+    for (const candidate of parsedResults) {
+        if (!candidate)
             continue;
-        result.set(parsed.threadId, {
+        const existing = newestByThread.get(candidate.parsed.threadId);
+        if (!existing || candidate.modified > existing.modified) {
+            newestByThread.set(candidate.parsed.threadId, candidate);
+        }
+    }
+    for (const [threadId, { parsed }] of newestByThread) {
+        result.set(threadId, {
             ...(parsed.entry.codexSettings
                 ? { codexSettings: parsed.entry.codexSettings }
                 : {}),
@@ -2203,12 +2273,50 @@ async function findSessionJsonlPath(sessionId) {
 }
 async function findCodexSessionJsonlPath(threadId) {
     const files = await listCodexSessionFiles();
-    for (const filePath of files) {
+    const candidates = files.filter((filePath) => {
         const fallbackSessionId = basename(filePath, ".jsonl");
-        if (fallbackSessionId === threadId ||
-            fallbackSessionId.endsWith(`-${threadId}`)) {
-            return filePath;
+        return fallbackSessionId === threadId ||
+            fallbackSessionId.endsWith(`-${threadId}`) ||
+            fallbackSessionId.includes(`-${threadId}_`);
+    });
+    const matches = await parallelMap(candidates, PARALLEL_FILE_READ_LIMIT, async (filePath) => {
+        let file;
+        try {
+            file = await open(filePath, "r");
+            const metadata = await file.stat();
+            const buffer = Buffer.alloc(Math.min(metadata.size, CODEX_HEAD_BYTES));
+            const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+            // History/image lookup must not depend on list metadata (cwd or text).
+            // Older rollouts have no session_meta, so retain the filename fallback.
+            for (const line of buffer.subarray(0, bytesRead).toString("utf-8").split("\n")) {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry?.type === "session_meta" && typeof entry.payload?.id === "string") {
+                        if (entry.payload.id !== threadId)
+                            return null;
+                        break;
+                    }
+                }
+                catch {
+                    // Ignore partial or malformed header records.
+                }
+            }
+            return { filePath, modified: metadata.mtimeMs };
+        }
+        catch {
+            return null;
         }
+        finally {
+            await file?.close();
+        }
+    });
+    const newest = matches
+        .filter((match) => match !== null)
+        .sort((a, b) => b.modified - a.modified)[0];
+    if (newest)
+        return newest.filePath;
+    for (const filePath of files) {
+        const fallbackSessionId = basename(filePath, ".jsonl");
         let raw;
         try {
             raw = await readFile(filePath, "utf-8");