codex-overleaf-link 2.4.1 → 2.5.1

package/extension/bootstrap/background.js

@@ -1,20 +1,26 @@
 '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';
 const UPDATE_RELOAD_TABS_KEY = 'codex-overleaf-managed-update-tabs-v1';
 const CHECK_ALARM = 'codex-overleaf-stable-update-check';
 const IDLE_ALARM = 'codex-overleaf-staged-update-idle';
-const OVERLEAF_EDITOR_MATCHES = [
-  'https://www.overleaf.com/project/*',
-  'https://overleaf.com/project/*'
-];
-const OVERLEAF_MATCHES = [
+// Built-in sites. The replaceable runtime manifest may list more; any extra
+// site is used only after Chrome reports its permission as granted, so a later
+// release can add an Overleaf site without changing this Bootstrap file.
+const BUILT_IN_OVERLEAF_MATCHES = Object.freeze([
   'https://www.overleaf.com/project',
   'https://overleaf.com/project',
-  ...OVERLEAF_EDITOR_MATCHES
-];
+  'https://cn.overleaf.com/project',
+  'https://www.overleaf.com/project/*',
+  'https://overleaf.com/project/*',
+  'https://cn.overleaf.com/project/*'
+]);
+let OVERLEAF_MATCHES = [...BUILT_IN_OVERLEAF_MATCHES];
+let OVERLEAF_HOSTS = hostsOf(OVERLEAF_MATCHES);
 const APPLYING_STATES = new Set(['applying', 'awaiting_health', 'rolling_back']);
 const FAST_IDLE_RETRY_BLOCKERS = new Set(['recent_user_activity', 'save_state_not_stable']);
 const FAST_IDLE_RETRY_MS = 4000;
@@ -58,6 +64,10 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
   return undefined;
 });
 
+// A newly granted site starts working without a reload or reinstall.
+chrome.permissions?.onAdded?.addListener(() => { registerManagedRuntime().catch(() => {}); });
+chrome.permissions?.onRemoved?.addListener(() => { registerManagedRuntime().catch(() => {}); });
+
 chrome.alarms.onAlarm.addListener(alarm => {
   if (alarm.name === CHECK_ALARM) {
     checkAndStage().catch(() => {});
@@ -67,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) });
 });
 
@@ -83,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') {
@@ -105,6 +117,10 @@ async function registerManagedRuntime() {
   }
   const manifest = await response.json();
   validateRuntimeManifest(manifest);
