codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/backgroundUpdateSafety.js

@@ -0,0 +1,173 @@
+(function installBackgroundUpdateSafety(root) {
+  'use strict';
+  const blocked = () => ({ idle: false, saved: false, blockers: ['tab_probe_unavailable'] });
+  // Chrome storage serializes object keys independently of insertion order.
+  // Preserve every key/value and array position when comparing readback.
+  function sameStored(left, right) {
+    if (left === right) return true;
+    if (!left || !right || typeof left !== 'object' || typeof right !== 'object') return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+      return Array.isArray(left) && Array.isArray(right) && left.length === right.length
+        && left.every((value, index) => sameStored(value, right[index]));
+    }
+    const leftKeys = Object.keys(left), rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length
+      && leftKeys.every(key => Object.prototype.hasOwnProperty.call(right, key) && sameStored(left[key], right[key]));
+  }
+  function create(options) {
+    const bindings = new Map();
+    const tabsKey = 'codex-overleaf-managed-update-tabs-v1';
+    const guardKey = 'codex-overleaf-managed-update-guarded-tabs-v1';
+    async function ownerMatches(binding) {
+      if (!options.isExecutionLocked()) return false;
+      const response = await options.request({ id: crypto.randomUUID(), method: 'update.status',
+        params: { bootstrapRevision: String(root.__CODEX_OVERLEAF_BOOTSTRAP_REVISION__ || '') } });
+      const tx = response?.ok && response.result?.transaction;
+      return tx?.id === binding.transactionId && tx.targetVersion === binding.targetVersion
+        && tx.sourceVersion === binding.sourceVersion && tx.state === binding.expectedState;
+    }
+    async function snapshot(tabId, documentId) {
+      const results = await chrome.scripting.executeScript({ target: documentId ? { tabId, documentIds: [documentId] }
+        : { tabId, frameIds: [0] }, world: 'ISOLATED', func: () => ({ url: location.href }) });
+      const item = results?.length === 1 && results[0];
+      return item?.frameId === 0 && item.documentId && typeof item.result?.url === 'string'
+        ? { documentId: item.documentId, url: item.result.url } : null;
+    }
+    async function saveProbe(message, sender) {
+      const binding = bindings.get(sender?.tab?.id);
+      if (!binding || sender.id !== chrome.runtime.id || sender.frameId !== 0 || sender.documentId !== binding.documentId
+        || sender.url !== binding.url || message.token !== binding.token || message.transactionId !== binding.transactionId
+        || message.nonce !== binding.nonce || !await ownerMatches(binding)) return { ok: false };
+      const before = await snapshot(binding.tabId, binding.documentId);
+      if (before?.url !== binding.url) return { ok: false };
+      const results = await chrome.scripting.executeScript({ target: { tabId: binding.tabId, documentIds: [binding.documentId] },
+        world: 'MAIN', func: url => globalThis.CodexOverleafUpdateSafetyProbe?.probe(url), args: [binding.url] });
+      const after = await snapshot(binding.tabId, binding.documentId);
+      if (after?.url !== binding.url || message.nonce !== binding.nonce || !await ownerMatches(binding)
+        || results?.length !== 1 || results[0].documentId !== binding.documentId || results[0].frameId !== 0) return { ok: false };
+      return { ok: true, nonce: message.nonce, result: results[0].result };
+    }
+    chrome.runtime.onMessage.addListener((message, sender, respond) => {
+      if (message?.type !== 'codex-overleaf/migration-save-probe') return undefined;
+      saveProbe(message, sender).then(respond).catch(() => respond({ ok: false }));
+      return true;
+    });
+    async function probe(tab, owner) {
+      try {
+        const current = await snapshot(tab.id);
+        if (!current || current.url !== tab.url) return blocked();
+        let binding = bindings.get(tab.id);
+        if (binding && (binding.documentId !== current.documentId || binding.url !== current.url
+          || binding.transactionId !== owner.transactionId)) return blocked();
+        if (!binding) {
+          binding = { ...owner, ...current, tabId: tab.id, token: crypto.randomUUID(), nonce: '' };
+          if (!await ownerMatches(binding)) return blocked();
+          bindings.set(tab.id, binding);
+        }
+        binding.expectedState = owner.expectedState;
+        if (!binding.installed) {
+          const target = { tabId: tab.id, documentIds: [binding.documentId] };
+          await chrome.scripting.executeScript({ target, world: 'MAIN',
+            files: ['runtime/src/page/saveState.js', 'runtime/src/page/updateSafetyProbe.js'] });
+          await chrome.scripting.executeScript({ target, world: 'ISOLATED',
+            files: ['runtime/src/shared/pageRpcContract.js', 'runtime/src/content/updateIdle.js', 'runtime/src/content/updateSafetyReceiver.js'] });
+          const installed = await chrome.scripting.executeScript({ target, world: 'ISOLATED',
+            func: value => globalThis.CodexOverleafUpdateSafetyReceiver?.install(value, {
+              UpdateIdle: globalThis.CodexOverleafUpdateIdle, PageRpcContract: globalThis.CodexOverleafPageRpcContract
+            }), args: [binding] });
+          if (installed?.length !== 1 || installed[0].documentId !== binding.documentId
+            || installed[0].result?.ok !== true || installed[0].result.url !== binding.url) return blocked();
+          binding.installed = true;
+        }
+        if (!await ownerMatches(binding)) return blocked();
+        binding.nonce = crypto.randomUUID();
+        const nonce = binding.nonce;
+        let timer;
+        const response = await Promise.race([
+          chrome.tabs.sendMessage(tab.id, { type: 'codex-overleaf/migration-idle-probe', ...binding },
+            { documentId: binding.documentId }),
+          new Promise(resolve => { timer = setTimeout(() => resolve(null), 3500); })
+        ]).finally(() => clearTimeout(timer));
+        const after = await snapshot(tab.id, binding.documentId);
+        if (!response?.safetyOnly || response.token !== binding.token || response.transactionId !== binding.transactionId
+          || response.targetVersion !== binding.targetVersion || response.nonce !== nonce || response.url !== binding.url
+          || after?.url !== binding.url || !await ownerMatches(binding)) return blocked();
+        return response;
+      } catch (_) { return blocked(); }
+    }
+    async function protectReloadTabs(transaction) {
+      const owner = { transactionId: transaction.id, sourceVersion: transaction.sourceVersion,
+        targetVersion: transaction.targetVersion, expectedState: 'bootstrap_pending' };
+      if (!await ownerMatches(owner)) return false;
+      const stored = await chrome.storage.local.get([tabsKey, guardKey]);
+      if (stored[guardKey]?.transactionId === transaction.id && !stored[tabsKey]?.length) return true;
+      if (stored[guardKey]?.state === 'guarded' && stored[guardKey].transactionId !== transaction.id) {
+        const open = new Set((await chrome.tabs.query({})).map(tab => tab.id));
+        for (const entry of stored[guardKey].entries || []) {
+          if (!open.has(entry.tabId)) continue;
+          const current = await snapshot(entry.tabId).catch(() => null);
+          if (!entry.documentId || !current || current.documentId === entry.documentId) return false;
+        }
+      }
+      const entries = await Promise.all((stored[tabsKey] || []).map(async tabId => ({ tabId,
+        ...await snapshot(tabId).catch(() => null) })));
+      const guard = { transactionId: transaction.id, sourceVersion: transaction.sourceVersion,
+        targetVersion: transaction.targetVersion, state: 'guarded', entries };
+      const current = await chrome.storage.local.get([tabsKey, guardKey]);
+      if (!sameStored(current, stored) || !await ownerMatches(owner)) return false;
+      await chrome.storage.local.set({ [guardKey]: guard, [tabsKey]: [] });
+      const readback = await chrome.storage.local.get([tabsKey, guardKey]);
+      return sameStored(readback[guardKey], guard) && readback[tabsKey]?.length === 0;
+    }
+    async function releaseReloadTabs(transaction, expectedState = 'bootstrap_pending') {
+      const owner = { transactionId: transaction.id, sourceVersion: transaction.sourceVersion,
+        targetVersion: transaction.targetVersion, expectedState };
+      if (!await ownerMatches(owner)) return false;
+      const stored = await chrome.storage.local.get([tabsKey, guardKey]);
+      const guard = stored[guardKey];
+      if (guard?.transactionId !== transaction.id || guard.state !== 'guarded' || stored[tabsKey]?.length) return false;
+      const open = new Set((await chrome.tabs.query({})).map(tab => tab.id));
+      const ids = [];
+      for (const entry of guard.entries) {
+        if (!open.has(entry.tabId)) continue;
+        if (!entry.documentId || !entry.url) return false;
+        const current = await snapshot(entry.tabId, entry.documentId).catch(() => null);
+        if (current?.documentId !== entry.documentId || current?.url !== entry.url) return false;
+        ids.push(entry.tabId);
+      }
+      const again = await chrome.storage.local.get([tabsKey, guardKey]);
+      if (!sameStored(again[guardKey], guard) || again[tabsKey]?.length || !await ownerMatches(owner)) return false;
+      await chrome.storage.local.set({ [tabsKey]: ids, [guardKey]: { ...guard, state: 'ready' } });
+      return true;
+    }
+    async function revalidate(tabs, owner) {
+      if (!await ownerMatches(owner)) return false;
+      for (const tab of tabs) {
+        const binding = bindings.get(tab.id);
+        if (!binding || binding.transactionId !== owner.transactionId) continue;
+        if ((await probe(tab, owner)).idle !== true) return false;
+      }
+      return ownerMatches(owner);
+    }
+    async function hasReplacedReloadDocument(transaction) {
+      const owner = { transactionId: transaction.id, sourceVersion: transaction.sourceVersion,
+        targetVersion: transaction.targetVersion, expectedState: 'rolled_back' };
+      if (!await ownerMatches(owner)) return false;
+      const stored = await chrome.storage.local.get([tabsKey, guardKey]);
+      const guard = stored[guardKey];
+      if (guard?.transactionId !== transaction.id || guard.state !== 'guarded' || stored[tabsKey]?.length) return false;
+      const open = new Set((await chrome.tabs.query({})).map(tab => tab.id));
+      for (const entry of guard.entries) {
+        if (!open.has(entry.tabId) || !entry.documentId) continue;
+        const current = await snapshot(entry.tabId).catch(() => null);
+        if (current && current.documentId !== entry.documentId) {
+          const again = await chrome.storage.local.get([tabsKey, guardKey]);
+          return sameStored(again, stored) && await ownerMatches(owner);
+        }
+      }
+      return false;
+    }
+    return Object.freeze({ probe, protectReloadTabs, releaseReloadTabs, revalidate, hasReplacedReloadDocument });
+  }
+  root.CodexOverleafBackgroundUpdateSafety = Object.freeze({ create });
+})(globalThis);

