codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/page/treeOperations.js

@@ -246,7 +246,7 @@
     if (node) {
       dispatchFileTreeOpenClick(node);
       await delay(250);
-      const active = await waitForActiveFile(normalizedPath, 5000);
+      const active = await waitForActiveFile(normalizedPath, options.activeWaitMs ?? 5000);
       diagnostics.domClickActivePath = getActiveFilePath();
       if (active) {
         return {
@@ -254,6 +254,20 @@
           method: 'dom-click'
         };
       }
+      // Overleaf can drop a click while the previous document is still
+      // settling (e.g. right after a multi-file write). Re-resolve the row,
+      // activate the row itself plus a keyboard Enter, and wait once more.
+      const retryNode = findFileTreeNode(normalizedPath, { invalidateCache: true }) || node;
+      dispatchActivationSequence(retryNode);
+      dispatchKeyboardOpen(findFileTreeOpenClickTarget(retryNode) || retryNode);
+      const retried = await waitForActiveFile(normalizedPath, options.retryWaitMs ?? 4000);
+      diagnostics.domRetryActivePath = getActiveFilePath() || 'unknown';
+      if (retried) {
+        return {
+          ok: true,
+          method: 'dom-click-retry'
+        };
+      }
     }
 
     const manager = findFileTreeManager();
@@ -322,7 +336,7 @@
       .map(item => `${item.method}/${item.argType}:ok=${item.ok ? 'yes' : 'no'},active=${item.activePath || 'unknown'}${item.error ? ',error=' + item.error : ''}`)
       .slice(0, 8)
       .join('|') || 'none';
-    return `open diagnostics initial=${diagnostics.initialActivePath || 'unknown'}, initialNode=${diagnostics.initialDomNodeFound ? 'yes' : 'no'}, folders=${folders}, postExpandNode=${diagnostics.postExpandDomNodeFound ? 'yes' : 'no'}, domClickActive=${diagnostics.domClickActivePath || 'unknown'}, manager=${managers}`;
+    return `open diagnostics initial=${diagnostics.initialActivePath || 'unknown'}, initialNode=${diagnostics.initialDomNodeFound ? 'yes' : 'no'}, folders=${folders}, postExpandNode=${diagnostics.postExpandDomNodeFound ? 'yes' : 'no'}, domClickActive=${diagnostics.domClickActivePath || 'unknown'}, domRetryActive=${diagnostics.domRetryActivePath || 'none'}, manager=${managers}`;
   }
 
   function dispatchFileTreeOpenClick(node) {
@@ -361,6 +375,16 @@
     }
   }
 
+  function dispatchKeyboardOpen(node) {
+    for (const type of ['keydown', 'keyup']) {
+      try {
+        node?.dispatchEvent(new KeyboardEvent(type, { key: 'Enter', code: 'Enter', bubbles: true, cancelable: true }));
+      } catch (_error) {
+        // KeyboardEvent may be unavailable in synthetic harnesses.
+      }
+    }
+  }
+
   function findFileTreeOpenClickTarget(node) {
     const selectors = [
       '.file-tree-entity-details',
@@ -1540,15 +1564,6 @@
       };
     }
 
-    function fileTreeMethodNames(type) {
-      return {
-        create: ['createDoc', 'createFile', 'addDoc', 'addFile'],
-        rename: ['renameEntity', 'renameFile', 'renameDoc'],
-        move: ['moveEntity', 'moveFile', 'moveDoc'],
-        delete: ['deleteEntity', 'deleteFile', 'deleteDoc', 'removeEntity']
-      }[type] || [];
-    }
-
     function resolveTimeoutMs(options = {}, fallback) {
       const value = Number(options.timeoutMs);
       return Number.isFinite(value) && value >= 0 ? value : fallback;
@@ -1591,5 +1606,11 @@
     return text;
   }
 
-  return { create };
+  function fileTreeMethodNames(type) {
+    return {
+      create: ['createDoc', 'createFile', 'addDoc', 'addFile'], rename: ['renameEntity', 'renameFile', 'renameDoc'],
+      move: ['moveEntity', 'moveFile', 'moveDoc'], delete: ['deleteEntity', 'deleteFile', 'deleteDoc', 'removeEntity']
+    }[type] || [];
+  }
+  return { create, fileTreeMethodNames };
 });

package/extension/src/page/updateSafetyProbe.js

