codex-overleaf-link 2.5.0 → 2.5.1

package/extension/src/page/reviewContext.js

@@ -0,0 +1,113 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafReviewContext = api;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+
+  const cancelledOwners = new Map();
+  function cancelOwner(token) {
+    if (typeof token !== 'string' || !token || token.length > 256) return false;
+    for (const [id, until] of cancelledOwners) if (until <= Date.now()) cancelledOwners.delete(id);
+    cancelledOwners.set(token, Date.now() + 120000); return true;
+  }
+
+  // One context per request. The small response reserve lets an expired review
+  // return its known partial evidence before the caller's transport timer fires.
+  function create(deps, input = {}) {
+    const now = deps.now || Date.now;
+    const timers = typeof deps.window?.setTimeout === 'function' ? deps.window : globalThis;
+    const started = now(), limit = input.deadlineAt == null ? started + 120000 : input.deadlineAt;
+    const deadlineAt = Number.isFinite(limit) ? limit - Math.min(250, Math.max(0, limit - started) / 10) : started;
+    const cancellation = deps.readWriteCancellationSequence?.();
+    const appliedLists = new Set(), observations = new Map();
+    let stopped = null, mutationStarted = false;
+    const params = { ...input, deadlineAt };
+    const failure = (code, reason) => ({ ok: false, code, reason, changedDocument: false,
+      failure: { code: code === 'codex_cancelled' ? 'codex_run_cancelled' : 'tracked_changes_remain',
+        stage: 'reviewing', severity: 'blocked', terminalState: 'blocked', changedDocument: false,
+        userMessage: reason, nextAction: 'Check the retained per-file results in Overleaf before retrying.',
+        evidence: { originalCode: code, writeStarted: false } } });
+    function check() {
+      if (stopped) return stopped;
+      if (params.reviewOwnerToken && cancelledOwners.has(params.reviewOwnerToken))
+        return stopped = failure('codex_cancelled', 'The Undo owner disconnected; no further review writes were started.');
+      if (!Number.isFinite(limit) || now() >= deadlineAt)
+        return stopped = failure('writeback_deadline_exceeded', 'The review time budget expired; no further review writes were started.');
+      if (typeof deps.readWriteCancellationSequence === 'function' && deps.readWriteCancellationSequence() !== cancellation)
+        return stopped = failure('codex_cancelled', 'The review was cancelled; no further review writes were started.');
+      const project = deps.getProjectId?.() || /\/project\/([^/?#]+)/.exec(deps.window?.location?.pathname || '')?.[1];
+      if (!params.runProjectId || (project && project !== params.runProjectId))
+        return stopped = failure('aborted_project_changed', 'The original review project is no longer active.');
+      const blocked = deps.checkWritebackRunProjectId?.(params);
+      if (blocked) return stopped = blocked.skipped?.[0]?.result || blocked;
+      return null;
+    }
+    function assert() {
+      const blocked = check();
+      if (blocked) throw Object.assign(new Error(blocked.reason || blocked.code), { reviewFailure: blocked });
+    }
+    async function wait(work) {
+      assert();
+      let timer;
+      try {
+        const timeout = new Promise((_, reject) => {
+          timer = timers.setTimeout(() => {
+            const blocked = check() || failure('writeback_deadline_exceeded', 'The review time budget expired.');
+            stopped = blocked;
+            reject(Object.assign(new Error(blocked.reason), { reviewFailure: blocked }));
+          }, Math.max(0, deadlineAt - now()));
+        });
+        const result = await Promise.race([Promise.resolve().then(() => { assert(); return work(); }), timeout]);
+        assert();
+        return result;
+      } finally { if (timer != null) timers.clearTimeout(timer); }
+    }
+    const remember = entry => {
+      if (entry.result?.changedDocument === true || entry.result?.failure?.changedDocument === true) mutationStarted = true;
+      const ref = entry.trackedChange || { path: entry.operation?.path || '', key: 'snapshot-undo:' + (entry.operation?.path || ''), id: '' };
+      observations.set(ref.path + '\0' + (ref.key || ref.id || ''), { trackedChange: ref, result: entry.result });
+    };
+    const scoped = { ...deps, reviewGuard: check, reviewAwait: work => wait(work),
+      reviewDeadlineAt: deadlineAt,
+      createReviewApplied() { const list = []; appliedLists.add(list); return list; } };
+    for (const name of ['openFileByPath', 'setReviewingEnabled', 'verifyActiveEditorText']) {
+      if (typeof deps[name] === 'function') scoped[name] = (...args) => wait(() => deps[name](...args));
+    }
+    scoped.delay = ms => wait(() => deps.delay(Math.min(ms, Math.max(0, deadlineAt - now()))));
+    if (typeof deps.readActiveEditorText === 'function') scoped.readActiveEditorText = (...args) => { assert(); return deps.readActiveEditorText(...args); };
+    if (typeof deps.clickNode === 'function') scoped.clickNode = (...args) => { assert(); mutationStarted = true; return deps.clickNode(...args); };
+    for (const name of ['applyOperationsCore', 'applyOperationsWithNoTraceUndo']) {
+      if (typeof deps[name] !== 'function') continue;
+      scoped[name] = async (operations, options = {}) => {
+        assert();
+        const result = await deps[name](operations, { ...options, deadlineAt,
+          reviewGuard: check, reviewAwait: work => wait(work),
+          onOperationResult(entry) { remember(entry); options.onOperationResult?.(entry); } });
+        for (const entry of result.applied || []) remember(entry);
+        // Preserve a completed in-flight result even if cancellation just arrived.
+        return result;
+      };
+    }
+    if (typeof deps.confirmReviewWriteback === 'function') scoped.confirmReviewWriteback = async (original, result) => {
+      for (const entry of result.applied || []) remember(entry);
+      return deps.confirmReviewWriteback({ ...original, deadlineAt, reviewGuard: check, reviewAwait: work => wait(work) }, result);
+    };
+    async function run(work) {
+      try { assert(); return await work(scoped, params); }
+      catch (error) {
+        if (!error?.reviewFailure) throw error;
+        for (const list of appliedLists) for (const entry of list) remember(entry);
+        const applied = [...observations.values()].filter(entry => entry.result?.ok !== false);
+        const path = deps.getActiveFilePath?.() || '';
+        const changedDocument = mutationStarted || applied.some(entry => entry.result?.changedDocument !== false);
+        const blocked = { ...error.reviewFailure, changedDocument,
+          failure: { ...error.reviewFailure.failure, changedDocument,
+            evidence: { ...error.reviewFailure.failure?.evidence, writeStarted: changedDocument } } };
+        return { ok: false, applied, skipped: [{ trackedChange: { path }, result: blocked }] };
+      }
+    }
+    return Object.freeze({ run, check, assert, wait, params, scoped });
+  }
+  return Object.freeze({ create, cancelOwner });
+});

