codex-overleaf-link 2.4.0 → 2.5.0

package/extension/src/page/writebackRouter.js

@@ -17,6 +17,7 @@
       ? Math.max(0, Number(deps.writebackOpenSettleMs))
       : 1200;
     const diagnosticsRevision = String(deps.diagnosticsRevision || '');
+    const now = deps.now || Date.now;
     // Cross-world cancel signal reader. Returns the current page-bridge
     // sequence number, which monotonically increments when content-side
     // calls pageBridge.cancelActiveWrite. applyOperationsCore captures the
@@ -269,6 +270,11 @@
         fallbackUserMessage: 'The edit anchor no longer matches current Overleaf content.',
         fallbackNextAction: 'Rerun the task against the current document.'
       },
+      write_operation_failed: {
+        stage: 'write', severity: 'error', defaultRetryable: true,
+        fallbackUserMessage: 'Editor write call failed.',
+        fallbackNextAction: 'Retry after the editor is stable.'
+      },
       write_observed_mismatch: {
         stage: 'verify', severity: 'error', defaultRetryable: false,
         fallbackUserMessage: 'Codex attempted to write, but the content read back from Overleaf did not match the approved change.',
@@ -398,7 +404,8 @@
     for (let attempt = 0; attempt < 2; attempt++) {
       if (!isEditingConfirmedForNoTraceUndo(getReviewingState({}))) {
         toggle = await setReviewingEnabled(false, { waitMs: 1800 });
-        if (!toggle.ok) return toggle;
+        if (!toggle.ok && (!['editing_not_confirmed', 'reviewing_disable_failed'].includes(toggle.code)
+          || !isEditingConfirmedForNoTraceUndo(getReviewingState({})))) return toggle;
         changed = changed || toggle.changed === true;
       }
       await delay(180);
@@ -447,20 +454,8 @@
       document: window.document,
       treeOperations
     });
-    // Cross-world cancel baseline. The user clicks cancel during writeback →
-    // content-side calls pageBridge.cancelActiveWrite → the sequence number
-    // bumps. Two layers of responsiveness:
-    //   1. Between-ops check — short-circuits the next iteration so the
-    //      remaining ops never start.
-    //   2. Race the in-flight op against a cancellation poller (50ms
-    //      interval) so a click DURING a slow op (e.g. inside a 5s
-    //      waitForActiveFile poll) is observed within ~50ms instead of
-    //      having to wait out the op's internal timeout. The op promise
-    //      keeps running in the page world after the race resolves — its
-    //      eventual result is ignored. This is "user-perceived instant
-    //      cancel": the spinner stops, the run settles to cancelled, and
-    //      any DOM mutation already in flight on the op cannot be undone
-    //      from here anyway.
+    // Preserve the actual result of an in-flight operation so its readback and
+    // undo evidence survive cancellation. The checkpoints stop undispatched work.
     const cancelBaselineSequence = readWriteCancellationSequence();
     const cancelledSkipResult = {
       ok: false,
@@ -477,58 +472,34 @@
         changedDocument: false
       }
     };