+  const matches = await grantedMatches(manifest.matches);
+  if (!matches.length) throw new Error('No Overleaf site in the runtime manifest is permitted.');
+  OVERLEAF_MATCHES = [...new Set([...BUILT_IN_OVERLEAF_MATCHES, ...matches])];
+  OVERLEAF_HOSTS = hostsOf(OVERLEAF_MATCHES);
   managedRuntimeAssets = {
     js: ['bootstrap/runtimeContext.js', ...manifest.js.map(value => 'runtime/' + value)],
     css: manifest.css.map(value => 'runtime/' + value)
@@ -115,7 +131,7 @@ async function registerManagedRuntime() {
   }
   await chrome.scripting.registerContentScripts([{
     id: RUNTIME_SCRIPT_ID,
-    matches: manifest.matches,
+    matches,
     js: managedRuntimeAssets.js,
     css: managedRuntimeAssets.css,
     runAt: manifest.runAt || 'document_idle',
@@ -127,7 +143,7 @@ function validateRuntimeManifest(manifest) {
   if (!manifest || manifest.schemaVersion !== 1 || !Array.isArray(manifest.matches) || !Array.isArray(manifest.js) || !Array.isArray(manifest.css)) {
     throw new Error('Managed runtime manifest is invalid.');
   }
-  if (!manifest.matches.length || manifest.matches.some(value => !OVERLEAF_MATCHES.includes(value))) {
+  if (!manifest.matches.length || manifest.matches.some(value => !isProjectMatch(value))) {
     throw new Error('Managed runtime match patterns are invalid.');
   }
   const paths = [...manifest.js, ...manifest.css];
@@ -303,11 +319,36 @@ async function probeTabIdle(tab) {
   return { idle: false, blockers: ['tab_probe_unavailable'] };
 }
 
+// Only project pages on overleaf.com or one of its subdomains: the same scope
+// as optional_host_permissions and web_accessible_resources in the manifest.
+function isProjectMatch(value) {
+  return typeof value === 'string'
+    && /^https:\/\/(?:[a-z0-9-]+\.)*overleaf\.com\/project(?:\/\*)?$/.test(value);
+}
+
+function hostsOf(matches) {
+  return new Set(matches.map(value => {
+    try { return new URL(value.replace(/\*$/, '')).host; } catch (_error) { return ''; }
+  }).filter(Boolean));
+}
+
+// Built-in sites are granted at install; a site a later runtime adds only
+// counts once the user has approved Chrome's prompt for it (see the popup).
+async function grantedMatches(matches) {
+  const result = [];
+  for (const value of matches) {
+    if (BUILT_IN_OVERLEAF_MATCHES.includes(value)) { result.push(value); continue; }
+    const granted = await chrome.permissions.contains({ origins: [value] }).catch(() => false);
+    if (granted) result.push(value);
+  }
+  return result;
+}
+
 function isEditorProjectTab(tab) {
   try {
     const url = new URL(tab?.url || '');
     return url.protocol === 'https:' &&
-      (url.hostname === 'www.overleaf.com' || url.hostname === 'overleaf.com') &&
+      OVERLEAF_HOSTS.has(url.host) &&
       /^\/project\/[^/]+(?:\/|$)/.test(url.pathname);
   } catch (_error) {
     return false;
@@ -344,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 || {};
@@ -362,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({
@@ -414,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);
@@ -448,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.4.0",
+  "version": "2.5.1",
   "description": "Connect the active Overleaf project to a local Codex bridge.",
   "icons": {
     "16": "assets/icons/icon16.png",
@@ -20,7 +20,12 @@
     "https://www.overleaf.com/project",
     "https://overleaf.com/project",
     "https://www.overleaf.com/project/*",
-    "https://overleaf.com/project/*"
+    "https://overleaf.com/project/*",
+    "https://cn.overleaf.com/project",
+    "https://cn.overleaf.com/project/*"
+  ],
+  "optional_host_permissions": [
+    "https://*.overleaf.com/*"
   ],
   "background": {
     "service_worker": "bootstrap/background.js"
@@ -36,8 +41,8 @@
         "runtime/src/pageBridge.js"
       ],
       "matches": [
-        "https://www.overleaf.com/*",
-        "https://overleaf.com/*"
+        "https://overleaf.com/*",
+        "https://*.overleaf.com/*"
       ]
     }
   ],

package/extension/bootstrap/popup.html

@@ -1,24 +1,19 @@
 <!doctype html>
-<html>
+<html lang="en" class="popup-minimal-root" data-popup-theme="dark">
   <head>
     <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>Codex Overleaf Link</title>
-    <link rel="stylesheet" href="popup.css">
+    <link id="popup-styles" rel="stylesheet" href="../runtime/styles/popup.css">
   </head>
-  <body>
-    <h1 class="popup-brand">Codex Overleaf Link</h1>
-    <div class="version-status" data-popup-context>
-      <span id="compat-status-icon" class="status-icon incompatible" title="Native host incompatible">X</span>
-      <span id="version-pair">Extension unknown / Native unknown</span>
-    </div>
-    <button id="open-panel" data-popup-context>Open panel in Overleaf</button>
-    <p id="status" data-popup-context>Use this on an Overleaf project tab.</p>
-    <div id="native-install" class="install" data-popup-context hidden>
-      <strong>Native host attention required</strong>
-      <p>Run this command in Terminal, then reload this extension in Chrome.</p>
-      <code id="install-command"></code>
-      <button id="copy-install-command" class="secondary" type="button">Copy install command</button>
-    </div>
+  <body class="popup-minimal">
+    <!-- The popup body is drawn by the replaceable runtime (runtime/src/popup.js),
+         so popup changes ship through normal updates. This shell only holds
+         the fallback shown if the runtime cannot load. -->
+    <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/update.js

@@ -88,6 +88,7 @@
       up_to_date: ['Everything is up to date', 'Extension and Native Host are on the latest stable release.', 'Up to date', 'success'],
       checking: ['Checking for updates', 'Reading the latest signed stable release.', 'Checking', 'active'],
       update_available: ['A stable update is ready', 'Review the target version, then update when convenient.', 'Available', 'success'],
+      manual_install_required: ['This update needs a one-time reinstall', 'Update now cannot apply this release. Run the command below once, then reload the extension and refresh Overleaf. Your sessions, settings, provider keys and project mirrors are kept.', 'Reinstall', 'warning'],
       downloading: ['Downloading the signed release', 'The package is being fetched and verified before any files change.', 'Downloading', 'active'],
       staged: ['Update verified', 'The signed package is ready and waiting for a safe installation point.', 'Verified', 'active'],
       waiting: ['Waiting for a safe point', 'Active Overleaf work will finish before the runtime changes.', 'Waiting', 'warning'],
@@ -164,6 +165,12 @@
         { id: 'install', label: 'Update now', kind: 'primary' }
       ];
     }
+    if (phase === 'manual_install_required') {
+      return [
+        { id: 'later', label: 'Later', kind: 'quiet' },
+        { id: 'copy-command', label: 'Copy command', kind: 'primary' }
+      ];
+    }
     if (['failed', 'rolled_back'].includes(phase)) {
       return [
         { id: 'close', label: 'Close', kind: 'quiet' },
@@ -229,8 +236,14 @@
       ? 'The extension may restart briefly. This window will reconnect and restore the saved progress.'
       : 'This window can stay open while work continues elsewhere. Progress is saved automatically.';
 
-    const technical = technicalText(currentView);
-    elements.details.hidden = !technical || !['failed', 'rolled_back'].includes(presentation.phase);
+    // The signed reason and the exact reinstall command replace the generic
+    // detail; the command stays visible and selectable in the details box.
+    const manual = presentation.phase === 'manual_install_required';
+    const reason = manual ? String(currentView.manualReason?.en || currentView.manualReason?.zh || '').trim() : '';
+    if (reason) elements.detail.textContent = reason + ' ' + presentation.detail;
+    const technical = manual ? manualCommand(target) : technicalText(currentView);
+    elements.details.hidden = !technical || !['failed', 'rolled_back', 'manual_install_required'].includes(presentation.phase);
+    elements.details.open = manual || elements.details.open;
     elements.technicalMessage.textContent = technical;
     renderActions(presentation.phase);
     schedulePolling(presentation.phase);
@@ -286,8 +299,18 @@
     }, 1100);
   }
 
+  function manualCommand(version) {
+    const pinned = /^\d+\.\d+\.\d+$/.test(String(version || '')) ? version : 'latest';
+    return `npm exec --yes codex-overleaf-link@${pinned} -- install-managed`;
+  }
+
   async function runAction(action) {
     if (actionPending) return;
+    if (action === 'copy-command') {
+      const target = versionOf(currentView, ['latestVersion', 'targetVersion', 'availableVersion'], '');
+      await navigator.clipboard.writeText(manualCommand(target)).catch(() => {});
+      return;
+    }
     if (action === 'close') {
       window.close();
       return;

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.'

package/extension/runtime-manifest.json

@@ -4,7 +4,9 @@
     "https://www.overleaf.com/project",
     "https://overleaf.com/project",
     "https://www.overleaf.com/project/*",
-    "https://overleaf.com/project/*"
+    "https://overleaf.com/project/*",
+    "https://cn.overleaf.com/project",
+    "https://cn.overleaf.com/project/*"
   ],
   "js": [
     "src/content/generated/content.bundle.js"