@@ -0,0 +1,41 @@
+(function installUpdateSafetyProbe(root) {
+  'use strict';
+  if (root.CodexOverleafUpdateSafetyProbe?.revision === '1') return;
+  const identities = new WeakMap();
+  function identity(value) {
+    if (!identities.has(value)) identities.set(value, crypto.randomUUID());
+    return identities.get(value);
+  }
+  // The same full CodeMirror document sources used by pageBridge. No DOM
+  // viewport text is eligible for the quiet-save fallback.
+  function editorView() {
+    const store = root.overleaf?.unstable?.store || root.Overleaf?.unstable?.store;
+    const get = key => { try { return store?.get?.(key) || {}; } catch (_) { return {}; } };
+    return [get('editor.view'), get('editor.view.camel'), get('editor').view,
+      root.overleaf?.unstable?.editorView, root.Overleaf?.editorView, root._ide?.editorView]
+      .find(value => value && typeof value.dispatch === 'function' && value.state?.doc
+        && typeof value.state.doc.toString === 'function') || null;
+  }
+  function fileIdentity() {
+    const store = root.overleaf?.unstable?.store || root.Overleaf?.unstable?.store;
+    const get = key => { try { return store?.get?.(key); } catch (_) { return ''; } };
+    const selected = document.querySelector('[role="treeitem"][aria-selected="true"] [data-file-id]');
+    return [get('editor.open_doc_id'), get('editor.openDocId'), root._ide?.editor?.open_doc_id,
+      root._ide?.editor?.openDocId, selected?.getAttribute('data-file-id'),
+      get('editor.open_doc_name'), get('editor.openDocName')].find(value => typeof value === 'string' && value) || '';
+  }
+  async function probe(expectedUrl) {
+    const view = editorView(), doc = view?.state?.doc, file = fileIdentity();
+    if (location.href !== expectedUrl || !file || !root.CodexOverleafSaveState) return { ok: false, state: 'unavailable' };
+    const save = root.CodexOverleafSaveState.create({ window: root, document,
+      delay: ms => new Promise(resolve => setTimeout(resolve, ms)),
+      detectEditor: () => ({ ok: Boolean(view && editorView() === view && view.state.doc === doc) }),
+      getActiveFilePath: () => doc ? identity(doc) : '', readActiveEditorText: () => view?.state.doc.toString() || '' });
+    const result = await save.waitForSaveState({ deadlineMs: 1500, pollIntervalMs: 100,
+      requirePositiveSignal: true, allowQuietEditorFallback: Boolean(doc), quietFallbackMs: 1000 });
+    if (location.href !== expectedUrl || fileIdentity() !== file || editorView() !== view
+      || (view && view.state.doc !== doc)) return { ok: false, state: 'unavailable' };
+    return { ok: result.ok === true, state: result.state, identity: file + ':' + (doc ? identity(doc) : 'positive-save-signal') };
+  }
+  root.CodexOverleafUpdateSafetyProbe = Object.freeze({ revision: '1', probe });
+})(globalThis);

package/extension/src/page/writebackReceiptJournal.js