package/extension/src/page/saveState.js

@@ -311,16 +311,18 @@
         expected.set(path, entry.result.verifiedContent);
       }
     }
-    const deadline = now() + Math.max(0, timeoutMs);
+    const deadline = Math.min(now() + Math.max(0, timeoutMs), params.deadlineAt == null ? Infinity
+      : Number.isFinite(params.deadlineAt) ? params.deadlineAt : now());
     let attempts = 0;
     if (expected.size && typeof readSnapshot === 'function') {
       do {
-        if (!params.runProjectId || getProjectId() !== params.runProjectId) break;
+        if (now() >= deadline || params.reviewGuard?.() || !params.runProjectId || getProjectId() !== params.runProjectId) break;
         try {
-          const snapshot = await readSnapshot({ force: true, maxAgeMs: 0,
+          const read = () => readSnapshot({ force: true, maxAgeMs: 0,
             zipTimeoutMs: Math.max(1, Math.min(8000, deadline - now())) });
+          const snapshot = params.reviewAwait ? await params.reviewAwait(read) : await read();
           attempts++;
-          if (getProjectId() !== params.runProjectId) break;
+          if (now() >= deadline || params.reviewGuard?.() || getProjectId() !== params.runProjectId) break;
           if (snapshot?.ok === true && Array.from(expected).every(([path, content]) =>
             snapshot.files?.some(file => file.path === path && file.source === 'overleaf-zip'
               && file.content === content))) {

package/extension/src/page/snapshotRouter.js

@@ -97,9 +97,10 @@
             };
           }),
           capabilities: {
-            fullProjectSnapshot: true,
+            fullProjectSnapshot: zipSnapshot.pathIdentityComplete !== false,
+            pathIdentityComplete: zipSnapshot.pathIdentityComplete,
             method: 'overleaf-zip-file-list',
-            skipped: [],
+            skipped: zipSnapshot.skipped || [],
             diagnostics: {
               zipEndpoint: zipSnapshot.endpoint,
               zipTiming: zipSnapshot.diagnostics,
@@ -243,7 +244,7 @@
     if (zipSnapshot.ok && zipSnapshot.files.length) {
       const mergedFiles = mergeSnapshotFiles(
         zipSnapshot.files,
-        filterZipSnapshotOverlayFiles(zipSnapshot.files, lightweightSnapshot?.files || [])
+        filterZipSnapshotOverlayFiles(zipSnapshot.files, lightweightSnapshot?.files || [], zipSnapshot.skipped)
       );
       const files = filterRequestedSnapshotFiles(mergedFiles, params, activePath);
       const requestedPathsComplete = params.restrictToRequestedPathsOnly === true
@@ -255,7 +256,9 @@
         activePath,
         files,
         capabilities: {
-          fullProjectSnapshot: params.restrictToRequestedPathsOnly === true ? false : true,
+          fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && zipSnapshot.pathIdentityComplete !== false,
+          pathIdentityComplete: zipSnapshot.pathIdentityComplete,
+          contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
           skipped: zipSnapshot.skipped || [],
@@ -316,7 +319,8 @@
       80
     );
     const files = [];
-    const skipped = [];
+    const skipped = [...(zipSnapshot?.skipped || [])];
+    const ambiguousPaths = new Set(skipped.filter(file => file.reason === 'zip_path_duplicate').map(file => file.path));
     if (zipSnapshot && !zipSnapshot.ok) {
       skipped.push({
         path: 'project.zip',
@@ -326,6 +330,7 @@
     let previousSignature = '';
 
     for (const filePath of projectPaths) {
+      if (ambiguousPaths.has(filePath)) continue;
       if (filePath === snapshotActivePath) {
         const ready = await waitForActiveEditorText(filePath, 5000);
         if (!ready.ok) {
@@ -404,7 +409,7 @@
       await waitForActiveEditorText(activePath, 5000);
     }
 
-    if (snapshotActivePath && !files.length && (!lightweightOnly || params.allowZipFallback === false)) {
+    if (snapshotActivePath && !ambiguousPaths.has(snapshotActivePath) && !files.length && (!lightweightOnly || params.allowZipFallback === false)) {
       files.push({
         path: snapshotActivePath,
         content: readActiveEditorText(),
@@ -419,7 +424,8 @@
       activePath: snapshotActivePath,
       files,
       capabilities: {
-        fullProjectSnapshot: params.restrictToRequestedPathsOnly === true ? false : requestedPathsComplete,
+        fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && requestedPathsComplete && zipSnapshot?.pathIdentityComplete !== false,
+        pathIdentityComplete: zipSnapshot?.pathIdentityComplete,
         requestedPathsComplete,
         method: resolvePageSnapshotMethod(files, lightweightOnly),
         skipped,
@@ -438,15 +444,14 @@
 
   async function buildZipOnlyProjectSnapshot(params = {}) {
     const activePath = getPassiveActiveFilePath();
-    const activeText = params.serverOnly === true ? '' : activePath ? readActiveEditorText() : '';
+    // Capture read evidence together with the path/text before awaiting ZIP.
+    // A later editor identity cannot prove that an earlier empty read succeeded.
+    const activeOverlay = params.serverOnly === true ? [] : readActiveEditorOverlay(activePath);
 
     const zipSnapshot = await fetchProjectZipSnapshot(params);
     if (zipSnapshot.ok && zipSnapshot.files.length) {
-      const activeOverlay = params.serverOnly === true ? [] : buildActiveEditorOverlay(activePath, activeText, {
-        allowedPaths: zipSnapshot.files.map(file => file.path)
-      });
       const files = filterRequestedSnapshotFiles(
-        mergeSnapshotFiles(zipSnapshot.files, activeOverlay),
+        mergeSnapshotFiles(zipSnapshot.files, filterZipSnapshotOverlayFiles(zipSnapshot.files, activeOverlay, zipSnapshot.skipped)),
         params,
         activePath
       );
@@ -459,7 +464,9 @@
         activePath,
         files,
         capabilities: {
-          fullProjectSnapshot: params.restrictToRequestedPathsOnly === true ? false : true,
+          fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && zipSnapshot.pathIdentityComplete !== false,
+          pathIdentityComplete: zipSnapshot.pathIdentityComplete,
+          contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
           skipped: zipSnapshot.skipped || [],
@@ -478,16 +485,18 @@
       id: getProjectId(),
       url: window.location.href,
       activePath,
-      files: params.serverOnly === true ? [] : buildActiveEditorOverlay(activePath, activeText),
+      files: filterZipSnapshotOverlayFiles([], activeOverlay, zipSnapshot.skipped, true),
       capabilities: {
         fullProjectSnapshot: false,
+        pathIdentityComplete: zipSnapshot.pathIdentityComplete,
         method: params.serverOnly === true ? 'overleaf-zip-unavailable'
-          : activePath && window.CodexOverleafProjectFiles.isUsableProjectFileContent(activeText)
+          : activeOverlay.length
           ? 'active-editor-zip-only-fallback'
           : 'zip-only-fallback-empty',
-        skipped: [{
+        contentComplete: false,
+        skipped: [...(zipSnapshot.skipped || []), {
           path: 'project.zip',
-          reason: zipSnapshot.reason
+          reason: zipSnapshot.reason || 'ZIP file identities were incomplete'
         }],
         diagnostics: {
           docRecordCount: 0,
@@ -500,9 +509,11 @@
     };
   }
 
-  function filterZipSnapshotOverlayFiles(zipFiles = [], overlayFiles = []) {
+  function filterZipSnapshotOverlayFiles(zipFiles = [], overlayFiles = [], skipped = [], allowMissing = false) {
     const zipPaths = new Set((zipFiles || []).map(file => file.path).filter(Boolean));
-    return (overlayFiles || []).filter(file => file?.source !== 'active-editor' || zipPaths.has(file.path));
+    const ambiguousPaths = new Set((skipped || []).filter(file => file.reason === 'zip_path_duplicate').map(file => file.path));
+    return (overlayFiles || []).filter(file => !ambiguousPaths.has(file?.path)
+      && (allowMissing || file?.source !== 'active-editor' || zipPaths.has(file.path)));
   }
 
   function getRequestedSnapshotPaths(params = {}, activePath = '') {
@@ -520,19 +531,32 @@
     return (files || []).filter(file => requestedSet.has(file?.path));
   }
 
-  function buildActiveEditorOverlay(activePath, activeText, options = {}) {
-    if (!activePath || !window.CodexOverleafProjectFiles.isUsableProjectFileContent(activeText)) {
-      return [];
-    }
-    if (Array.isArray(options.allowedPaths) && !options.allowedPaths.includes(activePath)) {
+  function readActiveEditorOverlay(activePath) {
+    if (!activePath) return [];
+    try {
+      const content = readActiveEditorText();
+      if (typeof content !== 'string') return [];
+      if (!content.trim()) {
+        // The legacy reader also returns '' when no surface exists. A readable
+        // identity must independently confirm blank text before it can erase ZIP.
+        const identity = deps.getActiveEditorIdentity?.();
+        let observed;
+        if (identity?.type === 'codemirror-view' && typeof identity.doc?.toString === 'function') {
+          observed = identity.doc.toString();
+        } else if (identity?.type === 'textarea') {
+          observed = identity.node?.value;
+        } else if (identity?.type === 'contenteditable') {
+          const node = identity.node;
+          if (typeof node?.innerText === 'string' || typeof node?.textContent === 'string') {
+            observed = node.innerText || node.textContent || '';
+          }
+        }
+        if (typeof observed !== 'string' || observed !== content) return [];
+      } else if (!window.CodexOverleafProjectFiles.isUsableProjectFileContent(content)) return [];
+      return [{ path: activePath, content, source: 'active-editor', kind: 'text' }];
+    } catch (_error) {
       return [];
     }
-    return [{
-      path: activePath,
-      content: activeText,
-      source: 'active-editor',
-      kind: 'text'
-    }];
   }
 
   function mergeSnapshotFiles(primaryFiles = [], overrideFiles = []) {
@@ -541,7 +565,7 @@
       if (!file?.path || file.kind === 'binary' || typeof file.content !== 'string') {
         continue;
       }
-      if (!window.CodexOverleafProjectFiles.isUsableProjectFileContent(file.content)) {
+      if (file.content.trim() && !window.CodexOverleafProjectFiles.isUsableProjectFileContent(file.content)) {
         continue;
       }
       filesByPath.set(file.path, {
@@ -691,7 +715,7 @@
         });
         const extractMs = Date.now() - extractStartedAt;
         const files = extracted.files || [];
-        if (!files.length) {
+        if (!files.length && extracted.pathIdentityComplete !== false) {
           attempts.push({
             endpoint,
             status: response.status,
@@ -715,6 +739,7 @@
         return {
           ok: true,
           endpoint,
+          pathIdentityComplete: extracted.pathIdentityComplete,
           skipped: extracted.skipped || [],
           files: files.map(file => ({
             ...file,
@@ -841,6 +866,9 @@
     const entryCount = view.getUint16(eocdOffset + 10, true);
     const centralDirectoryOffset = view.getUint32(eocdOffset + 16, true);
     const decoder = new TextDecoder('utf-8');
+    const nameDecoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+    const seenPaths = new Set();
+    let pathIdentityComplete = true;
     const files = [];
     const skipped = [];
     let binaryBytes = 0;
@@ -859,7 +887,25 @@
       const commentLength = view.getUint16(offset + 32, true);
       const localHeaderOffset = view.getUint32(offset + 42, true);
       const rawName = bytes.slice(offset + 46, offset + 46 + fileNameLength);
-      const path = normalizeSafeProjectPath(decoder.decode(rawName));
+      let name = '';
+      try { name = nameDecoder.decode(rawName); } catch (_error) { /* unknown identity is incomplete */ }
+      const directory = name.endsWith('/');
+      const path = normalizeSafeProjectPath(directory ? name.slice(0, -1) : name);
+      if (!path || seenPaths.has(path)) {
+        if (path) {
+          const previousIndex = files.findIndex(file => file.path === path);
+          if (previousIndex >= 0) files.splice(previousIndex, 1);
+        }
+        pathIdentityComplete = false;
+        skipped.push({ path: name, reason: path ? 'zip_path_duplicate' : 'zip_path_invalid', unknownPath: !name });
+        offset += 46 + fileNameLength + extraLength + commentLength;
+        continue;
+      }
+      seenPaths.add(path);
+      if (directory) {
+        offset += 46 + fileNameLength + extraLength + commentLength;
+        continue;
+      }
       const isText = window.CodexOverleafProjectFiles.isTextProjectPath(path);
       const shouldInclude = path && !path.endsWith('/') && (isText || options.includeBinaryFiles);
 
@@ -904,7 +950,7 @@
       offset += 46 + fileNameLength + extraLength + commentLength;
     }
 
-    return { files, skipped };
+    return { files, skipped, pathIdentityComplete };
   }
 
   function uint8ArrayToBase64(bytes) {
@@ -1035,11 +1081,10 @@
   }
 
   function fallbackNormalizeSafeProjectPath(value) {
-    const text = String(value || '').replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\/+|\/+$/g, '').trim();
-    if (!text || text.split('/').some(part => !part || part === '.' || part === '..')) {
-      return '';
-    }
-    return text;
+    if (typeof value !== 'string' || !value || value.length > 2048 || value.trim() !== value
+      || /[\u0000-\u001f\u007f]/.test(value) || value.startsWith('/')
+      || value.includes('\\') || /^[A-Za-z]:/.test(value)) return '';
+    return value.split('/').some(part => !part || part === '.' || part === '..') ? '' : value;
   }
 
   return { create };