codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/content/nativeCompatibilityController.js

@@ -12,27 +12,46 @@
     const tx = options.tx;
     const tr = options.tr;
 
+    let installIdentity = options.getExtensionCompatibilityMetadata?.()?.installIdentity || {};
+    function resolveInstallCommand(compatibility = {}) {
+      const metadata = options.getExtensionCompatibilityMetadata?.() || {};
+      installIdentity = { ...installIdentity, ...(metadata.installIdentity || {}), ...(compatibility.installIdentity || {}) };
+      if (installIdentity.managed) return Compatibility?.buildInstallCommand?.(
+        compatibility.recommendedVersion || Compatibility?.BUILD_TARGET_VERSION,
+        compatibility.native?.platform || compatibility.platform || installIdentity.platform,
+        metadata.extensionId, installIdentity
+      ) || '';
+      return compatibility.updateCommand || compatibility.installCommand || options.installCommand || '';
+    }
+
     function sendNative(payload) {
       return dispatch(payload, 'sendNative');
     }
 
-    function sendBackgroundNative(payload) {
-      return dispatch(payload, 'sendBackgroundNative');
+    function sendBackgroundNative(payload, context = {}) {
+      return dispatch(payload, 'sendBackgroundNative', context);
     }
 
-    async function dispatch(payload, channelMethod) {
-      const compatibilityGate = await ensureForMethod(payload?.method);
-      if (!compatibilityGate.ok) return compatibilityGate.response;
-      // Post-Undo cache bookkeeping must survive the ended run's cancellation.
-      if (gatedMethods.has(payload?.method) && payload.method !== 'mirror.invalidate') {
-        options.throwIfCancellationRequested?.();
+    async function dispatch(payload, channelMethod, context = {}) {
+      let compatibilityGate;
+      try {
+        compatibilityGate = await ensureForMethod(payload?.method, context);
+        if (!compatibilityGate.ok) return compatibilityGate.response;
+        // Post-Undo cache bookkeeping must survive the ended run's cancellation.
+        if (gatedMethods.has(payload?.method) && payload.method !== 'mirror.invalidate') {
+          options.throwIfCancellationRequested?.();
+        }
+        context.assertCurrent?.();
+      } catch (error) {
+        if (context.assertCurrent && error && typeof error === 'object') error.requestDispatched = false;
+        throw error;
       }
       return nativeChannel[channelMethod](
         attachEvidence(payload, compatibilityGate.compatibility)
       );
     }
 
-    async function ensureForMethod(method) {
+    async function ensureForMethod(method, { assertCurrent } = {}) {
       const metadata = options.getExtensionCompatibilityMetadata?.() || {};
       const params = Compatibility?.buildBridgePingParams
         ? Compatibility.buildBridgePingParams(metadata)
@@ -41,9 +60,12 @@
         method: 'bridge.ping',
         params
       });
+      // A retired run must not publish even a compatibility failure into a successor.
+      assertCurrent?.();
       const compatibility = Compatibility?.evaluateNativeCompatibility
         ? Compatibility.evaluateNativeCompatibility(response, metadata)
         : options.fallbackNativeCompatibility(response);
+      const installCommand = resolveInstallCommand(compatibility);
       const allowed = !gatedMethods.has(method) ||
         (Compatibility?.isNativeMethodAllowed
           ? Compatibility.isNativeMethodAllowed(method, compatibility)
@@ -51,14 +73,14 @@
       if (allowed) return { ok: true, compatibility };
 
       const message = formatBlockedMessage(method, compatibility);
-      const installCommand = options.installCommand;
       const error = {
         code: 'native_update_required',
         message,
         status: compatibility.status || 'unknown_native',
         classification: options.getNativeCompatibilityClassification(compatibility),
-        installCommand: compatibility.installCommand || installCommand,
-        updateCommand: compatibility.updateCommand || compatibility.installCommand || installCommand,
+        installIdentity,
+        installCommand,
+        updateCommand: installCommand,
         currentNativeVersion: compatibility.currentNativeVersion
           || compatibility.nativeVersion
           || compatibility.native?.version
@@ -102,6 +124,7 @@
           : {};
         const response = await sendBackgroundNative({ method: 'bridge.ping', params });
         const compatibility = Compatibility.evaluateNativeCompatibility(response, metadata);
+        resolveInstallCommand(compatibility);
         const classification = options.getNativeCompatibilityClassification(compatibility);
         if (classification === 'compatible') {
           options.setBadge?.(renderer.headerEl, { type: 'none' });
@@ -158,9 +181,7 @@
         || compatibility.nativeVersion
         || native.version
         || tx('missing', '未安装');
-      const command = compatibility.updateCommand
-        || compatibility.installCommand
-        || options.installCommand;
+      const command = resolveInstallCommand(compatibility);
       const releaseUrl = compatibility.releaseUrl || '';
       const overlay = options.document.createElement('div');
       overlay.className = 'codex-plugin-confirm';
@@ -193,10 +214,12 @@
             `Extension v${extensionVersion} / Native v${nativeVersion}`,
             `扩展 v${extensionVersion} / Native v${nativeVersion}`
           ),
-        tx(
-          'Run the platform-specific command below, reload the extension, then refresh Overleaf.',
-          '运行下面的平台命令，重新加载扩展，然后刷新 Overleaf。'
-        )
+        !command && installIdentity.managed
+          ? tx('Repair Managed using the original managed root, browser and extension ID with install-managed.',
+            '请使用原管理根目录、浏览器及扩展 ID，通过 install-managed 修复托管安装。')
+          : tx('Run the command below, reload the extension, then refresh Overleaf.', '运行下面的命令，重新加载扩展，然后刷新 Overleaf。')
+            + (installIdentity.managed && (native.platform || installIdentity.platform) === 'win32'
+              ? tx(' Use PowerShell.', ' 请使用 PowerShell。') : '')
       ].join('\n\n');
       const commandCode = options.document.createElement('code');
       commandCode.textContent = command;
@@ -221,7 +244,9 @@
       copy.type = 'button';
       copy.className = 'codex-plugin-confirm-confirm';
       copy.textContent = tx('Copy command', '复制命令');
+      copy.disabled = !command;
       copy.addEventListener('click', async () => {
+        if (!command) return;
         await options.navigator.clipboard.writeText(command);
         copy.textContent = tx('Copied', '已复制');
       });
@@ -237,7 +262,7 @@
         if (event.target === overlay) overlay.remove();
       });
       panel.append(overlay);
-      copy.focus();
+      (command ? copy : close).focus();
     }
 
     function scheduleFirstUseOnboardingTip() {

package/extension/src/content/otWarmMirror.js

@@ -833,7 +833,7 @@
     if (getCurrentProjectId() !== projectId) return { useExistingMirror: false, reason: 'project_changed' };
     const otWarmStart = otWarmMirrorController.canUseOtWarmStart({
       enabled: isExperimentalOtEnabled() && !otWarmMirrorState.failureActive,
-      focusFiles,
+      focusFiles, focusFilesAreLiteral: true,
       mirrorStatus
     });
     if (!mirrorStatus?.exists || (!otWarmStart.ok && !isMirrorReusable(mirrorStatus))) {
@@ -858,10 +858,9 @@
       return { useExistingMirror: false, reason: 'overlay_probe_failed', mirrorStatus };
     }
     if (getCurrentProjectId() !== projectId) return { useExistingMirror: false, reason: 'project_changed' };
-    const fileOverlays = buildSnapshotFileOverlays(overlayProject, focusFiles);
-    if (!fileOverlays.length) {
-      return { useExistingMirror: false, reason: 'missing_current_overlay', mirrorStatus };
-    }
+    const fileOverlays = buildSnapshotFileOverlays(overlayProject, focusFiles).filter(file =>
+      !otWarmStart.ok || focusFiles.some(path => normalizeSnapshotPath(path) === normalizeSnapshotPath(file.path)));
+    if (!fileOverlays.length) return { useExistingMirror: false, reason: 'missing_current_overlay', mirrorStatus };
     if (focusFiles.length && !focusFiles.every(path => {
       const normalized = normalizeSnapshotPath(path);
       return fileOverlays.some(file => normalizeSnapshotPath(file.path) === normalized);

package/extension/src/content/otWarmMirrorController.js

@@ -1,10 +1,10 @@
 (function initCodexOverleafOtWarmMirrorController(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('../shared/projectFiles'));
   } else {
-    root.CodexOverleafOtWarmMirrorController = factory();
+    root.CodexOverleafModuleRegistry.define('OtWarmMirrorController', ['ProjectFiles'], factory);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function otWarmMirrorControllerFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function otWarmMirrorControllerFactory(projectFiles) {
   'use strict';
 
   const OT_POLL_INTERVAL_MS = 1000;
@@ -17,6 +17,7 @@
   const OT_MAX_BATCH_BYTES = 2 * 1024 * 1024;
   const encoder = typeof TextEncoder === 'function' ? new TextEncoder() : null;
   const PAUSE_STATES = new Set(['running', 'writing', 'undoing', 'compiling']);
+  const normalizeLiteralPath = projectFiles.normalizeSafeProjectPath;
 
   function buildPatchFilesRequest({ projectId, events, nativeCompatibility } = {}) {
     const files = [];
@@ -24,8 +25,8 @@
       if (files.length >= OT_MAX_PATCH_BATCH) {
         break;
       }
-      const filePath = normalizePath(event?.path);
-      if (!isSafeRelativePath(filePath) || typeof event?.baseHash !== 'string') {
+      const filePath = normalizeLiteralPath(event?.path);
+      if (!filePath || typeof event?.baseHash !== 'string') {
         continue;
       }
       const baseHash = event.baseHash.trim();
@@ -73,7 +74,7 @@
     return { pause: false };
   }
 
-  function canUseOtWarmStart({ enabled, focusFiles, mirrorStatus, now = Date.now() } = {}) {
+  function canUseOtWarmStart({ enabled, focusFiles, focusFilesAreLiteral = false, mirrorStatus, now = Date.now() } = {}) {
     if (!enabled) {
       return { ok: false, reason: 'disabled' };
     }
@@ -82,7 +83,10 @@
     }
     if (mirrorStatus.dirty === true) return { ok: false, reason: 'mirror_dirty' };
 
-    const normalizedFocusFiles = normalizePaths(focusFiles);
+    if (focusFilesAreLiteral === true && Array.isArray(focusFiles) && focusFiles.some(path => !normalizeLiteralPath(path))) {
+      return { ok: false, reason: 'invalid_focus_paths' };
+    }
+    const normalizedFocusFiles = normalizePaths(focusFiles, focusFilesAreLiteral === true);
     if (!normalizedFocusFiles.length) {
       return { ok: false, reason: 'no_focus_files' };
     }
@@ -94,7 +98,7 @@
       }
       const age = now - Date.parse(file.observedAt ?? file.lastPatchAt ?? '');
       if (!Number.isFinite(age) || age < 0 || age > OT_FRESHNESS_MAX_AGE_MS) continue;
-      const filePath = normalizePath(file.path);
+      const filePath = normalizeLiteralPath(file.path);
       if (filePath) {
         freshFiles.add(filePath);
       }
@@ -124,9 +128,9 @@
     let bytes = next.reduce((sum, event) => sum + patchBytes(event), 0);
     if (next.length > OT_MAX_PENDING_EVENTS || bytes > OT_MAX_PENDING_BYTES) return { ok: false, reason: 'ot_queue_limit' };
     for (const input of events) {
-      const path = normalizePath(input?.path);
+      const path = normalizeLiteralPath(input?.path);
       const time = typeof input?.observedAt === 'number' ? input.observedAt : Date.parse(input?.observedAt || '');
-      if (!isSafeRelativePath(path) || path.length > 1024 || typeof input?.nextContent !== 'string' ||
+      if (!path || path.length > 1024 || typeof input?.nextContent !== 'string' ||
           typeof input.baseHash !== 'string' || !input.baseHash || input.baseHash.length > 128) {
         return { ok: false, reason: 'ot_event_invalid' };
       }
@@ -165,7 +169,7 @@
     }
     if (!events.length || Number(result.appliedCount) !== events.length || !Array.isArray(result.appliedFiles) ||
         result.appliedFiles.length !== events.length || !result.appliedFiles.every((file, index) =>
-          normalizePath(file?.path) === events[index].path && (!events[index].nextHash || file.hash === events[index].nextHash))) {
+          normalizeLiteralPath(file?.path) === events[index].path && (!events[index].nextHash || file.hash === events[index].nextHash))) {
       return { ok: false, reason: 'mirror_patch_invalid_result' };
     }
     if (events.some(event => { const time = Date.parse(event.observedAt);
@@ -220,11 +224,11 @@
       .replace(/^\/+/, '');
   }
 
-  function normalizePaths(value) {
+  function normalizePaths(value, literal = false) {
     const seen = new Set();
     const paths = [];
     for (const item of Array.isArray(value) ? value : []) {
-      const filePath = normalizePath(item);
+      const filePath = literal ? normalizeLiteralPath(item) : normalizePath(item);
       if (!filePath || seen.has(filePath)) {
         continue;
       }
@@ -234,13 +238,6 @@
     return paths;
   }
 
-  function isSafeRelativePath(filePath) {
-    if (!filePath) {
-      return false;
-    }
-    return !filePath.split('/').some(part => part === '.' || part === '..');
-  }
-
   function isPrimitiveMetadata(value) {
     return ['string', 'number', 'boolean'].includes(typeof value);
   }

package/extension/src/content/pageBridgeClient.js

@@ -9,7 +9,7 @@
     ['src/shared/reviewing.js', 'codex-overleaf-reviewing-script'],
     ['src/shared/projectFiles.js', 'codex-overleaf-project-files-script'],
     ['src/shared/compatibility.js', 'codex-overleaf-compatibility-page-script'],
-    ['src/shared/pageRpcContract.js', 'codex-overleaf-page-rpc-contract-script'],
+    ['src/shared/pageRpcContract.js', 'codex-overleaf-page-rpc-contract-script', true],
     ['src/shared/staleGuard.js', 'codex-overleaf-stale-guard-script'],
     ['src/shared/compileAdapter.js', 'codex-overleaf-compile-adapter-script'],
     ['src/shared/sensitiveScan.js', 'codex-overleaf-sensitive-scan-script'],
@@ -21,13 +21,21 @@
     ['src/page/overleafProjectSnapshot.js', 'codex-overleaf-project-snapshot-script'],
     ['src/page/pageBridgeCapability.js', 'codex-overleaf-page-bridge-capability-script'],
     ['src/page/treeOperations.js', 'codex-overleaf-tree-operations-script', true],
+    ['src/page/ownedDirectoryCleanup.js', 'codex-overleaf-owned-directory-cleanup-script', true],
     ['src/page/textFileCreator.js', 'codex-overleaf-text-file-creator-script', true],
     ['src/page/binaryAssetUploader.js', 'codex-overleaf-binary-asset-uploader-script', true],
     ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
+    ['src/page/referenceProjects.js', 'codex-overleaf-reference-projects-script', true],
+    ['src/page/fileMover.js', 'codex-overleaf-file-mover-script', true],
     ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
+    ['src/page/trackedChangeOwnership.js', 'codex-overleaf-tracked-change-ownership-script', true],
     ['src/page/trackedChangeCapture.js', 'codex-overleaf-tracked-change-capture-script', true],
+    ['src/page/trackedChangeReplay.js', 'codex-overleaf-tracked-change-replay-script', true],
+    ['src/page/reviewContext.js', 'codex-overleaf-review-context-script', true],
     ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],
     ['src/page/writebackRouter.js', 'codex-overleaf-writeback-router-script', true],
+    ['src/page/writebackReceiptJournal.js', 'codex-overleaf-writeback-receipt-script', true],
+    ['src/page/textCoordinates.js', 'codex-overleaf-text-coordinates-script', true],
     ['src/pageBridge.js', 'codex-overleaf-page-bridge-script', true]
   ]);
   const OPTIONAL_OT_SCRIPTS = Object.freeze([
@@ -44,6 +52,7 @@
     const Contract = options.contract;
     const Compatibility = options.compatibility;
     const timeoutOverrides = { ...(options.timeoutOverrides || {}) };
+    const now = options.now || Date.now;
     const revision = Contract.REVISION;
     const capability = createCapability(cryptoImpl);
     const activeCancellationHandlers = new Map();
@@ -66,11 +75,24 @@
     function send(method, params, policy = {}) {
       const id = cryptoImpl.randomUUID();
       return new Promise((resolve, reject) => {
-        const timeoutMs = Number.isFinite(Number(policy.timeoutMs))
+        const requestTimeoutMs = Number.isFinite(Number(policy.timeoutMs))
           ? Number(policy.timeoutMs)
           : Contract.resolveTimeoutMs(method, timeoutOverrides);
+        // Review preparation and its nested writes share the transport budget.
+        if (Contract.getMethod(method)?.timeoutClass === 'lifecycle') {
+          params = { ...params, deadlineAt: params?.deadlineAt == null ? now() + requestTimeoutMs
+            : Number.isFinite(params.deadlineAt) ? Math.min(params.deadlineAt, now() + requestTimeoutMs) : params.deadlineAt };
+        }
+        const remainingMs = params?.deadlineAt == null ? Infinity
+          : Number.isFinite(params.deadlineAt) ? params.deadlineAt - now() : 0;
+        if (remainingMs <= 0) {
+          resolve({ ok: false, code: 'writeback_deadline_exceeded', changedDocument: false,
+            rpcMethod: method, error: 'The operation deadline expired before this request was sent.' });
+          return;
+        }
+        const timeoutMs = Math.min(requestTimeoutMs, remainingMs);
         const cancellable = policy.cancellation === 'content_abort';
-        let settled = false;
+        let settled = false, dispatched = false;
         let timeout = null;
         function cleanup() {
           if (timeout !== null) windowRef.clearTimeout(timeout);
@@ -93,10 +115,16 @@
           const error = new Error('Codex run was cancelled by the user');
           error.code = 'codex_cancelled';
           error.cancelled = true;
+          error.requestDispatched = dispatched;
+          error.changedDocument = dispatched && Contract.getMethod(method)?.mutation === 'document';
+          if (dispatched && method === 'applyOperations') { error.requestId = id; error.rpcMethod = method; }
           rejectOnce(error);
         }
+        // Cancellation stops new requests; receipt settlement has its own non-cancellable policy.
+        if (cancellable && options.isCancellationRequested?.()) { cancelRequest(); return; }
         timeout = windowRef.setTimeout(() => {
-          resolveOnce({ ok: false, error: 'Page bridge timed out' });
+          resolveOnce({ ok: false, error: 'Page bridge timed out',
+            ...(method === 'applyOperations' ? { code: 'page_bridge_timeout', rpcMethod: method, requestId: id } : {}) });
         }, timeoutMs);
         function onMessage(event) {
           if (event.source !== windowRef
@@ -111,11 +139,11 @@
         }
         if (cancellable) {
           activeCancellationHandlers.set(id, cancelRequest);
-          if (options.isCancellationRequested?.()) windowRef.queueMicrotask(cancelRequest);
         }
         windowRef.addEventListener('message', onMessage);
         // Every low-level request remains one attempt. Higher layers must opt
         // into replay so a document mutation is never duplicated implicitly.
+        dispatched = true;
         windowRef.postMessage({
           source: 'codex-overleaf/content',
           id,