package/extension/src/content/activeTurnControl.js

@@ -94,12 +94,19 @@
       const journals = await listJournals(projectKey).catch(() => []);
       let changed = false;
       const acknowledgeIds = [];
+      const recoveredRuns = [];
       for (const journal of journals) {
         if (!journal?.terminal && !journal?.ownerLost) {
           continue;
         }
+        // Native completion can precede the owner's writeback and durable
+        // session save. A passive shared-history reader must not settle it.
+        if (options.requireOwnerLost === true && journal.ownerLost !== true) {
+          continue;
+        }
         const session = options.findSession?.(journal.sessionId);
-        if (!session) {
+        if (!session || (session.projectId && session.projectId !== projectKey)
+          || (options.accountScopeId && session.accountScopeId && session.accountScopeId !== options.accountScopeId)) {
           continue;
         }
         let record = (session.runs || []).find(run => run.id === journal.clientRunId);
@@ -112,6 +119,11 @@
         if (!record) {
           continue;
         }
+        if (record.runProjectId && record.runProjectId !== projectKey) continue;
+        if (!record.runProjectId) record.runProjectId = projectKey;
+        if (record.status === 'running') {
+          options.normalizeInterruptedRun?.(record);
+        }
         const reloadReports = (record.events || []).filter(event => event?.failure?.source === 'panel_reload');
         record.events = (record.events || []).filter(event => event?.failure?.source !== 'panel_reload');
         const lastSequence = Number(record.nativeEventSeq || 0);
@@ -155,8 +167,10 @@
         options.pauseSessionQueue?.(session, 'page_reload');
         changed = true;
         acknowledgeIds.push(journal.requestId);
+        recoveredRuns.push({ sessionId: session.id, runId: record.id,
+          projectId: projectKey, accountScopeId: options.accountScopeId });
       }
-      return { changed, acknowledgeIds };
+      return { changed, acknowledgeIds, recoveredRuns };
     }
 
     function destroy() {

package/extension/src/content/applyResultFormatters.js

@@ -85,7 +85,8 @@
    */
   function normalizeSkippedFailure(item) {
     if (!FailureReasons || !FailureReasons.normalizeFailureReason) return null;
-    const failure = FailureReasons.normalizeFailureReason(item?.result, item?.operation || {}, { locale: getLocale() });
+    const normalize = FailureReasons.normalizeWritebackFailure || FailureReasons.normalizeFailureReason;
+    const failure = normalize(item?.result, item?.operation || {}, { locale: getLocale() });
     if (!failure || !failure.code) return null;
     const localized = FailureReasons.localizeFailureReason
       ? FailureReasons.localizeFailureReason(failure, getLocale(), failureReasonI18nLookup)
@@ -98,7 +99,7 @@
 
   function pickPrimarySkippedFailure(failures) {
     if (!FailureReasons || !FailureReasons.selectPrimaryFailure) return null;
-    return FailureReasons.selectPrimaryFailure(failures);
+    return (FailureReasons.selectPrimaryWritebackFailure || FailureReasons.selectPrimaryFailure)(failures);
   }
 
   function failureReasonI18nLookup(key) {
@@ -134,6 +135,8 @@
     const code = result.code || '';
     const filePath = result.reasonParams?.filePath || operation.path || operation.from || operation.to || '';
     const withDebug = reason => appendApplyResultDebug(reason, result);
+    const catalogReason = formatCatalogFailureReason(result, filePath);
+    if (catalogReason) return withDebug(catalogReason);
     if (key === 'missingBaseFile' || code === 'missing_base_file') {
       const target = filePath || tx('this file', '这个文件');
       return withDebug(tx(
@@ -236,82 +239,52 @@
     return parts.join(', ');
   }
 
+  function formatCatalogFailureReason(result, path) {
+    if (!FailureReasons?.formatFailureReasonForDisplay) return '';
+    // Compact historical settlements can omit canonical validation fields.
+    // Their display is still recoverable without re-normalizing stored facts.
+    const failure = result.failure && typeof result.failure === 'object'
+      ? { ...result.failure, file: result.failure.file || result.file || path }
+      : FailureReasons.normalizeFailureReason(result, { path: result.file || path });
+    const display = FailureReasons.formatFailureReasonForDisplay(failure, getLocale(), failureReasonI18nLookup);
+    return display.localized ? display.message : '';
+  }
+
   function formatBridgeResultReason(result = {}, fallbackPath = '') {
-    const code = result.code || '';
-    const path = result.path || fallbackPath || '';
-    if (getLocale() !== 'en') {
-      return localizeVisibleReason(result.reason || result.error || result.code || tr('unknownReason'));
-    }
-    if (code === 'missing_tracked_changes') {
-      return 'No matching Overleaf tracked-change records were found for this run, so Codex did not undo with text patches.';
-    }
-    if (code === 'tracked_change_file_open_failed') {
-      return path
-        ? `Could not open ${path} to find this run's tracked changes. Handle them manually in the Overleaf review tools.`
-        : 'Could not open the file to find this run\'s tracked changes. Handle them manually in the Overleaf review tools.';
-    }
-    if (code === 'tracked_change_not_found') {
-      return 'No matching tracked changes were found on the Overleaf page for this run.';
-    }
-    if (code === 'tracked_change_reject_control_not_found') {
-      return path
-        ? `Some tracked changes in ${path} remain, but the matching Reject button was not found. Reject them manually in Overleaf.`
-        : 'Some tracked changes remain, but the matching Reject button was not found. Reject them manually in Overleaf.';
-    }
-    if (code === 'tracked_change_reject_not_confirmed') {
-      return 'Codex clicked Reject, but Overleaf still shows this tracked change. Reject it manually in the Overleaf review panel.';
-    }
-    if (code === 'tracked_change_accept_control_not_found') {
-      return path
-        ? `Some tracked changes in ${path} remain, but the matching Accept button was not found. Accept them manually in Overleaf.`
-        : 'Some tracked changes remain, but the matching Accept button was not found. Accept them manually in Overleaf.';
-    }
-    if (code === 'tracked_change_accept_not_confirmed') {
-      return 'Codex clicked Accept, but Overleaf still shows this tracked change. Accept it manually in the Overleaf review panel.';
-    }
-    if (code === 'tracked_change_editor_undo_open_failed') {
-      return path ? `Could not open ${path} for Overleaf native undo.` : 'Could not open the file for Overleaf native undo.';
-    }
-    if (code === 'tracked_change_editor_undo_current_mismatch') {
-      return path
-        ? `${path} no longer matches this run's written content, so Codex did not use Overleaf native undo.`
-        : 'The current content no longer matches this run\'s written content, so Codex did not use Overleaf native undo.';
-    }
-    if (code === 'editor_undo_control_not_found') {
-      return path
-        ? `Could not find Overleaf's editor Undo button to undo this run in ${path}.`
-        : 'Could not find Overleaf\'s editor Undo button to undo this run.';
-    }
-    if (code === 'editor_undo_no_progress') {
-      return path
-        ? `Codex clicked Overleaf Undo, but ${path} did not change.`
-        : 'Codex clicked Overleaf Undo, but the file did not change.';
-    }
-    if (code === 'editor_undo_max_iterations') {
-      return path
-        ? `${path} did not return to its pre-run content after repeated Overleaf native undo steps. Codex stopped to avoid undoing other edits.`
-        : 'The file did not return to its pre-run content after repeated Overleaf native undo steps. Codex stopped to avoid undoing other edits.';
-    }
-    if (code === 'tracked_change_undo_max_iterations') {
-      return path
-        ? `${path} still has tracked changes left. Codex stopped to avoid rejecting unrelated edits.`
-        : 'Tracked changes are still left. Codex stopped to avoid rejecting unrelated edits.';
-    }
-    if (code === 'tracked_change_undo_verify_open_failed') {
-      return path
-        ? `Could not open ${path} after undo to verify content. Reload Overleaf and check manually.`
-        : 'Could not open the file after undo to verify content. Reload Overleaf and check manually.';
-    }
-    if (code === 'tracked_change_undo_verify_failed') {
-      return path
-        ? `${path} did not return to its pre-run content after rejecting tracked changes. Check this run's changes in the Overleaf review panel.`
-        : 'The file did not return to its pre-run content after rejecting tracked changes. Check this run\'s changes in the Overleaf review panel.';
-    }
-    return localizeVisibleReason(result.reason || result.error || result.code || tr('unknownReason'));
+    const path = result.file || result.path || fallbackPath || '';
+    return formatCatalogFailureReason(result, path)
+      || localizeVisibleReason(result.reason || result.error || result.code || tr('unknownReason'));
   }
 
+  const runtimeOwnedReasonPairs = [
+  ['The selected provider no longer exists.', '所选模型服务已不存在。'],
+  ['The selected provider has no usable revision.', '所选模型服务没有可用的配置版本。'],
+  ['The selected provider revision was not captured for this run.', '本轮任务未记录所选模型服务的配置版本。'],
+  ['The selected provider changed after this run was submitted.', '本轮任务提交后，所选模型服务的配置已发生变化。'],
+  ['The captured selection is invalid. Attach it again.', '已记录的选区无效，请重新添加。'],
+  ['Provider revision must be a finite non-negative integer.', '模型服务配置版本必须是有效的非负整数。'],
+  ['A stable matching Overleaf account is required for shared history.', '共享历史需要稳定且匹配的 Overleaf 账号。'],
+  ['The background storage connection was lost.', '后台存储连接已断开。'],
+  ['Shared history is unavailable. Reload the extension and this page.', '共享历史不可用，请重新加载扩展和当前页面。'],
+  ['The shared history lock disconnected.', '共享历史的存储锁连接已断开。'],
+  ['Another page is saving history. Retry after it finishes.', '其他页面正在保存历史，请待保存完成后重试。'],
+  ['The shared history lock was lost before completion.', '操作完成前，共享历史的存储锁已丢失。'],
+  ['A stable account scope is required for durable persistence.', '持久保存需要稳定的账号范围。'],
+  ['A cross-realm browser lock is required for durable persistence.', '持久保存需要能够跨页面协调的浏览器锁。'],
+  ['Shared session storage is unavailable.', '共享会话存储不可用。'],
+  ['Native host request failed.', '本地主机请求失败。'],
+  ['Native host disconnected', '本地主机连接已断开。']
+];
+
   function localizeVisibleReason(reason) {
     const text = String(reason || '').trim();
+    for (const [en, zh] of runtimeOwnedReasonPairs) {
+      if (text === en || text === zh) return tx(en, zh);
+    }
+    const scoped = /^(?:Scoped persistence failed: |限定范围的持久保存失败：)(invalid_commit|stale_view|revision_conflict|queue_revision_conflict|invalid_queue_mutation|queue_claim_conflict)$/.exec(text);
+    if (scoped) return tx(`Scoped persistence failed: ${scoped[1]}`, `限定范围的持久保存失败：${scoped[1]}`);
+    const localized = FailureReasons?.localizeFailureMessage?.(text, getLocale(), failureReasonI18nLookup);
+    if (localized && localized !== text) return localized;
     if (!text || getLocale() !== 'en') {
       return text;
     }