codex-overleaf-link 2.4.1 → 2.5.0

package/extension/src/shared/writebackIntent.js

@@ -0,0 +1,62 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory(require('./undoOperations'));
+  else root.CodexOverleafModuleRegistry.define('WritebackIntent', ['UndoOperations'], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : window, function (Undo) {
+  'use strict';
+  const MAX_BYTES = 300 * 1024;
+  const types = new Set(['edit', 'create', 'delete', 'rename', 'move', 'binary-create', 'overwrite-binary']);
+  const path = value => typeof value === 'string' && value && !value.startsWith('/')
+    && !/^[A-Za-z]:/.test(value) && !value.replace(/\\/g, '/').split('/').some(part => !part || part === '.' || part === '..');
+  function normalize(value) {
+    if (!value || typeof value !== 'object' || !value.id || !value.projectId || !value.accountScopeId
+      || !value.sessionId || !value.runId || !Array.isArray(value.operations) || value.operations.length > 100) return null;
+    const operations = [];
+    for (const input of value.operations) {
+      if (!types.has(input?.type) || !path(input.path) || (input.to && !path(input.to))) return null;
+      const op = { type: input.type, path: input.path };
+      for (const key of ['to', 'content', 'replaceAll', 'find', 'replace', 'sha256', 'mimeType']) {
+        if (typeof input[key] === 'string') op[key] = input[key];
+      }
+      if (Number.isSafeInteger(input.size)) op.size = input.size;
+      if (Array.isArray(input.patches)) {
+        if (input.patches.length > 1000) return null;
+        op.patches = input.patches.map(p => ({ from: p.from, to: p.to, expected: String(p.expected ?? ''), insert: String(p.insert ?? '') }));
+        if (op.patches.some(p => !Number.isSafeInteger(p.from) || !Number.isSafeInteger(p.to) || p.from < 0 || p.to < p.from)) return null;
+      }
+      operations.push(op);
+    }
+    const paths = new Set(operations.flatMap(op => [op.path, op.to].filter(Boolean)));
+    const baseFiles = (Array.isArray(value.baseFiles) ? value.baseFiles : [])
+      .filter(file => paths.has(file?.path) && typeof file.content === 'string')
+      .map(file => ({ path: file.path, content: file.content }));
+    const result = { v: 1, id: String(value.id).slice(0, 160), projectId: String(value.projectId).slice(0, 160),
+      accountScopeId: String(value.accountScopeId).slice(0, 160), sessionId: String(value.sessionId).slice(0, 160),
+      runId: String(value.runId).slice(0, 160), createdAt: String(value.createdAt || '').slice(0, 64),
+      requireReviewing: value.requireReviewing === true, operations, baseFiles };
+    if (typeof value.requestId === 'string') result.requestId = value.requestId.slice(0, 160);
+    const size = typeof TextEncoder === 'function' ? new TextEncoder().encode(JSON.stringify(result)).length : JSON.stringify(result).length * 2;
+    return size <= MAX_BYTES ? result : null;
+  }
+  function expectedFiles(value) {
+    return Undo.buildExpectedFilesAfterOperations({ files: value.baseFiles }, value.operations.filter(op => !op.type.includes('binary')));
+  }
+  function normalizeSaveCheck(value) {
+    if (!value?.projectId || !value.accountScopeId || !value.sessionId || !value.runId
+      || !Array.isArray(value.files) || value.files.length > 1000) return null;
+    const files = [];
+    for (const file of value.files) {
+      if (!path(file?.path)) return null;
+      if (file.absent === true) files.push({ path: file.path, absent: true });
+      else if (/^[a-f0-9]{64}$/i.test(file.sha256 || '')) {
+        if (file.kind !== undefined && !['text', 'binary'].includes(file.kind)) return null;
+        files.push({ path: file.path, sha256: file.sha256.toLowerCase(),
+          ...(file.kind ? { kind: file.kind } : {}) });
+      }
+      else return null;
+    }
+    return files.length ? { v: 1, projectId: String(value.projectId).slice(0, 160),
+      accountScopeId: String(value.accountScopeId).slice(0, 160), sessionId: String(value.sessionId).slice(0, 160),
+      runId: String(value.runId).slice(0, 160), createdAt: String(value.createdAt || '').slice(0, 64), files } : null;
+  }
+  return { normalize, normalizeSaveCheck, expectedFiles, MAX_BYTES };
+});

package/extension/src/shared/writebackSettlement.js

@@ -190,6 +190,27 @@
       : (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'
       || fileSettlements.some(file => file.readBack === 'mismatch')) {
@@ -270,17 +291,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,
@@ -368,6 +385,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
@@ -711,6 +729,7 @@
     SETTLEMENT_FACTS_MAX_BYTES,
     aggregateFileSettlements,
     applySettlementTransition,
+    mergeRetrySettlement,
     acceptDiagnosticStatus,
     attachVerifiedContentToOperation,
     attachAcceptNotVerifiedFailure,

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 };
+});