codex-overleaf-link 2.5.1 → 2.6.5

package/extension/src/page/overleafProjectSnapshot.js

@@ -16,27 +16,70 @@
     const snapshotCache = createKeyedCache();
     const fileListCache = createKeyedCache();
 
+    function editorCaptureKey() {
+      const capture = deps.captureEditorDocument?.({ path: deps.getActiveFilePath?.(), projectId: deps.getProjectId?.() });
+      return capture?.ok ? capture : null;
+    }
+
+    function sameEditorCapture(left, right) {
+      return Boolean(left?.ok && right?.ok) && left.view === right.view && left.state === right.state && left.doc === right.doc
+        && left.text === right.text && ['path', 'projectId', 'documentId', 'targetDocumentId']
+          .every(key => left.documentIdentity[key] === right.documentIdentity[key]);
+    }
+
+    function hasEditorOverlay(snapshot) {
+      // Navigation reads carry the open method as their source. Only ZIP and
+      // document fetches are independent of the mounted editor.
+      return snapshot?.files?.some(file => typeof file.content === 'string'
+        && !/^overleaf-(?:zip|doc-fetch)/.test(file.source || ''));
+    }
+
+    function hasNavigationReads(snapshot) {
+      return snapshot?.files?.some(file => typeof file.content === 'string' && file.source !== 'active-editor'
+        && !/^overleaf-(?:zip|doc-fetch)/.test(file.source || ''));
+    }
+
     async function getProjectSnapshot(params = {}) {
       const cacheKey = getSnapshotCacheKey(params);
       const maxAgeMs = normalizeSnapshotMaxAge(params.maxAgeMs);
       const now = Date.now();
       const cacheEntry = snapshotCache.entries.get(cacheKey);
+      const captureKey = editorCaptureKey();
+      const projectId = deps.getProjectId?.();
 
-      if (!params.force && cacheEntry?.pending) {
-        return cacheEntry.pending;
+      function currentSnapshot(snapshot) {
+        if (deps.getProjectId?.() !== projectId) return withoutEditorFiles(snapshot, true);
+        if (!hasEditorOverlay(snapshot) || params.allowEditorNavigation === true || hasNavigationReads(snapshot)) return snapshot;
+        const captures = deps.getSnapshotEditorCaptures?.(snapshot) || [];
+        if (captures.length === 1 && deps.isCaptureCurrent?.(captures[0])) return snapshot;
+        // Fallback captures can be returned once, but never reused from cache.
+        if (!snapshot.files.some(file => file.documentIdentity !== undefined)) return snapshot;
+        return withoutEditorFiles(snapshot);
       }
 
-      if (!params.force && cacheEntry?.value && now - cacheEntry.capturedAt <= maxAgeMs) {
+      if (!params.force && cacheEntry?.pending && (params.allowEditorNavigation === false || params.zipOnly || params.serverOnly)
+        && (params.serverOnly === true || sameEditorCapture(cacheEntry.pendingCaptureKey, captureKey))) {
+        const snapshot = await cacheEntry.pending;
+        return currentSnapshot(snapshot);
+      }
+
+      if (!params.force && cacheEntry?.value && now - cacheEntry.capturedAt <= maxAgeMs
+        && (!hasEditorOverlay(cacheEntry.value) || (params.allowEditorNavigation !== true
+          && sameEditorCapture(cacheEntry.captureKey, captureKey)))) {
         return withSnapshotCacheMetadata(cacheEntry.value, 'memory', cacheEntry.capturedAt);
       }
 
       const pending = deps.buildProjectSnapshot(params)
         .then(snapshot => {
+          const captures = deps.getSnapshotEditorCaptures?.(snapshot) || [];
+          const finalCapture = captures.length === 1 ? captures[0] : null;
+          snapshot = currentSnapshot(snapshot);
           const capturedAt = Date.now();
           const currentEntry = snapshotCache.entries.get(cacheKey);
           if (currentEntry?.pending === pending) {
             snapshotCache.entries.set(cacheKey, {
               value: snapshot,
+              captureKey: params.allowEditorNavigation === true || hasNavigationReads(snapshot) ? null : finalCapture,
               capturedAt,
               pending: null
             });
@@ -52,12 +95,22 @@
 
       snapshotCache.entries.set(cacheKey, {
         value: cacheEntry?.value || null,
+        captureKey: cacheEntry?.captureKey,
+        pendingCaptureKey: captureKey,
         capturedAt: cacheEntry?.capturedAt || 0,
         pending
       });
       return pending;
     }
 
+    function withoutEditorFiles(snapshot, projectChanged = false) {
+      const files = projectChanged ? [] : (snapshot?.files || []).filter(file => /^overleaf-(?:zip|doc-fetch)/.test(file.source || ''));
+      const removed = (snapshot?.files || []).filter(file => !files.includes(file));
+      return { ...snapshot, files, capabilities: { ...snapshot?.capabilities, fullProjectSnapshot: false,
+        requestedPathsComplete: false, skipped: [...(snapshot?.capabilities?.skipped || []),
+          ...removed.map(file => ({ path: file.path, reason: 'document_identity_mismatch' }))] } };
+    }
+
     async function getProjectFileList(params = {}) {
       const cacheKey = getProjectFileListCacheKey(params);
       const maxAgeMs = normalizeFileListMaxAge(params.maxAgeMs);

package/extension/src/page/snapshotRouter.js

@@ -17,12 +17,22 @@
     const normalizeSafeProjectPath = typeof deps.normalizePath === 'function'
       ? deps.normalizePath
       : fallbackNormalizeSafeProjectPath;
-    const readActiveEditorText = typeof deps.readActiveEditorText === 'function'
-      ? deps.readActiveEditorText
-      : () => '';
     let invalidatedAt = 0;
     let preferredZipEndpoint = '';
     const writebackReads = new Set();
+    const editorCaptures = new WeakMap();
+
+    function editorFile(path, ready, source) {
+      if (ready.documentIdentity && ready.capture) editorCaptures.set(ready.documentIdentity, ready.capture);
+      return { path, content: ready.text, source, kind: 'text',
+        ...(ready.documentIdentity !== undefined ? { documentIdentity: ready.documentIdentity } : {}) };
+    }
+
+    function getSnapshotEditorCaptures(snapshot) {
+      return (snapshot?.files || []).filter(file => typeof file.content === 'string'
+        && !/^overleaf-(?:zip|doc-fetch)/.test(file.source || ''))
+        .map(file => editorCaptures.get(file.documentIdentity));
+    }
 
     function getProjectId() {
       return treeOperations.getProjectId?.() || null;
@@ -214,6 +224,18 @@
   }
 
   async function buildProjectSnapshot(params = {}) {
+    const projectId = params.projectId || getProjectId();
+    if (!projectId || projectId !== getProjectId()) return projectChangedSnapshot(projectId);
+    const snapshot = await buildProjectSnapshotForProject({ ...params, projectId });
+    return getProjectId() === projectId ? snapshot : projectChangedSnapshot(projectId);
+  }
+
+  function projectChangedSnapshot(projectId) {
+    return { ok: false, id: projectId, files: [], capabilities: { fullProjectSnapshot: false,
+      skipped: [{ path: '', reason: 'document_identity_mismatch' }] } };
+  }
+
+  async function buildProjectSnapshotForProject(params = {}) {
     if (params.zipOnly || params.serverOnly === true) {
       return buildZipOnlyProjectSnapshot(params);
     }
@@ -242,9 +264,18 @@
 
     const zipSnapshot = await fetchProjectZipSnapshot(params);
     if (zipSnapshot.ok && zipSnapshot.files.length) {
+      const skipped = [...(zipSnapshot.skipped || [])];
+      const overlays = [...(lightweightSnapshot?.files || [])];
+      for (let index = 0; index < overlays.length; index++) {
+        if (overlays[index].source !== 'active-editor') continue;
+        const captured = await readActiveEditorOverlay(overlays[index].path, zipSnapshot.files, { projectId: params.projectId });
+        skipped.push(...captured.skipped);
+        overlays.splice(index, 1, ...captured.files);
+        if (!captured.files.length) index--;
+      }
       const mergedFiles = mergeSnapshotFiles(
         zipSnapshot.files,
-        filterZipSnapshotOverlayFiles(zipSnapshot.files, lightweightSnapshot?.files || [], zipSnapshot.skipped)
+        filterZipSnapshotOverlayFiles(zipSnapshot.files, overlays, skipped)
       );
       const files = filterRequestedSnapshotFiles(mergedFiles, params, activePath);
       const requestedPathsComplete = params.restrictToRequestedPathsOnly === true
@@ -261,7 +292,7 @@
           contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
-          skipped: zipSnapshot.skipped || [],
+          skipped,
           diagnostics: {
             zipEndpoint: zipSnapshot.endpoint,
             zipTiming: zipSnapshot.diagnostics,
@@ -309,15 +340,16 @@
       snapshotActivePath,
       ...(Array.isArray(params.focusFiles) ? params.focusFiles : [])
     ];
+    const enumeratedPaths = params.restrictToRequestedPathsOnly === true
+      ? []
+      : collectProjectTextPaths(snapshotActivePath);
     const projectPaths = window.CodexOverleafProjectFiles.collectUniqueTextPaths(
-      params.restrictToRequestedPathsOnly === true
-        ? requestedPaths
-        : [
-          ...requestedPaths,
-          ...collectProjectTextPaths(snapshotActivePath)
-        ],
+      [...requestedPaths, ...enumeratedPaths],
       80
     );
+    const enumerationTruncated = projectPaths.truncated === true
+      || enumeratedPaths.truncated === true
+      || internalDocRecords.truncated === true;
     const files = [];
     const skipped = [...(zipSnapshot?.skipped || [])];
     const ambiguousPaths = new Set(skipped.filter(file => file.reason === 'zip_path_duplicate').map(file => file.path));
@@ -332,7 +364,7 @@
     for (const filePath of projectPaths) {
       if (ambiguousPaths.has(filePath)) continue;
       if (filePath === snapshotActivePath) {
-        const ready = await waitForActiveEditorText(filePath, 5000);
+        const ready = await waitForActiveEditorText(filePath, 5000, { allowEmpty: true, projectId: params.projectId });
         if (!ready.ok) {
           skipped.push({
             path: filePath,
@@ -340,18 +372,14 @@
           });
           continue;
         }
-        files.push({
-          path: filePath,
-          content: ready.text,
-          source: 'active-editor'
-        });
+        files.push(editorFile(filePath, ready, 'active-editor'));
         previousSignature = contentSignature(ready.text);
         continue;
       }
 
       const docRecord = docRecordByPath.get(filePath);
       if (docRecord) {
-        const fetched = await fetchOverleafDocContent(docRecord);
+        const fetched = await fetchOverleafDocContent(docRecord, params.projectId);
         if (fetched.ok) {
           files.push({
             path: filePath,
@@ -365,6 +393,7 @@
           path: filePath,
           reason: fetched.reason
         });
+        if (fetched.reason === 'document_identity_mismatch') continue;
       }
 
       if (!canOpenInactiveFileForSnapshot(filePath, params, lightweightOnly, docRecord)) {
@@ -386,7 +415,9 @@
 
       await waitForActiveFile(filePath, 5000);
       const ready = await waitForActiveEditorText(filePath, 7000, {
-        notSignature: previousSignature
+        notSignature: previousSignature,
+        projectId: params.projectId,
+        allowEmpty: true
       });
       if (!ready.ok) {
         skipped.push({
@@ -395,11 +426,7 @@
         });
         continue;
       }
-      files.push({
-        path: filePath,
-        content: ready.text,
-        source: opened.method || 'file-tree-open'
-      });
+      files.push(editorFile(filePath, ready, opened.method || 'file-tree-open'));
       previousSignature = contentSignature(ready.text);
     }
 
@@ -409,14 +436,6 @@
       await waitForActiveEditorText(activePath, 5000);
     }
 
-    if (snapshotActivePath && !ambiguousPaths.has(snapshotActivePath) && !files.length && (!lightweightOnly || params.allowZipFallback === false)) {
-      files.push({
-        path: snapshotActivePath,
-        content: readActiveEditorText(),
-        source: 'active-editor'
-      });
-    }
-
     const requestedPathsComplete = isCompleteProjectSnapshot(files, projectPaths);
     return {
       id: getProjectId(),
@@ -424,7 +443,7 @@
       activePath: snapshotActivePath,
       files,
       capabilities: {
-        fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && requestedPathsComplete && zipSnapshot?.pathIdentityComplete !== false,
+        fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && !enumerationTruncated && requestedPathsComplete && zipSnapshot?.pathIdentityComplete !== false,
         pathIdentityComplete: zipSnapshot?.pathIdentityComplete,
         requestedPathsComplete,
         method: resolvePageSnapshotMethod(files, lightweightOnly),
@@ -444,11 +463,11 @@
 
   async function buildZipOnlyProjectSnapshot(params = {}) {
     const activePath = getPassiveActiveFilePath();
-    // 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);
+    const captured = params.serverOnly === true ? { files: [], skipped: [] }
+      : await readActiveEditorOverlay(activePath, zipSnapshot.ok ? zipSnapshot.files : null, { passive: true, projectId: params.projectId });
+    const activeOverlay = captured.files;
+    const skipped = [...(zipSnapshot.skipped || []), ...captured.skipped];
     if (zipSnapshot.ok && zipSnapshot.files.length) {
       const files = filterRequestedSnapshotFiles(
         mergeSnapshotFiles(zipSnapshot.files, filterZipSnapshotOverlayFiles(zipSnapshot.files, activeOverlay, zipSnapshot.skipped)),
@@ -469,7 +488,7 @@
           contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
-          skipped: zipSnapshot.skipped || [],
+          skipped,
           diagnostics: {
             zipEndpoint: zipSnapshot.endpoint,
             zipTiming: zipSnapshot.diagnostics,
@@ -494,7 +513,7 @@
           ? 'active-editor-zip-only-fallback'
           : 'zip-only-fallback-empty',
         contentComplete: false,
-        skipped: [...(zipSnapshot.skipped || []), {
+        skipped: [...skipped, {
           path: 'project.zip',
           reason: zipSnapshot.reason || 'ZIP file identities were incomplete'
         }],
@@ -531,32 +550,15 @@
     return (files || []).filter(file => requestedSet.has(file?.path));
   }
 
-  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 [];
-    }
+  async function readActiveEditorOverlay(activePath, referenceFiles, options = {}) {
+    if (!activePath) return { files: [], skipped: [] };
+    const references = referenceFiles ? new Map(referenceFiles
+      .filter(file => file.kind !== 'binary' && typeof file.content === 'string')
+      .map(file => [file.path, file.content])) : null;
+    const ready = await waitForActiveEditorText(activePath, 5000, { ...options, allowEmpty: true, references });
+    return ready.ok
+      ? { files: [editorFile(activePath, ready, 'active-editor')], skipped: [] }
+      : { files: [], skipped: [{ path: activePath, reason: ready.code || ready.reason }] };
   }
 
   function mergeSnapshotFiles(primaryFiles = [], overrideFiles = []) {
@@ -609,7 +611,7 @@
     return projectPaths.every(filePath => capturedPaths.has(filePath));
   }
 
-  async function fetchOverleafDocContent(record) {
+  async function fetchOverleafDocContent(record, expectedProjectId = getProjectId()) {
     if (!record?.id || !record.path) {
       return {
         ok: false,
@@ -625,6 +627,9 @@
       };
     }
 
+    const target = treeOperations.resolveTargetDocument?.(record.path, { projectId });
+    if (projectId !== expectedProjectId || (target && (target.status !== 'known' || target.documentId !== record.id.toLowerCase())))
+      return { ok: false, reason: 'document_identity_mismatch' };
     try {
       const response = await fetch(`${window.location.origin}/project/${encodeURIComponent(projectId)}/doc/${encodeURIComponent(record.id)}`, {
         credentials: 'include',
@@ -639,6 +644,9 @@
         };
       }
       const payload = await response.json();
+      const currentTarget = treeOperations.resolveTargetDocument?.(record.path, { projectId });
+      if (getProjectId() !== projectId || (target && (currentTarget?.status !== 'known' || currentTarget.documentId !== target.documentId)))
+        return { ok: false, reason: 'document_identity_mismatch' };
       const content = readDocPayloadContent(payload);
       if (!window.CodexOverleafProjectFiles.isUsableProjectFileContent(content)) {
         return {
@@ -1071,6 +1079,7 @@
       assembleSnapshot,
       buildProjectFileList,
       buildProjectSnapshot,
+      getSnapshotEditorCaptures,
       fetchProjectZipSnapshot,
       getInvalidatedAt,
       getRequestedSnapshotPaths,

package/extension/src/page/textCoordinates.js

@@ -6,7 +6,7 @@
   'use strict';
 
   function resolveJumpToPositionRange(params, text, filePath) {
-    if (params.line === undefined && params.column === undefined) {
+    if (params.line === undefined && params.column === undefined && params.endLine === undefined) {
       return {
         ok: true,
         from: params.from,
@@ -33,6 +33,22 @@
       });
     }
 
+    if (params.endLine !== undefined) {
+      const endLineNumber = Number(params.endLine);
+      if (!Number.isInteger(endLineNumber) || endLineNumber < lineNumber) {
+        return jumpPositionOutOfRange('line_out_of_range', filePath, {
+          line: lineNumber,
+          endLine: Number.isInteger(endLineNumber) ? endLineNumber : params.endLine,
+          lineCount
+        });
+      }
+      return {
+        ok: true,
+        from: line.start,
+        to: lines[Math.min(endLineNumber, lineCount) - 1].end
+      };
+    }
+
     const lineLength = line.end - line.start;
     if (params.selectLine === true) {
       return {

package/extension/src/page/textFileCreator.js

@@ -108,9 +108,14 @@
     }
     function verificationFailure(error, changedDocument, phase) {
       const interrupted = ['codex_cancelled', 'aborted_project_changed'].includes(error?.code);
-      const code = interrupted ? error.code : changedDocument ? 'file_upload_unconfirmed' : 'source_zip_unavailable';
+      // Only a failed server read means the project could not be checked; any
+      // other error before the upload came from the Overleaf file-tree controls.
+      const treeControls = !interrupted && !changedDocument && error?.code !== 'source_zip_unavailable';
+      const code = interrupted ? error.code : changedDocument ? 'file_upload_unconfirmed'
+        : treeControls ? 'file_tree_controls_unavailable' : 'source_zip_unavailable';
       const reason = interrupted ? error.message : changedDocument
         ? 'The file was submitted, but its saved content could not be confirmed.'
+        : treeControls ? 'Codex could not safely perform this file operation with the available Overleaf controls.'
         : 'The project could not be checked before uploading this file.';
       return { ok: false, code, reason, changedDocument, diagnostics: {
         verificationPhase: phase, ...(error?.diagnostics || {}), reason: error?.technicalMessage || error?.message || ''
@@ -610,6 +615,9 @@
     async function ensureWriteMode(reviewing, params = {}) {
       const ensureMode = reviewing ? deps.ensureReviewing : deps.ensureEditing;
       if (typeof ensureMode !== 'function') return { ok: false, reason: 'Editor mode controls are unavailable.' };
+      // An open paywall can make the underlying editor inert. Detect it before
+      // preparation attempts any file navigation behind that modal.
+      if (reviewing && deps.findUpgradeModal?.()) return ensureMode(params);
       const prepared = await prepareEditor(params);
       return prepared.ok ? ensureMode(params) : prepared;
     }