codex-mobile-re 0.1.131 → 0.1.133

package/dist/index.html

@@ -36,8 +36,8 @@
     <link rel="preload" as="font" type="font/woff2" href="/fonts/ibm-plex-sans-400.woff2" crossorigin />
     <link rel="preload" as="font" type="font/woff2" href="/fonts/ibm-plex-mono-400.woff2" crossorigin />
     <title>Codex Web</title>
-    <script type="module" crossorigin src="/assets/index-ClI-fbXf.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DthBwStG.css">
+    <script type="module" crossorigin src="/assets/index-CMrfiiel.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dm1iQsik.css">
   </head>
   <body>
     <div id="app"></div>

package/dist-cli/index.js

@@ -5077,6 +5077,210 @@ async function handleSkillsRoutes(req, res, url, context) {
 // src/server/telegramThreadBridge.ts
 import { basename as basename2 } from "path";
 
+// src/server/bridge/threadTurnPage.ts
+var ThreadTurnPageUnsupportedError = class extends Error {
+  constructor(cause) {
+    super(`thread/turns/list is not supported by this app-server: ${getErrorMessage(cause, "unknown error")}`);
+    this.name = "ThreadTurnPageUnsupportedError";
+  }
+};
+var TURN_LIST_UNSUPPORTED_PATTERN = /-32601|not supported|not implemented|unknown variant|method not found|unknown method/i;
+function isTurnListUnsupportedError(error) {
+  return TURN_LIST_UNSUPPORTED_PATTERN.test(getErrorMessage(error, ""));
+}
+var TURN_ID_PAGE_SIZE = 1e4;
+var TURN_ID_MAX_PAGES = 50;
+var TURN_LIST_SERVER_PAGE_CLAMP = 100;
+var ThreadTurnPageCursorChain = class {
+  constructor(options = {}) {
+    this.cursorByThreadId = /* @__PURE__ */ new Map();
+    this.maxThreads = options.maxThreads ?? 64;
+    this.maxTurnsPerThread = options.maxTurnsPerThread ?? 256;
+  }
+  /** Record that `olderCursor` reaches the turns just before `oldestTurnId`. */
+  record(threadId, oldestTurnId, olderCursor) {
+    if (!threadId || !oldestTurnId) return;
+    const cursor = readNonEmptyString(olderCursor);
+    if (!cursor) return;
+    let perThread = this.cursorByThreadId.get(threadId);
+    if (!perThread) {
+      perThread = /* @__PURE__ */ new Map();
+      this.cursorByThreadId.set(threadId, perThread);
+      if (this.cursorByThreadId.size > this.maxThreads) {
+        const oldestThreadId = this.cursorByThreadId.keys().next().value;
+        if (typeof oldestThreadId === "string") this.cursorByThreadId.delete(oldestThreadId);
+      }
+    }
+    perThread.delete(oldestTurnId);
+    perThread.set(oldestTurnId, cursor);
+    if (perThread.size > this.maxTurnsPerThread) {
+      const oldestTurnId2 = perThread.keys().next().value;
+      if (typeof oldestTurnId2 === "string") perThread.delete(oldestTurnId2);
+    }
+  }
+  lookup(threadId, turnId) {
+    if (!threadId || !turnId) return null;
+    const perThread = this.cursorByThreadId.get(threadId);
+    if (!perThread) return null;
+    const cursor = perThread.get(turnId);
+    if (cursor === void 0) return null;
+    perThread.delete(turnId);
+    perThread.set(turnId, cursor);
+    return cursor;
+  }
+  clear(threadId) {
+    if (threadId) this.cursorByThreadId.delete(threadId);
+    else this.cursorByThreadId.clear();
+  }
+  /**
+   * Restore a persisted snapshot (round-136). Entries go in through `record`,
+   * so the caps and the least-recently-recorded eviction order apply to restored
+   * anchors exactly as they do to fresh ones -- the caller therefore feeds the
+   * snapshot oldest-first, and a snapshot older than the caps degrades to "the
+   * newest entries survive" rather than to a rejected file.
+   */
+  hydrate(state) {
+    if (!state) return;
+    for (const [threadId, perThread] of Object.entries(state)) {
+      for (const [turnId, cursor] of Object.entries(perThread ?? {})) {
+        this.record(threadId, turnId, cursor);
+      }
+    }
+  }
+  /** What is currently known, oldest registration first (the persist order). */
+  snapshot() {
+    const state = {};
+    for (const [threadId, perThread] of this.cursorByThreadId) {
+      const entries = {};
+      for (const [turnId, cursor] of perThread) entries[turnId] = cursor;
+      if (Object.keys(entries).length > 0) state[threadId] = entries;
+    }
+    return state;
+  }
+};
+async function readThreadTurnIds(rpc, threadId) {
+  if (!threadId) return null;
+  const descending = [];
+  let cursor = "";
+  for (let page = 0; page < TURN_ID_MAX_PAGES; page += 1) {
+    const params = {
+      threadId,
+      limit: TURN_ID_PAGE_SIZE,
+      sortDirection: "desc",
+      itemsView: "notLoaded"
+    };
+    if (cursor) params.cursor = cursor;
+    let result;
+    try {
+      result = await rpc("thread/turns/list", params);
+    } catch (error) {
+      if (isTurnListUnsupportedError(error)) throw new ThreadTurnPageUnsupportedError(error);
+      return null;
+    }
+    const record = asRecord(result);
+    if (!record || !Array.isArray(record.data)) return null;
+    for (const turn of record.data) {
+      const turnId = readNonEmptyString(asRecord(turn)?.id);
+      if (!turnId) return null;
+      descending.push(turnId);
+    }
+    const nextCursor = readNonEmptyString(record.nextCursor);
+    if (!nextCursor) return descending.reverse();
+    cursor = nextCursor;
+  }
+  return null;
+}
+async function buildThreadTurnPage(rpc, threadId, turns, startTurnIndex, hasMoreOlder) {
+  let metadata;
+  try {
+    metadata = await rpc("thread/read", { threadId, includeTurns: false });
+  } catch {
+    return null;
+  }
+  const record = asRecord(metadata);
+  const thread = asRecord(record?.thread);
+  if (!record || !thread) return null;
+  return {
+    result: { ...record, thread: { ...thread, turns } },
+    startTurnIndex,
+    hasMoreOlder
+  };
+}
+async function readBoundedThreadTurnPage(deps, threadId, beforeTurnId, limit) {
+  if (!threadId || !beforeTurnId) return null;
+  const pageSize = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1;
+  const ids = await readThreadTurnIds(deps.rpc, threadId);
+  if (!ids) return null;
+  const beforeIndex = ids.indexOf(beforeTurnId);
+  if (beforeIndex < 0) {
+    return await buildThreadTurnPage(deps.rpc, threadId, [], 0, false);
+  }
+  const startTurnIndex = Math.max(0, beforeIndex - pageSize);
+  const wanted = beforeIndex - startTurnIndex;
+  let turns = [];
+  let boundaryTurnId = "";
+  let boundaryCursor = null;
+  if (wanted > 0) {
+    const cursor = await resolveChainCursor(deps, threadId, ids, beforeIndex);
+    if (!cursor) return null;
+    let page;
+    try {
+      page = await deps.rpc("thread/turns/list", {
+        threadId,
+        cursor,
+        sortDirection: "desc",
+        limit: wanted,
+        itemsView: "full"
+      });
+    } catch (error) {
+      if (isTurnListUnsupportedError(error)) throw new ThreadTurnPageUnsupportedError(error);
+      return null;
+    }
+    const record = asRecord(page);
+    const data = Array.isArray(record?.data) ? record.data : null;
+    if (!data || data.length !== wanted) return null;
+    const ascending = [...data].reverse();
+    if (readNonEmptyString(asRecord(ascending[0])?.id) !== ids[startTurnIndex]) return null;
+    if (wanted > 1 && readNonEmptyString(asRecord(ascending[wanted - 1])?.id) !== ids[beforeIndex - 1]) {
+      return null;
+    }
+    turns = ascending;
+    boundaryTurnId = ids[startTurnIndex];
+    boundaryCursor = record?.nextCursor ?? null;
+  }
+  const built = await buildThreadTurnPage(deps.rpc, threadId, turns, startTurnIndex, startTurnIndex > 0);
+  if (!built) return null;
+  if (boundaryTurnId) deps.chain.record(threadId, boundaryTurnId, boundaryCursor);
+  return built;
+}
+async function resolveChainCursor(deps, threadId, ids, beforeIndex) {
+  const anchorTurnId = ids[beforeIndex];
+  if (!anchorTurnId) return null;
+  const known = deps.chain.lookup(threadId, anchorTurnId);
+  if (known) return known;
+  const span = ids.length - beforeIndex;
+  if (span < 1 || span > TURN_LIST_SERVER_PAGE_CLAMP) return null;
+  let page;
+  try {
+    page = await deps.rpc("thread/turns/list", {
+      threadId,
+      limit: span,
+      sortDirection: "desc",
+      itemsView: "notLoaded"
+    });
+  } catch (error) {
+    if (isTurnListUnsupportedError(error)) throw new ThreadTurnPageUnsupportedError(error);
+    return null;
+  }
+  const record = asRecord(page);
+  const data = Array.isArray(record?.data) ? record.data : null;
+  const oldestTurnId = data ? readNonEmptyString(asRecord(data[data.length - 1])?.id) : "";
+  const cursor = readNonEmptyString(record?.nextCursor);
+  if (!data || oldestTurnId !== anchorTurnId || !cursor) return null;
+  deps.chain.record(threadId, anchorTurnId, cursor);
+  return cursor;
+}
+
 // src/server/bridge/threadResumeTurnPage.ts
 var TURN_COUNT_PAGE_SIZE = 1e4;
 var TURN_COUNT_MAX_PAGES = 50;
@@ -5132,6 +5336,35 @@ async function readThreadTurnCount(rpc, threadId) {
   }
   return null;
 }