-    const cancelledInFlightResult = {
-      ...cancelledSkipResult,
-      reason: 'The Codex run was cancelled while an Overleaf write operation was already in flight. The editor may have changed; review the current file before starting a new run.',
-      failure: {
-        ...cancelledSkipResult.failure,
-        severity: 'warning',
-        userMessage: 'The Codex run was cancelled during an in-flight write. The editor may already contain part of that write.',
-        nextAction: 'Review the current Overleaf file before starting a new run.',
-        changedDocument: true
+    const createCandidates = operations.map(normalizeOperationPaths).filter(operation => operation.type === 'create'
+      && operations.filter(other => [other.path, other.to].includes(operation.path)).length === 1);
+    const createBatch = createCandidates.length && typeof deps.beginTextCreateBatch === 'function'
+      ? await deps.beginTextCreateBatch(createCandidates, { isCurrent: () =>
+        treeOperations.getProjectId?.() === runProjectId && readWriteCancellationSequence() === cancelBaselineSequence }) : null;
+    const deferredCreates = [];
+    const reopenQueue = [];
+    const deadlineFailure = () => Number.isFinite(options.deadlineAt) && now() >= options.deadlineAt
+      ? { ok: false, code: 'writeback_deadline_exceeded', changedDocument: false,
+        reason: 'The undo time budget expired before this operation could start.' } : null;
+    const editOptions = () => ({ baseFileLookup, runProjectId,
+      recheckWriteProject: writeGuardSurface ? () => {
+        const expired = deadlineFailure();
+        return expired ? { applied: [], skipped: [{ operation: {}, result: expired }] }
+          : writeGuardSurface.runWriteGuard({ runProjectId });
+      } : null,
+      trackReviewingChanges: options.trackReviewingChanges === true, noTraceUndo: options.noTraceUndo === true });
+    const record = (operation, result) => {
+      if (result.trackedChangeCapture) trackedChangeCaptures.push(result.trackedChangeCapture);
+      if (operation.type === 'edit' && result.ok && Array.isArray(result.trackedChanges)) {
+        trackedChanges.push(...result.trackedChanges);
       }
+      (result.ok ? applied : skipped).push({ operation, result });
+      options.onOperationResult?.({ operation, result });
     };
-    // 50ms-poller racer using recursive setTimeout. setInterval is NOT
-    // exposed in the test VM context that hosts pageBridge (only setTimeout /
-    // clearTimeout are wired), so this implementation must avoid it. Each
-    // tick re-schedules itself only while the racer has not resolved;
-    // dispose() flips a flag so any tick that fires after dispose is a no-op.
-    // Resolves the first time the cancellation sequence bumps past baseline.
-    function createCancellationRacer() {
-      let resolved = false;
-      let resolveFn;
-      const promise = new Promise(resolve => { resolveFn = resolve; });
-      let timer = null;
-      function tick() {
-        if (resolved) return;
-        if (readWriteCancellationSequence() !== cancelBaselineSequence) {
-          resolved = true;
-          resolveFn();
-          return;
-        }
-        timer = window.setTimeout(tick, 50);
-      }
-      timer = window.setTimeout(tick, 50);
-      return {
-        promise,
-        dispose() {
-          resolved = true;
-          if (timer) window.clearTimeout(timer);
-        }
-      };
-    }
-    const CANCELLED_RACE_SENTINEL = Symbol('writebackRouter.cancelled');
-    async function raceOpAgainstCancellation(opPromise) {
-      // Once an editor operation starts, preserve its actual result and undo
-      // metadata. The loop's pre-operation cancellation check stops the tail.
-      return await opPromise;
-    }
 
     for (const rawOperation of operations) {
-      // Cross-world cancel check. Cheap (synchronous read of a counter),
-      // runs before the writeGuard re-check so a click-cancel that arrived
-      // during the previous op's await microtasks short-circuits before we
-      // burn time on guard / open-file work for the next op.
+      // Stop undispatched work when cancellation arrives during an awaited operation.
       if (readWriteCancellationSequence() !== cancelBaselineSequence) {
         skipped.push({ operation: normalizeOperationPaths(rawOperation), result: cancelledSkipResult });
         const remainingForCancel = operations.slice(operations.indexOf(rawOperation) + 1);
@@ -537,16 +508,11 @@
         }
         break;
       }
-      // Per-op re-check: if a runProjectId was supplied and the page-side
-      // guard is available, verify the editor still shows the same project
-      // before committing the next write. Mismatch → push aborted_project_changed
-      // for THIS op and every remaining op in the queue, then return.
+      // Re-check project ownership before this operation and preserve every skipped tail entry.
       if (runProjectId && writeGuardSurface) {
         const guardBlock = await writeGuardSurface.runWriteGuard({ runProjectId });
         if (guardBlock) {
-          // First push the guard's structured skip for the current op so the
-          // caller can attribute the abort to a real operation path, then
-          // pad the remaining ops with the same failure shape.
+          // Keep the current path and the remaining operations attributable.
           const guardFailure = guardBlock.skipped[0].result;
           skipped.push({ operation: normalizeOperationPaths(rawOperation), result: guardFailure });
           const remaining = operations.slice(operations.indexOf(rawOperation) + 1);
@@ -557,23 +523,24 @@
         }
       }
       const operation = normalizeOperationPaths(rawOperation);
-      const pathSafety = validateOperationProjectPaths(operation);
+      const pathSafety = deadlineFailure() || validateOperationProjectPaths(operation);
       if (!pathSafety.ok) {
         skipped.push({ operation, result: pathSafety });
         continue;
       }
-      let raceResult;
+      let result;
       if (operation.type === 'edit') {
-        raceResult = await raceOpAgainstCancellation(applyEditOperation(operation, {
-          baseFileLookup, runProjectId,
-          recheckWriteProject: writeGuardSurface ? () => writeGuardSurface.runWriteGuard({ runProjectId }) : null,
-          trackReviewingChanges: options.trackReviewingChanges === true,
-          noTraceUndo: options.noTraceUndo === true
-        }));
+        result = await applyEditOperation(operation, editOptions());
+        if (isUntouchedOpenFailure(result)) {
+          reopenQueue.push({ operation, result });
+          continue;
+        }
       } else if (['binary-create', 'overwrite-binary'].includes(operation.type)) {
-        raceResult = await raceOpAgainstCancellation(applyBinaryAssetOperation(operation, { baseFileLookup, baseBinaryFileLookup }));
+        result = await applyBinaryAssetOperation(operation, { baseFileLookup, baseBinaryFileLookup });
       } else if (['create', 'rename', 'move', 'delete'].includes(operation.type)) {
-        raceResult = await raceOpAgainstCancellation(applyFileTreeOperation(operation, { baseFileLookup }));
+        result = await applyFileTreeOperation(operation, { baseFileLookup, runProjectId, deadlineAt: options.deadlineAt,
+          createBatch: createBatch?.targets.has(operation.path) ? createBatch : null,
+          retryCreates: options.retryCreates === true });
       } else {
         skipped.push({
           operation,
@@ -584,27 +551,37 @@
         });
         continue;
       }
-      // Cancellation race winner: skip current op + the rest of the queue.
-      // The op promise above keeps running in background; its eventual
-      // result is discarded. The user perceives instant cancel because we
-      // settle the loop here instead of waiting for the op to finish.
-      if (raceResult === CANCELLED_RACE_SENTINEL) {
-        skipped.push({ operation, result: cancelledInFlightResult });
-        const remainingAfterCancel = operations.slice(operations.indexOf(rawOperation) + 1);
-        for (const tailOperation of remainingAfterCancel) {
-          skipped.push({ operation: normalizeOperationPaths(tailOperation), result: cancelledSkipResult });
-        }
-        break;
-      }
-      const result = raceResult;
-      if (result.trackedChangeCapture) trackedChangeCaptures.push(result.trackedChangeCapture);
-      if (operation.type === 'edit' && result.ok && Array.isArray(result.trackedChanges)) {
-        trackedChanges.push(...result.trackedChanges);
+      if (operation.type === 'create' && createBatch?.pending.has(operation.path)
+        && !createBatch.blocked.has(operation.path)) {
+        deferredCreates.push({ operation, result });
+        continue;
       }
-      (result.ok ? applied : skipped).push({ operation, result });
+      record(operation, result);
     }
 
-    if (applied.length > 0) {
+    // A file that could not be opened mid-batch usually opens once the
+    // previous document has settled: give untouched open failures one pass.
+    if (reopenQueue.length && readWriteCancellationSequence() === cancelBaselineSequence
+      && !skipped.some(entry => entry.result?.code === 'aborted_project_changed')) {
+      await delay(deps.reopenRetryDelayMs ?? 1200);
+    }
+    for (const entry of reopenQueue) {
+      const blocked = readWriteCancellationSequence() !== cancelBaselineSequence
+        || skipped.some(item => item.result?.code === 'aborted_project_changed')
+        || Boolean(runProjectId && writeGuardSurface && await writeGuardSurface.runWriteGuard({ runProjectId }));
+      const result = blocked ? entry.result : await applyEditOperation(entry.operation, editOptions());
+      record(entry.operation, result);
+    }
+
+    if (deferredCreates.length) {
+      const confirmed = await deps.finishTextCreateBatch(createBatch, deferredCreates, applied);
+      for (const entry of confirmed) {
+        (entry.result.ok ? applied : skipped).push(entry);
+        if (entry.result.ok) recordFileTreeOperationSuccess(entry.operation, baseFileLookup);
+        options.onOperationResult?.(entry);
+      }
+    }
+    if (applied.some(entry => entry.result?.changedDocument !== false)) {
       compileBridge.markSourceEdited();
     }
 
@@ -617,29 +594,10 @@
     };
   }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+  function isUntouchedOpenFailure(result) {
+    return result?.ok === false && result.failure?.code === 'target_file_open_failed'
+      && result.failure.changedDocument === false;
+  }
 
   async function applyEditOperation(operation, options = {}) {
     const currentPath = getActiveFilePath();
@@ -778,12 +736,23 @@
       return result;
     }
 
-    const verified = await verifyActiveEditorText(nextContent, operation.path);
+    const verified = await verifyActiveEditorText(nextContent, operation.path, deps.writeVerifyWaitMs ?? 2500, current);
     if (!verified.ok) {
       const decorated = attachWritebackDebug(verified, 'write_verification', operation, options.baseFileLookup, readActiveEditorText(), {
         initialActivePath: currentPath,
         editorReadyDebug: editorReady.debug || null
       });
+      const evidence = { originalCode: verified.code || '', writeMethod: result.method || '', writeStarted: true,
+        ...verified.evidence };
+      if (verified.evidence?.observedIsBefore && verified.evidence.activeMatchesTarget) {
+        // The editor still holds exactly the pre-write text: the write never landed, so a retry is safe.
+        decorated.failure = buildPageFailure('write_operation_failed', {
+          file: operation?.path || '', operationType: operation?.type || 'edit', changedDocument: false,
+          userMessage: `Overleaf did not accept the edit to ${operation?.path || 'the target file'}; the document was left unchanged.`,
+          technicalMessage: verified.reason || '', evidence
+        });
+        return decorated;
+      }
       // §9.3 write_observed_mismatch: the write call landed but the readback
       // does not match. changedDocument:true — the editor state moved, just
       // not as Codex expected.
@@ -793,12 +762,7 @@
         changedDocument: true,
         userMessage: `${operation?.path || 'The target file'} did not read back the content Codex wrote; the document state may differ from what was approved.`,
         technicalMessage: verified.reason || '',
-        evidence: {
-          originalCode: verified.code || '',
-          expectedLength: verified.expectedLength,
-          actualLength: verified.actualLength,
-          writeStarted: true
-        }
+        evidence
       });
       return decorated;
     }
