codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/shared/writebackSettlement.js

@@ -4,21 +4,24 @@
       require('./failureReasons'),
       require('./settlementFacts'),
       require('./writebackEvidenceProjection'),
-      require('./writebackOperationEvidence')
+      require('./writebackOperationEvidence'),
+      require('./undoOperations')
     );
   } else {
     root.CodexOverleafModuleRegistry.define('WritebackSettlement', [
       'FailureReasons',
       'SettlementFacts',
       'WritebackEvidenceProjection',
-      'WritebackOperationEvidence'
+      'WritebackOperationEvidence',
+      'UndoOperations'
     ], factory);
   }
 })(typeof window !== 'undefined' ? window : globalThis, function writebackSettlementFactory(
   DefaultFailureReasons,
   SettlementFacts,
   EvidenceProjection,
-  OperationEvidence
+  OperationEvidence,
+  UndoOperations
 ) {
   'use strict';
 
@@ -190,8 +193,29 @@
       : (state === 'not_started' || !state ? 'not-attempted' : 'unknown');
   }
 
+  // A Retry sync re-settles only the files it replays: merge them over the run's original facts.
+  function mergeRetrySettlement(previous, retryFacts, failureReasons = DefaultFailureReasons) {
+    if (!retryFacts || typeof retryFacts !== 'object') return previous || null;
+    if (!previous || typeof previous !== 'object') return retryFacts;
+    const retried = new Map((retryFacts.fileSettlements || []).map(file => [file.path, file]));
+    const fileSettlements = [...(previous.fileSettlements || []).map(file => retried.get(file.path) || file),
+      ...[...retried.values()].filter(file => !(previous.fileSettlements || []).some(old => old.path === file.path))];
+    const stillFailing = new Set(fileSettlements.flatMap(file => file.failureCodes || []));
+    const resolved = new Set([...retried.values()].filter(file => file.applied === 'complete').map(file => file.path));
+    const failures = [...(previous.failures || []).filter(failure => !resolved.has(failure.file)
+      && (failure.file || stillFailing.has(failure.code))), ...(retryFacts.failures || [])];
+    const all = (key, value) => fileSettlements.every(file => file[key] === value);
+    const any = (key, value) => fileSettlements.some(file => file[key] === value);
+    return compactSettlementFacts({ ...previous, fileSettlements, failures, documentEffect: retryFacts.documentEffect === 'changed' ? 'changed' : previous.documentEffect,
+      evidence: { ...previous.evidence, saved: retryFacts.evidence?.saved || previous.evidence?.saved,
+        applied: all('applied', 'complete') ? 'complete' : any('applied', 'complete') ? 'partial' : previous.evidence?.applied,
+        readBack: all('readBack', 'exact') ? 'exact' : any('readBack', 'mismatch') ? 'mismatch' : 'partial',
+        settled: deriveSettledEvidence(selectPrimaryFailure(failures, failureReasons), fileSettlements) },
+      capturedAt: retryFacts.capturedAt || previous.capturedAt });
+  }
+
   function deriveSettledEvidence(primaryFailure, fileSettlements = []) {
-    if (primaryFailure?.terminalState === 'needs_review'
+    if (primaryFailure?.terminalState === 'needs_review' || DefaultFailureReasons.isUnconfirmedWriteFailure?.(primaryFailure)
       || fileSettlements.some(file => file.readBack === 'mismatch')) {
       return 'needs-review';
     }
@@ -270,17 +294,13 @@
     }
     const successful = isSuccessfulTrackedChangeSettlement(input.result);
     const reviewCodes = kind === 'accept' ? ACCEPT_NEEDS_REVIEW_CODES : REJECT_NEEDS_REVIEW_CODES;
-    // Reject/Undo is an all-target recovery transaction. A successful entry
-    // only proves that one tracked target was restored; any failed/skipped
-    // sibling can still leave this run's content in another file. Keep that
-    // recovery actionable instead of collapsing a partial multi-file reject
-    // into the terminal `rejected` state. Accept retains its established
-    // best-effort terminal policy.
-    const incompleteReject = kind === 'reject'
-      && collectRunResultSkipped(input.result).length > 0;
-    const needsReview = incompleteReject || (!successful && failures.some(failure =>
+    // Both actions cover every targeted file. Partial success must retain
+    // the original recovery material for unresolved siblings.
+    const incomplete = collectRunResultSkipped(input.result).length > 0
+      || input.result?.ok === false;
+    const needsReview = incomplete || !successful || failures.some(failure =>
       failure.terminalState === 'needs_review' || reviewCodes.has(failure.code)
-    ));
+    );
     const status = needsReview ? 'needs_review' : kind === 'accept' ? 'accepted' : 'rejected';
     return {
       decision: status,
@@ -319,7 +339,8 @@
   }
 
   function settleLegacyUndo(input = {}) {
-    const status = input.status === 'applied' ? 'applied' : 'partial';
+    const status = input.status === 'applied'
+      && isUndoResultEffectivelyApplied(input.run, input.result, input.run?.undoOperations) ? 'applied' : 'partial';
     const recovery = preserveRecovery();
     return {
       statePatch: { undoStatus: status },
@@ -368,6 +389,7 @@
         next[field] = cloneValue(disposition.value);
       }
     }
+    if (next.undoStatus === 'applied' || next.trackedChangeStatus === 'rejected') Object.assign(next, { saveCheck: null, retryWriteback: null });
     if (settlementResult.facts) {
       const existingSettlement = next.settlement && typeof next.settlement === 'object'
         ? next.settlement
@@ -423,7 +445,8 @@
   }
 
   function isUndoResultEffectivelyApplied(run, result, undoOperations = []) {
-    if (!result?.skipped?.length) return true;
+    if (result?.saveVerification?.ok === false || result?.receiptUnconfirmed === true) return false;
+    if (!result?.skipped?.length) return result?.ok === true;
     const expectedByPath = new Map((run?.undoExpectedFiles || [])
       .filter(file => file?.path && typeof file.content === 'string')
       .map(file => [normalizeSettlementPath(file.path), file.content])
@@ -449,10 +472,12 @@
     if (entry?.operation?.type === 'edit' && operationPath === normalizedPath) {
       return inner.verifiedContent === expectedContent;
     }
-
     const trackedPath = normalizeSettlementPath(entry?.trackedChange?.path);
     if (trackedPath !== normalizedPath) return false;
     const key = String(entry?.trackedChange?.key || '');
+    if (['overleaf-review-reject', 'overleaf-review-reject-sweep'].includes(inner.method))
+      return /^(?:id:|pos:|sig:)/.test(key) && inner.verified === true
+        && inner.verifiedContent === expectedContent;
     if (key === `editor-undo:${normalizedPath}`) {
       return inner.method === 'overleaf-editor-undo'
         && inner.verified === true
@@ -474,14 +499,12 @@
     }
     return false;
   }
-
   function normalizeSettlementPath(value) {
     return String(value || '')
       .replace(/\\/g, '/')
       .replace(/\/+/g, '/')
       .replace(/^\/+|\/+$/g, '');
   }
-
   function attachAcceptNotVerifiedFailure(run, result, options = {}) {
     if (!result || typeof result !== 'object' || result.ok === false) return result;
     if (Array.isArray(result.skipped) && result.skipped.length > 0) return result;
@@ -562,8 +585,9 @@
       const inner = entry?.result || entry;
       if (!inner || inner.ok === true) continue;
       const operation = entry?.operation || (entry?.trackedChange ? { path: entry.trackedChange.path } : undefined);
-      failures.push(failureReasons?.normalizeFailureReason instanceof Function
-        ? failureReasons.normalizeFailureReason(inner, operation)
+      const normalize = failureReasons?.normalizeWritebackFailure || failureReasons?.normalizeFailureReason;
+      failures.push(normalize instanceof Function
+        ? normalize(inner, operation)
         : normalizeFailure(inner, operation));
     }
     return failures.filter(Boolean);
@@ -612,9 +636,22 @@
 
   function attachVerifiedContentToOperation(operation, result) {
     if (!operation || typeof operation !== 'object') return operation;
-    return operation.type === 'edit' && typeof result?.verifiedContent === 'string'
-      ? { ...operation, verifiedContent: result.verifiedContent }
-      : operation;
+    const createdDirectories = (Array.isArray(result?.createdDirectories) ? result.createdDirectories
+      : Array.isArray(result?.moveProof?.createdDirectories) ? result.moveProof.createdDirectories : [])
+      .filter(proof => proof?.v === 1 && typeof proof.projectId === 'string' && proof.projectId
+        && typeof proof.path === 'string' && proof.path && !proof.path.split('/').some(part => !part || part === '.' || part === '..')
+        && typeof proof.nativeFolderId === 'string')
+      .map(proof => ({ v: 1, projectId: proof.projectId, path: proof.path, nativeFolderId: proof.nativeFolderId,
+        ownershipConfirmed: false, observedAfterCreate: proof.observedAfterCreate === true }));
+    const rawMove = result?.moveProof;
+    const moveProof = rawMove?.v === 1 && ['text', 'binary'].includes(rawMove.kind) && /^[a-f0-9]{64}$/i.test(rawMove.sha256 || '')
+      && typeof rawMove.sourceEntityId === 'string' && rawMove.sourceEntityId
+      && typeof rawMove.targetEntityId === 'string' && rawMove.targetEntityId
+      ? { v: 1, kind: rawMove.kind, sha256: rawMove.sha256.toLowerCase(), sourceEntityId: rawMove.sourceEntityId,
+        targetEntityId: rawMove.targetEntityId, ...(['doc', 'file'].includes(rawMove.entityType) ? { entityType: rawMove.entityType } : {}), ...(createdDirectories.length ? { createdDirectories } : {}) } : null;
+    if (!(operation.type === 'edit' && typeof result?.verifiedContent === 'string') && !createdDirectories.length && !moveProof) return operation;
+    return { ...operation, ...(operation.type === 'edit' && typeof result?.verifiedContent === 'string' ? { verifiedContent: result.verifiedContent } : {}),
+      ...(createdDirectories.length ? { createdDirectories } : {}), ...(moveProof ? { moveProof } : {}) };
   }
 
   function selectExpectedFilesForTrackedUndo(
@@ -623,26 +660,7 @@
     trackedChanges = [],
     previousExpectedFiles = []
   ) {
-    const paths = new Set();
-    for (const change of trackedChanges || []) {
-      if (change?.path) paths.add(change.path);
-    }
-    for (const operation of operations || []) {
-      if (operation?.path) paths.add(operation.path);
-      if (operation?.to) paths.add(operation.to);
-    }
-    const expectedByPath = new Map();
-    for (const file of previousExpectedFiles || []) {
-      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
-        expectedByPath.set(file.path, { path: file.path, content: file.content });
-      }
-    }
-    for (const file of project?.files || []) {
-      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
-        expectedByPath.set(file.path, { path: file.path, content: file.content });
-      }
-    }
-    return Array.from(expectedByPath.values());
+    return UndoOperations.selectExpectedFilesForTrackedUndo(project, operations, trackedChanges, previousExpectedFiles);
   }
 
   function acceptDiagnosticStatus(step, info) {
@@ -656,10 +674,9 @@
     return 'info';
   }
 
-  function selectPrimaryFailure(failures, failureReasons) {
-    return failureReasons?.selectPrimaryFailure instanceof Function
-      ? failureReasons.selectPrimaryFailure(failures)
-      : failures[0] || null;
+  function selectPrimaryFailure(failures, failureReasons = DefaultFailureReasons) {
+    const select = failureReasons?.selectPrimaryWritebackFailure || failureReasons?.selectPrimaryFailure;
+    return select instanceof Function ? select(failures) : failures[0] || null;
   }
 
   function appendSyntheticFailure(result, failure, path, code, type) {
@@ -711,6 +728,7 @@
     SETTLEMENT_FACTS_MAX_BYTES,
     aggregateFileSettlements,
     applySettlementTransition,
+    mergeRetrySettlement,
     acceptDiagnosticStatus,
     attachVerifiedContentToOperation,
     attachAcceptNotVerifiedFailure,
@@ -730,6 +748,7 @@
     normalizeOperationEvidence,
     normalizeSaveEvidence,
     projectRunSettlement,
+    selectPrimaryFailure,
     selectExpectedFilesForTrackedUndo,
     settle,
     settleLegacyUndo,

package/extension/src/shared/writingStyle.js

@@ -0,0 +1,33 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafWritingStyle = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+  const REFERENCE_LIMITS = Object.freeze({
+    maxSources: 3,
+    maxPdfBytes: 20 * 1024 * 1024,
+    maxPdfTotalBytes: 40 * 1024 * 1024,
+    maxProjectBytes: 4 * 1024 * 1024,
+    // Two maximum-sized PDFs plus one project remain below Chrome's
+    // 64 MiB message ceiling after Base64 encoding and request metadata.
+    maxAttachmentTotalBytes: 44 * 1024 * 1024,
+    pdfExtractionTimeoutMs: 90000
+  });
+  function normalizeSnapshot(value) {
+    if (value == null || value.enabled === false) return null;
+    if (typeof value !== 'object'
+      || typeof value.accountScopeId !== 'string' || !value.accountScopeId || value.accountScopeId.length > 256
+      || !/^[a-zA-Z0-9_-]{1,80}$/.test(value.projectId || '')
+      || !/^[a-f0-9-]{36}$/i.test(value.version || '')
+      || !/^[a-f0-9]{64}$/i.test(value.bundleHash || '')) {
+      const error = new Error('The selected writing skill is unavailable. Reopen General settings.');
+      error.code = 'writing_style_snapshot_invalid';
+      throw error;
+    }
+    return Object.freeze({ accountScopeId: value.accountScopeId, projectId: value.projectId,
+      version: value.version, bundleHash: value.bundleHash.toLowerCase(),
+      label: String(value.label || 'Academic writing').slice(0, 160) });
+  }
+  return { normalizeSnapshot, REFERENCE_LIMITS };
+});