+var TERMINAL_TURN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "declined", "interrupted", "error"]);
+function readTurnStatus(turn) {
+  const record = asRecord(turn);
+  const raw = record?.status;
+  const text = readNonEmptyString(raw) || readNonEmptyString(asRecord(raw)?.type);
+  return text.toLowerCase();
+}
+function dropTurnsMissingFromIndex(pageData, indexTurnIds) {
+  const known = new Set(indexTurnIds);
+  return pageData.filter((turn) => {
+    const turnId = readNonEmptyString(asRecord(turn)?.id);
+    if (!turnId || known.has(turnId)) return true;
+    return !TERMINAL_TURN_STATUSES.has(readTurnStatus(turn));
+  });
+}
+async function readAuthoritativeTurnIds(rpc, threadId) {
+  if (!threadId) return null;
+  try {
+    return await readThreadTurnIds(rpc, threadId);
+  } catch {
+    return null;
+  }
+}
+function withResumePageTurns(result, turns) {
+  const record = asRecord(result);
+  const page = asRecord(record?.initialTurnsPage);
+  if (!record || !page) return result;
+  return { ...record, initialTurnsPage: { ...page, data: turns } };
+}
 function promoteResumeTurnPage(result, totalTurnCount) {
   const record = asRecord(result);
   const thread = asRecord(record?.thread);
@@ -5154,28 +5387,35 @@ async function resumeThreadWithTurnPage(deps, originalParams) {
   if (!isThreadResumeTurnPageSupported(result)) {
     return await deps.sendResume(originalParams);
   }
-  const pageData = readPageData(result) ?? [];
+  const threadId = readNonEmptyString(asRecord(asRecord(result)?.thread)?.id);
   const page = asRecord(asRecord(result)?.initialTurnsPage);
+  const pageData = readPageData(result) ?? [];
+  const indexTurnIds = await readAuthoritativeTurnIds(deps.rpc, threadId);
   if (pageData.length === 0) {
-    const threadId = readNonEmptyString(asRecord(asRecord(result)?.thread)?.id);
-    const turnCount = await readThreadTurnCount(deps.rpc, threadId);
-    if (turnCount === null || turnCount > 0) return await deps.sendResume(originalParams);
+    if (indexTurnIds === null || indexTurnIds.length > 0) return await deps.sendResume(originalParams);
   }
-  const oldestTurnId = readNonEmptyString(asRecord(pageData[pageData.length - 1])?.id);
-  if (oldestTurnId && deps.onTurnPageBoundary) {
-    deps.onTurnPageBoundary(
-      readNonEmptyString(asRecord(asRecord(result)?.thread)?.id),
-      oldestTurnId,
-      readNonEmptyString(page?.nextCursor) || null
-    );
+  let promoted = result;
+  let pageTurns = pageData;
+  if (pageData.length > 0 && indexTurnIds !== null && indexTurnIds.length > 0) {
+    const kept = dropTurnsMissingFromIndex(pageData, indexTurnIds);
+    if (kept.length !== pageData.length) {
+      const oldestKeptTurnId = readNonEmptyString(asRecord(kept[kept.length - 1])?.id);
+      const anchored = kept.length > 0 && oldestKeptTurnId !== "" && indexTurnIds[indexTurnIds.length - kept.length] === oldestKeptTurnId;
+      if (anchored) {
+        promoted = withResumePageTurns(result, kept);
+        pageTurns = kept;
+      }
+    }
   }
-  const needsCount = pageData.length > 0 && readNonEmptyString(page?.nextCursor) !== "";
-  let totalTurnCount = pageData.length;
-  if (needsCount) {
-    const threadId = readNonEmptyString(asRecord(asRecord(result)?.thread)?.id);
-    totalTurnCount = await readThreadTurnCount(deps.rpc, threadId);
+  const oldestTurnId = readNonEmptyString(asRecord(pageTurns[pageTurns.length - 1])?.id);
+  if (oldestTurnId && deps.onTurnPageBoundary) {
+    deps.onTurnPageBoundary(threadId, oldestTurnId, readNonEmptyString(page?.nextCursor) || null);
   }
-  return promoteResumeTurnPage(result, totalTurnCount);
+  const needsCount = pageTurns.length > 0 && readNonEmptyString(page?.nextCursor) !== "";
+  let totalTurnCount = pageTurns.length;
+  if (indexTurnIds !== null) totalTurnCount = indexTurnIds.length;
+  else if (needsCount) totalTurnCount = await readThreadTurnCount(deps.rpc, threadId);
+  return promoteResumeTurnPage(promoted, totalTurnCount);
 }
 
 // src/server/bridge/threadReadTurnPage.ts
@@ -12006,210 +12246,6 @@ async function runRpcResponsePipeline(deps, method, rpcResult) {
   return method === "thread/list" ? overlayExternalSessionOnThreadList(externalSessionTracker, dedupedResult) : THREAD_METHODS_WITH_TURNS.has(method) ? overlayExternalSessionOnThreadResult(externalSessionTracker, dedupedResult) : dedupedResult;
 }
 
-// src/server/bridge/threadTurnPage.ts
-var ThreadTurnPageUnsupportedError = class extends Error {
-  constructor(cause) {
-    super(`thread/turns/list is not supported by this app-server: ${getErrorMessage(cause, "unknown error")}`);
-    this.name = "ThreadTurnPageUnsupportedError";
-  }
-};
-var TURN_LIST_UNSUPPORTED_PATTERN = /-32601|not supported|not implemented|unknown variant|method not found|unknown method/i;
-function isTurnListUnsupportedError(error) {
-  return TURN_LIST_UNSUPPORTED_PATTERN.test(getErrorMessage(error, ""));
-}
-var TURN_ID_PAGE_SIZE = 1e4;
-var TURN_ID_MAX_PAGES = 50;
-var TURN_LIST_SERVER_PAGE_CLAMP = 100;
-var ThreadTurnPageCursorChain = class {
-  constructor(options = {}) {
-    this.cursorByThreadId = /* @__PURE__ */ new Map();
-    this.maxThreads = options.maxThreads ?? 64;
-    this.maxTurnsPerThread = options.maxTurnsPerThread ?? 256;
-  }
-  /** Record that `olderCursor` reaches the turns just before `oldestTurnId`. */
-  record(threadId, oldestTurnId, olderCursor) {
-    if (!threadId || !oldestTurnId) return;
-    const cursor = readNonEmptyString(olderCursor);
-    if (!cursor) return;
-    let perThread = this.cursorByThreadId.get(threadId);
-    if (!perThread) {
-      perThread = /* @__PURE__ */ new Map();
-      this.cursorByThreadId.set(threadId, perThread);
-      if (this.cursorByThreadId.size > this.maxThreads) {
-        const oldestThreadId = this.cursorByThreadId.keys().next().value;
-        if (typeof oldestThreadId === "string") this.cursorByThreadId.delete(oldestThreadId);
-      }
-    }
-    perThread.delete(oldestTurnId);
-    perThread.set(oldestTurnId, cursor);
-    if (perThread.size > this.maxTurnsPerThread) {
-      const oldestTurnId2 = perThread.keys().next().value;
-      if (typeof oldestTurnId2 === "string") perThread.delete(oldestTurnId2);
-    }
-  }
-  lookup(threadId, turnId) {
-    if (!threadId || !turnId) return null;
-    const perThread = this.cursorByThreadId.get(threadId);
-    if (!perThread) return null;
-    const cursor = perThread.get(turnId);
-    if (cursor === void 0) return null;
-    perThread.delete(turnId);
-    perThread.set(turnId, cursor);
-    return cursor;
-  }
-  clear(threadId) {
-    if (threadId) this.cursorByThreadId.delete(threadId);
-    else this.cursorByThreadId.clear();
-  }
-  /**
-   * Restore a persisted snapshot (round-136). Entries go in through `record`,
-   * so the caps and the least-recently-recorded eviction order apply to restored
-   * anchors exactly as they do to fresh ones -- the caller therefore feeds the
-   * snapshot oldest-first, and a snapshot older than the caps degrades to "the
-   * newest entries survive" rather than to a rejected file.
-   */
-  hydrate(state) {
-    if (!state) return;
-    for (const [threadId, perThread] of Object.entries(state)) {
-      for (const [turnId, cursor] of Object.entries(perThread ?? {})) {
-        this.record(threadId, turnId, cursor);
-      }
-    }
-  }
-  /** What is currently known, oldest registration first (the persist order). */
-  snapshot() {
-    const state = {};
-    for (const [threadId, perThread] of this.cursorByThreadId) {
-      const entries = {};
-      for (const [turnId, cursor] of perThread) entries[turnId] = cursor;
-      if (Object.keys(entries).length > 0) state[threadId] = entries;
-    }
-    return state;
-  }
-};
-async function readThreadTurnIds(rpc, threadId) {
-  if (!threadId) return null;
-  const descending = [];
-  let cursor = "";
-  for (let page = 0; page < TURN_ID_MAX_PAGES; page += 1) {
-    const params = {
-      threadId,
-      limit: TURN_ID_PAGE_SIZE,
-      sortDirection: "desc",
-      itemsView: "notLoaded"
-    };
-    if (cursor) params.cursor = cursor;
-    let result;
-    try {
-      result = await rpc("thread/turns/list", params);
-    } catch (error) {
-      if (isTurnListUnsupportedError(error)) throw new ThreadTurnPageUnsupportedError(error);
-      return null;
-    }
-    const record = asRecord(result);
-    if (!record || !Array.isArray(record.data)) return null;
-    for (const turn of record.data) {
-      const turnId = readNonEmptyString(asRecord(turn)?.id);
-      if (!turnId) return null;
-      descending.push(turnId);
-    }
-    const nextCursor = readNonEmptyString(record.nextCursor);
-    if (!nextCursor) return descending.reverse();
-    cursor = nextCursor;
-  }
-  return null;
-}
-async function buildThreadTurnPage(rpc, threadId, turns, startTurnIndex, hasMoreOlder) {
-  let metadata;
-  try {
-    metadata = await rpc("thread/read", { threadId, includeTurns: false });
-  } catch {
-    return null;
-  }
-  const record = asRecord(metadata);
-  const thread = asRecord(record?.thread);
-  if (!record || !thread) return null;
-  return {
-    result: { ...record, thread: { ...thread, turns } },
-    startTurnIndex,
-    hasMoreOlder
-  };
-}
-async function readBoundedThreadTurnPage(deps, threadId, beforeTurnId, limit) {
-  if (!threadId || !beforeTurnId) return null;
-  const pageSize = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1;
-  const ids = await readThreadTurnIds(deps.rpc, threadId);
-  if (!ids) return null;
-  const beforeIndex = ids.indexOf(beforeTurnId);
-  if (beforeIndex < 0) {
-    return await buildThreadTurnPage(deps.rpc, threadId, [], 0, false);
-  }
-  const startTurnIndex = Math.max(0, beforeIndex - pageSize);
-  const wanted = beforeIndex - startTurnIndex;
-  let turns = [];
-  let boundaryTurnId = "";
-  let boundaryCursor = null;
-  if (wanted > 0) {
-    const cursor = await resolveChainCursor(deps, threadId, ids, beforeIndex);
-    if (!cursor) return null;
-    let page;
-    try {
-      page = await deps.rpc("thread/turns/list", {
-        threadId,
-        cursor,
-        sortDirection: "desc",
-        limit: wanted,
-        itemsView: "full"
-      });
-    } catch (error) {
-      if (isTurnListUnsupportedError(error)) throw new ThreadTurnPageUnsupportedError(error);
-      return null;
-    }
-    const record = asRecord(page);
-    const data = Array.isArray(record?.data) ? record.data : null;
-    if (!data || data.length !== wanted) return null;
-    const ascending = [...data].reverse();
-    if (readNonEmptyString(asRecord(ascending[0])?.id) !== ids[startTurnIndex]) return null;
-    if (wanted > 1 && readNonEmptyString(asRecord(ascending[wanted - 1])?.id) !== ids[beforeIndex - 1]) {
-      return null;
-    }
-    turns = ascending;
-    boundaryTurnId = ids[startTurnIndex];
-    boundaryCursor = record?.nextCursor ?? null;
-  }
-  const built = await buildThreadTurnPage(deps.rpc, threadId, turns, startTurnIndex, startTurnIndex > 0);
-  if (!built) return null;
-  if (boundaryTurnId) deps.chain.record(threadId, boundaryTurnId, boundaryCursor);
-  return built;
-}
-async function resolveChainCursor(deps, threadId, ids, beforeIndex) {
-  const anchorTurnId = ids[beforeIndex];
-  if (!anchorTurnId) return null;
-  const known = deps.chain.lookup(threadId, anchorTurnId);
-  if (known) return known;
-  const span = ids.length - beforeIndex;
-  if (span < 1 || span > TURN_LIST_SERVER_PAGE_CLAMP) return null;
-  let page;
-  try {
-    page = await deps.rpc("thread/turns/list", {
-      threadId,
-      limit: span,
-      sortDirection: "desc",
-      itemsView: "notLoaded"
-    });
-  } catch (error) {
-    if (isTurnListUnsupportedError(error)) throw new ThreadTurnPageUnsupportedError(error);
-    return null;
-  }
-  const record = asRecord(page);
-  const data = Array.isArray(record?.data) ? record.data : null;
-  const oldestTurnId = data ? readNonEmptyString(asRecord(data[data.length - 1])?.id) : "";
-  const cursor = readNonEmptyString(record?.nextCursor);
-  if (!data || oldestTurnId !== anchorTurnId || !cursor) return null;
-  deps.chain.record(threadId, anchorTurnId, cursor);
-  return cursor;
-}
-
 // src/server/bridge/rollbackTurnContext.ts
 async function readRollbackTurnContext(appServer, threadId) {
   if (!threadId) return null;