@@ -808,12 +772,12 @@
       // Overleaf renders review markers asynchronously after the editor text
       // has already changed. A single 120 ms snapshot intermittently missed
       // those markers, leaving a Reviewing write with Undo but no Accept.
-      // Poll both paths: normal Reviewing writes get a shorter capture window,
-      // while Accept replay keeps the longer safety window used to prove that
-      // it did not create fresh tracked changes.
+      // Complete normal Track attribution while this file is still active.
+      // Slow batches are covered by request receipts; Accept replay retains
+      // its independent safety window proving that no new tracking was added.
       const trackedDiff = trackReviewingChanges
         ? await captureTrackedWrite({ trackedBefore, captureBaseline, operation, beforeContent: current,
-          postContent: nextContent, runProjectId: options.runProjectId })
+          postContent: nextContent, runProjectId: options.runProjectId, waitMs: deps.trackCaptureWaitMs ?? 35000 })
         : await waitForTrackedChangeDiff(trackedBefore, operationPaths, {
           waitMs: 3600, intervalMs: 180, stopOnFirst: true
         });
@@ -860,7 +824,7 @@
   }
 
 
-  async function verifyActiveEditorText(expected, filePath, waitMs = 1000) {
+  async function verifyActiveEditorText(expected, filePath, waitMs = 1000, before) {
     const deadline = Date.now() + waitMs;
     let actual = readActiveEditorText();
     while (actual !== expected && Date.now() < deadline) {
@@ -877,10 +841,37 @@
       code: 'write_verification_failed',
       reason: `${filePath || '当前文件'} 写入后读回内容和 Codex 预期不一致，已停止把这次操作标记为成功。请刷新 Overleaf 后重试。`,
       expectedLength: String(expected || '').length,
-      actualLength: String(actual || '').length
+      actualLength: String(actual || '').length,
+      evidence: describeReadbackMismatch(expected, actual, before, filePath)
     };
   }
 
+  // Content-free mismatch evidence: offsets, lengths and short hashes only.
+  function describeReadbackMismatch(expected, actual, before, filePath) {
+    const left = String(expected ?? ''), right = String(actual ?? '');
+    let firstDiff = 0;
+    while (firstDiff < left.length && left[firstDiff] === right[firstDiff]) firstDiff += 1;
+    let tail = 0;
+    while (tail < left.length - firstDiff && tail < right.length - firstDiff
+      && left[left.length - 1 - tail] === right[right.length - 1 - tail]) tail += 1;
+    const activePath = getActiveFilePath() || '';
+    return { expectedLength: left.length, actualLength: right.length, firstDiffOffset: firstDiff,
+      expectedDiffLength: left.length - firstDiff - tail, actualDiffLength: right.length - firstDiff - tail,
+      expectedHash: shortHash(left), actualHash: shortHash(right),
+      beforeHash: typeof before === 'string' ? shortHash(before) : '',
+      observedIsBefore: typeof before === 'string' && right === before,
+      activePath, activeMatchesTarget: !filePath || activePath === filePath };
+  }
+
+  function shortHash(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+      hash ^= value.charCodeAt(index);
+      hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, '0');
+  }
+
   async function ensureEditorReadyForOperation(operation, baseFileLookup, initialActivePath) {
     if (!operation?.path) {
       return {
@@ -1376,8 +1367,20 @@
   }
 
   async function applyFileTreeOperation(operation, options = {}) {
+    if (operation.type === 'delete' && operation.undoCreatedFile) {
+      return applyCreatedFileUndo(operation, options);
+    }
     const initialProjectId = treeOperations.getProjectId?.();
     const initialCancellationSequence = readWriteCancellationSequence();
+    if (operation.type === 'create' && options.createBatch && typeof deps.createTextFile === 'function') {
+      if (options.baseFileLookup?.has(operation.path) && options.retryCreates !== true) {
+        return checkFileTreeOperationFreshness(operation, options.baseFileLookup);
+      }
+      return deps.createTextFile(operation, { batch: options.createBatch,
+        allowExistingMatches: options.retryCreates === true,
+        isCurrent: () => treeOperations.getProjectId?.() === initialProjectId
+          && readWriteCancellationSequence() === initialCancellationSequence });
+    }
     const freshness = await checkFileTreeOperationFreshness(operation, options.baseFileLookup);
     if (!freshness.ok) {
       return freshness;
@@ -1436,7 +1439,7 @@
         return { ...fileTreeVerificationFailed(operation, 'Server receipt is missing or stale.'), changedDocument: true };
       }
       recordFileTreeOperationSuccess(operation, options.baseFileLookup);
-      return { ok: true, method: created.method, verified: true };
+      return { ...created, ok: true, method: created.method, verified: true };
     }
     return {
       ok: false,
@@ -1445,6 +1448,43 @@
     };
   }
 
+  async function applyCreatedFileUndo(operation, options = {}) {
+    const projectId = treeOperations.getProjectId?.();
+    const cancellation = readWriteCancellationSequence();
+    const proof = operation.undoCreatedFile;
+    const expected = options.baseFileLookup?.get(operation.path);
+    const text = proof?.v === 1 && proof.kind === 'text' && typeof expected === 'string';
+    const binary = proof?.v === 1 && proof.kind === 'binary' && /^[a-f0-9]{64}$/i.test(proof.sha256 || '');
+    const isCurrent = () => Boolean(projectId) && projectId === options.runProjectId
+      && treeOperations.getProjectId?.() === projectId && readWriteCancellationSequence() === cancellation;
+    if (!isCurrent() || (!text && !binary) || typeof deps.deleteTextFile !== 'function') {
+      return { ok: false, code: 'undo_operation_failed', changedDocument: false,
+        reason: 'Verified created-file deletion is unavailable for this run.' };
+    }
+    if (text && projectPathExists(operation.path)) {
+      const current = await readCurrentTextFileForFreshness(operation.path);
+      if (!current.ok || current.text !== expected || !isCurrent()) {
+        return { ok: false, code: 'undo_operation_failed', changedDocument: false,
+          reason: 'The created file changed after this run and was left untouched.' };
+      }
+    }
+    const result = await deps.deleteTextFile(operation, {
+      isCurrent, undoCreatedFile: true, deadlineAt: options.deadlineAt,
+      expectedContent: text ? expected : undefined,
+      prepareTextPreimage: text ? () => readCurrentTextFileForFreshness(operation.path) : undefined,
+      expectedSha256: binary ? proof.sha256.toLowerCase() : undefined,
+      canDelete: () => isCurrent() && (binary || (treeOperations.getActiveFilePath?.() === operation.path
+        && readActiveEditorText() === expected))
+    });
+    if (!result.ok) return result;
+    if (!isCurrent() || result.verified !== true || result.verification !== 'overleaf-zip') {
+      return { ok: false, code: 'undo_operation_failed', changedDocument: result.changedDocument !== false,
+        reason: 'The created file has no current server deletion receipt.' };
+    }
+    recordFileTreeOperationSuccess(operation, options.baseFileLookup);
+    return result;
+  }
+
   async function verifyFileTreeOperation(operation) {
     await delay(120);
     const sourcePath = operation.path;
@@ -1890,7 +1930,7 @@
       captureTrackedWrite, reconcileTrackedChangeCapture,
       waitForTrackedChangeDiff
     } = trackedChangesLifecycleModule.create({
-      window,
+      window, confirmReviewWriteback: deps.confirmReviewWriteback,
       checkWritebackRunProjectId,
       buildNoTraceUndoBlockedResult,
       buildReviewingRequiredBlockedResult,