@@ -0,0 +1,114 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafWritebackReceiptJournal = api;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+
+  function create({ getProjectId, prepareEditor, applyOperations, now = Date.now,
+    retentionMs = 600000, maxReceipts = 16 }) {
+    const receipts = new Map();
+    let active = null;
+    const clone = value => JSON.parse(JSON.stringify(value));
+    const empty = () => ({ applied: [], skipped: [], trackedChanges: [], trackedChangeCaptures: [] });
+    function failure(code, error) { return { ok: false, code, error, changedDocument: false }; }
+    function deadlineFailure(params) {
+      return params.deadlineAt != null && (!Number.isFinite(params.deadlineAt) || now() >= params.deadlineAt)
+        ? failure('writeback_deadline_exceeded', 'The operation deadline expired before any new write could start.') : null;
+    }
+    function prune() {
+      for (const [id, receipt] of receipts) {
+        if (receipt.state === 'completed' && now() - receipt.updatedAt > retentionMs) receipts.delete(id);
+      }
+      while (receipts.size >= maxReceipts) {
+        const oldest = Array.from(receipts).find(([, value]) => value.state === 'completed');
+        if (!oldest) break;
+        receipts.delete(oldest[0]);
+      }
+    }
+    function snapshot(receipt) {
+      const result = receipt.result || {
+        ...receipt.partial,
+        ok: receipt.partial.skipped.length === 0,
+        trackedChanges: receipt.partial.trackedChangeCaptures.some(value => value.state !== 'observed')
+          ? [] : receipt.partial.trackedChanges
+      };
+      return clone({ ok: true, requestId: receipt.id, runProjectId: receipt.projectId,
+        state: receipt.state, updatedAt: receipt.updatedAt, result });
+    }
+    function get(params = {}) {
+      if (!params.runProjectId || params.runProjectId !== getProjectId(params.runProjectId)) {
+        return failure('writeback_receipt_scope_changed', 'The writeback project is no longer active.');
+      }
+      const receipt = receipts.get(params.requestId);
+      if (!receipt || receipt.projectId !== params.runProjectId) {
+        return failure('writeback_receipt_missing', 'The original writeback receipt is unavailable. Do not replay the write.');
+      }
+      return snapshot(receipt);
+    }
+    async function apply(params = {}) {
+      const id = params.writebackRequestId, projectId = params.runProjectId;
+      if (typeof id !== 'string' || !id || id.length > 160 || !projectId || projectId !== getProjectId(projectId)) {
+        return failure('writeback_receipt_identity_invalid', 'Writeback request identity could not be confirmed.');
+      }
+      const fingerprint = JSON.stringify(params.operations || []);
+      const previous = receipts.get(id);
+      if (previous) {
+        if (previous.projectId !== projectId || previous.fingerprint !== fingerprint) {
+          return failure('writeback_receipt_conflict', 'The writeback request ID was reused with different operations.');
+        }
+        return previous.promise; // Duplicate delivery retrieves the original work; it never executes it again.
+      }
+      const expired = deadlineFailure(params);
+      if (expired) return expired;
+      if (active) return failure('writeback_in_progress', 'An earlier writeback is still running. Wait for its result before writing again.');
+      prune();
+      const receipt = { id, projectId, fingerprint, state: 'running', updatedAt: now(), partial: empty() };
+      receipts.set(id, receipt);
+      active = receipt;
+      const onOperationResult = ({ operation, result }) => {
+        const entry = clone({ operation, result });
+        (result.ok ? receipt.partial.applied : receipt.partial.skipped).push(entry);
+        if (operation.type === 'edit' && result.ok && Array.isArray(result.trackedChanges)) {
+          receipt.partial.trackedChanges.push(...clone(result.trackedChanges));
+        }
+        if (result.trackedChangeCapture) receipt.partial.trackedChangeCaptures.push(clone(result.trackedChangeCapture));
+        receipt.updatedAt = now();
+      };
+      // Defer execution until the promise is assigned, including for immediately completed operations.
+      receipt.promise = Promise.resolve().then(async () => {
+        if (deadlineFailure(params)) return deadlineFailure(params);
+        if (params.reviewingPolicy === 'no-trace-undo') {
+          const prepared = await prepareEditor(params);
+          if (prepared.ok !== true) return { applied: [], changedDocument: false,
+            skipped: (params.operations || []).map(operation => ({ operation, result: prepared })) };
+        }
+        if (deadlineFailure(params)) return deadlineFailure(params);
+        return applyOperations(params.operations || [], {
+          baseFiles: params.baseFiles || null,
+          reviewingPolicy: params.reviewingPolicy || '',
+          ...(params.reviewOwnerToken ? { reviewOwnerToken: params.reviewOwnerToken } : {}),
+          requireReviewing: params.requireReviewing === true,
+          requireEditing: params.requireEditing === true,
+          retryCreates: params.retryCreates === true,
+          runProjectId: projectId,
+          ...(params.deadlineAt == null ? {} : { deadlineAt: params.deadlineAt }),
+          onOperationResult
+        });
+      }).catch(error => ({
+        ...snapshot(receipt).result, ok: false, code: error?.code || 'page_bridge_dispatch_failed',
+        error: error?.message || String(error), requestId: id, changedDocument: true
+      })).then(result => {
+        receipt.result = clone(result && typeof result === 'object' ? result
+          : { ok: false, code: 'writeback_result_unconfirmed', error: 'The page returned no writeback result.' });
+        receipt.state = 'completed';
+        receipt.updatedAt = now();
+        if (active === receipt) active = null;
+        return receipt.result;
+      });
+      return receipt.promise;
+    }
+    return Object.freeze({ apply, get });
+  }
+  return { create };
+});