codex-overleaf-link 2.5.0 → 2.6.0

package/extension/bootstrap/background.js

@@ -1,5 +1,7 @@
 'use strict';
 
+globalThis.__CODEX_OVERLEAF_BOOTSTRAP_REVISION__ = '3.1';
+
 const CODEX_OVERLEAF_HOST = 'com.codex.overleaf';
 const RUNTIME_SCRIPT_ID = 'codex-overleaf-managed-runtime';
 const UPDATE_STATE_KEY = 'codex-overleaf-managed-update-state-v1';
@@ -75,7 +77,7 @@ chrome.alarms.onAlarm.addListener(alarm => {
   }
 });
 
-initializeBootstrap().catch(async error => {
+globalThis.__CODEX_OVERLEAF_BOOTSTRAP_READY__ = initializeBootstrap().catch(async error => {
   await setUpdateState({ state: 'failed', code: safeCode(error), message: safeMessage(error) });
 });
 
@@ -91,6 +93,8 @@ async function initializeBootstrap() {
     return;
   }
 
+  const migration = await globalThis.CodexOverleafBootstrapMigration?.ready?.();
+  if (migration?.continueInitialization === false) return;
   const nativeStatus = await requestInternal({ method: 'update.status', params: {} }).catch(() => null);
   const transaction = nativeStatus?.ok ? nativeStatus.result?.transaction : null;
   if (transaction?.state === 'awaiting_health') {
@@ -381,12 +385,12 @@ async function confirmPendingUpdate(transaction) {
   const targetVersion = transaction.targetVersion;
   const runtimeHealthy = await verifyPendingRuntimeHealth(targetVersion);
   if (!runtimeHealthy) {
-    await rollbackBrokenRuntime(new Error('Updated Overleaf content runtime did not report the target version.'));
+    await rollbackBrokenRuntime(new Error('Updated Overleaf content runtime did not report the target version.'), transaction);
     return;
   }
   const ping = await requestInternal({ method: 'bridge.ping', params: {} }).catch(() => null);
   if (!ping?.ok || ping.result?.version !== targetVersion) {
-    await rollbackBrokenRuntime(new Error('Updated native host did not report the target version.'));
+    await rollbackBrokenRuntime(new Error('Updated native host did not report the target version.'), transaction);
     return;
   }
   const native = ping.result || {};
@@ -399,19 +403,20 @@ async function confirmPendingUpdate(transaction) {
       native.protocolVersion < protocolRange.min ||
       native.protocolVersion > protocolRange.max ||
       missingCapabilities.length) {
-    await rollbackBrokenRuntime(new Error('Updated native host did not pass protocol and capability health checks.'));
+    await rollbackBrokenRuntime(new Error('Updated native host did not pass protocol and capability health checks.'), transaction);
     return;
   }
   const confirmed = await requestInternal({
     method: 'update.confirm',
     params: {
       transactionId: transaction.id,
+      bootstrapRevision: String(globalThis.__CODEX_OVERLEAF_BOOTSTRAP_REVISION__ || ''),
       extensionVersion: chrome.runtime.getManifest().version,
       nativeVersion: ping.result.version
     }
   });
   if (!confirmed?.ok) {
-    await rollbackBrokenRuntime(nativeError(confirmed));
+    await rollbackBrokenRuntime(nativeError(confirmed), transaction);
     return;
   }
   await setUpdateState({
@@ -451,20 +456,56 @@ async function verifyPendingRuntimeHealth(targetVersion) {
   return remaining.size === 0;
 }
 
-async function rollbackBrokenRuntime(error) {
+async function rollbackBrokenRuntime(error, transaction) {
   await setUpdateState({ state: 'rolling_back', code: safeCode(error), message: safeMessage(error) });
+  let pending = transaction;
+  let readback;
+  if (!pending) {
+    readback = await requestInternal({ method: 'update.status', params: {} }).catch(() => null);
+    pending = readback?.ok ? readback.result?.transaction : null;
+  }
+  // A status recovery may have completed an interrupted apply before this
+  // loader obtained its transaction. The same source-byte proof is required.
+  if (isRollbackReadback(readback, pending)) {
+    await setUpdateState({ state: 'rolled_back', code: safeCode(error), currentVersion: pending.sourceVersion, transactionId: pending.id });
+    chrome.runtime.reload();
+    return;
+  }
+  if (!pending?.id || !pending.sourceVersion || !['applying', 'bootstrap_pending', 'awaiting_health', 'committed'].includes(pending.state)) {
+    await setUpdateState({ state: 'failed', code: safeCode(error), message: safeMessage(error) });
+    return;
+  }
   const rolledBack = await requestInternal({
     method: 'update.rollback',
-    params: { reasonCode: safeCode(error) }
+    params: { reasonCode: safeCode(error), transactionId: pending.id, expectedState: pending.state }
   }).catch(() => null);
-  if (rolledBack?.ok) {
-    await setUpdateState({ state: 'rolled_back', code: safeCode(error), currentVersion: rolledBack.result.version });
+  if (rolledBack?.ok && rolledBack.result?.transactionId === pending.id
+    && rolledBack.result?.state === 'rolled_back' && rolledBack.result?.version === pending.sourceVersion) {
+    readback = await requestInternal({ method: 'update.status', params: {} }).catch(() => null);
+  }
+  if (rolledBack?.result?.restoredPair && isRollbackReadback(readback, pending, rolledBack.result.restoredPair)) {
+    await setUpdateState({ state: 'rolled_back', code: safeCode(error), currentVersion: pending.sourceVersion, transactionId: pending.id });
     chrome.runtime.reload();
     return;
   }
   await setUpdateState({ state: 'failed', code: safeCode(error), message: safeMessage(error) });
 }
 
+function isRollbackReadback(response, transaction, expectedPair) {
+  const status = response?.ok ? response.result : null;
+  const pair = status?.restoredPair;
+  return Boolean(transaction?.id && status?.transaction?.id === transaction.id
+    && status.transaction.state === 'rolled_back' && status.activeVersion === transaction.sourceVersion
+    && status.installedAligned === true && pair?.extensionVersion === transaction.sourceVersion
+    && pair?.nativeVersion === transaction.sourceVersion
+    && /^[0-9a-f]{64}$/.test(pair.extensionSha256 || '') && /^[0-9a-f]{64}$/.test(pair.nativeSha256 || '')
+    && (!(transaction.bootstrapRevision || status.transaction.bootstrapRevision || expectedPair?.bootstrapSha256)
+      || (/^[0-9a-f]{64}$/.test(pair.bootstrapSha256 || '')
+        && (!expectedPair || pair.bootstrapSha256 === expectedPair.bootstrapSha256)))
+    && (!expectedPair || ['extensionVersion', 'nativeVersion', 'extensionSha256', 'nativeSha256']
+      .every(key => pair[key] === expectedPair[key])));
+}
+
 async function reloadPendingOverleafTabs() {
   const tabIds = await getPendingOverleafTabIds();
   await chrome.storage.local.remove(UPDATE_RELOAD_TABS_KEY);
@@ -485,6 +526,8 @@ async function postponeUpdate() {
 }
 
 async function requestInternal(payload) {
+  if (payload?.method === 'update.status') payload = { ...payload,
+    params: { ...payload.params, bootstrapRevision: String(globalThis.__CODEX_OVERLEAF_BOOTSTRAP_REVISION__ || '') } };
   if (globalThis.CodexOverleafNativeBridge?.requestInternal) {
     return globalThis.CodexOverleafNativeBridge.requestInternal({
       id: crypto.randomUUID(),

package/extension/bootstrap/manifest.template.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Codex Overleaf Link",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Connect the active Overleaf project to a local Codex bridge.",
   "icons": {
     "16": "assets/icons/icon16.png",

package/extension/bootstrap/popup.html

@@ -13,6 +13,7 @@
     <main id="popup-shell" data-bootstrap-shell>
       <p class="popup-note">Codex Overleaf Link could not load its runtime. Rerun the installer, then reload the extension.</p>
     </main>
+    <script src="popupFallback.js"></script>
     <script src="../runtime/src/shared/compatibility.js"></script>
     <script src="../runtime/src/popup.js"></script>
     <script src="updateStatus.js"></script>

package/extension/bootstrap/popupFallback.js

@@ -0,0 +1,55 @@
+(function localizePopupFallback() {
+  'use strict';
+
+  const preferenceKeys = ['codexOverleafGlobalPrefsV1', 'codexOverleafPrefs'];
+  let revision = 0;
+  let recoveryReloaded = false;
+
+  async function refreshFallback() {
+    const requestRevision = ++revision;
+    let preferences = {};
+    try {
+      const stored = await chrome.storage.local.get(preferenceKeys);
+      preferences = stored.codexOverleafGlobalPrefsV1?.values || stored.codexOverleafPrefs || {};
+    } catch (_) { /* A missing language preference uses the product default. */ }
+    if (requestRevision !== revision) return;
+    const shell = document.querySelector('[data-bootstrap-shell]');
+    const message = shell?.querySelector('p');
+    // The healthy runtime replaces this shell. Late preference reads must
+    // never change the runtime's content or its current language.
+    if (!message) return;
+    const chinese = preferences.locale === 'zh';
+    document.documentElement.lang = chinese ? 'zh-CN' : 'en';
+    message.textContent = chinese
+      ? 'Codex Overleaf Link 无法加载运行组件。请重新运行安装程序，再重新加载扩展。'
+      : 'Codex Overleaf Link could not load its runtime. Rerun the installer, then reload the extension.';
+  }
+
+  chrome.storage.onChanged.addListener((changes, area) => {
+    if (area === 'local' && preferenceKeys.some(key => changes[key])) refreshFallback();
+  });
+  refreshFallback();
+
+  // This independent extension page can still start when the worker/runtime
+  // cannot. Native decides whether a persisted migration needs recovery; the
+  // popup never guesses a transaction or sends an unbound rollback request.
+  document.addEventListener?.('DOMContentLoaded', () => {
+    setTimeout(() => {
+      if (!document.querySelector('[data-bootstrap-shell]') || !chrome.runtime?.sendNativeMessage) return;
+      chrome.runtime.sendNativeMessage('com.codex.overleaf', {
+        id: crypto.randomUUID(), method: 'update.status', params: { bootstrapRecovery: true }
+      }, response => {
+        if (chrome.runtime.lastError || recoveryReloaded || !document.querySelector('[data-bootstrap-shell]')) return;
+        const status = response?.ok ? response.result : null;
+        const transaction = status?.transaction;
+        const pair = status?.restoredPair;
+        if (!transaction?.id || transaction.state !== 'rolled_back' || !transaction.sourceVersion
+          || status.activeVersion !== transaction.sourceVersion || status.installedAligned !== true
+          || pair?.extensionVersion !== transaction.sourceVersion || pair?.nativeVersion !== transaction.sourceVersion
+          || !['extensionSha256', 'nativeSha256', 'bootstrapSha256'].every(key => /^[0-9a-f]{64}$/.test(pair[key] || ''))) return;
+        recoveryReloaded = true;
+        chrome.runtime.reload();
+      });
+    }, 250);
+  }, { once: true });
+})();

package/extension/bootstrap/updateStatus.js

@@ -17,6 +17,7 @@
     tab_not_idle: 'An Overleaf tab is still busy.',
     native_project_locked: 'The native host still holds a project lock.',
     native_run_active: 'The native host is still processing a Codex run.',
+    native_process_stop_unconfirmed: 'A previous Codex process has not yet confirmed its exit.',
     native_gate_unavailable: 'The native host could not report whether it is idle.',
     native_not_idle: 'The native host is still busy.',
     busy: 'An update safety check is still busy.'