codex-overleaf-link 2.2.0 → 2.3.0

package/extension/src/shared/scopedPersistenceTransaction.js

@@ -0,0 +1,238 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(
+      require('./scopedPersistenceQueuePolicy'),
+      require('./scopedPersistenceBrowserAdapter')
+    );
+  } else {
+    root.CodexOverleafModuleRegistry.define('ScopedPersistenceTransaction', [
+      'ScopedPersistenceQueuePolicy',
+      'ScopedPersistenceBrowserAdapter'
+    ], factory);
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (QueuePolicy, BrowserAdapter) {
+  'use strict';
+
+  var applyQueueMutations = QueuePolicy.applyQueueMutations;
+  var cleanPart = QueuePolicy.cleanPart;
+  var createQueueClaim = QueuePolicy.createQueueClaim;
+  var isClaimCurrent = QueuePolicy.isClaimCurrent;
+  var mergeTombstones = QueuePolicy.mergeTombstones;
+  var normalizeMeta = QueuePolicy.normalizeMeta;
+  var normalizeQueueMutations = QueuePolicy.normalizeQueueMutations;
+  var normalizeRevision = QueuePolicy.normalizeRevision;
+  var createBrowserAdapter = BrowserAdapter.createBrowserAdapter;
+  var normalizeScope = BrowserAdapter.normalizeScope;
+  var scopeKey = BrowserAdapter.scopeKey;
+
+  function sameScope(left, right) {
+    return Boolean(left && right
+      && left.accountScopeId === right.accountScopeId
+      && left.projectId === right.projectId);
+  }
+
+
+  function createCoordinator(options) {
+    options = options || {};
+    var adapter = options.adapter || createBrowserAdapter(options);
+    var writerId = cleanPart(options.writerId) || randomId();
+    var generation = 0;
+    var active = null;
+
+    async function beginHydration(inputScope) {
+      var scope = normalizeScope(inputScope);
+      generation += 1;
+      var tokenGeneration = generation;
+      active = makeToken(scope, tokenGeneration, 0, false, 0);
+      var meta = await strictRead(adapter, scope);
+      var token = makeToken(scope, tokenGeneration, meta.revision, false, meta.queueRevision);
+      if (active && active.generation === tokenGeneration && sameScope(active, token)) active = token;
+      return token;
+    }
+
+    async function captureCommitView(inputScope, captureOptions) {
+      var scope = normalizeScope(inputScope);
+      var detached = Boolean(captureOptions && captureOptions.detached);
+      if (!detached && active && active.projectId === scope.projectId) {
+        scope = normalizeScope({
+          accountScopeId: active.accountScopeId,
+          projectId: scope.projectId
+        });
+      }
+      if (!detached && active && sameScope(active, scope)) {
+        return makeToken(scope, active.generation, active.revision, false, active.queueRevision);
+      }
+      var meta = await strictRead(adapter, scope);
+      return makeToken(scope, detached ? 0 : generation, meta.revision, detached, meta.queueRevision);
+    }
+
+    function isCurrent(token) {
+      return Boolean(token && active && token.detached !== true
+        && token.generation === active.generation && sameScope(token, active));
+    }
+
+    async function commit(token, action, commitOptions) {
+      if (!token || typeof action !== 'function' || !token.projectId) {
+        return { ok: false, reason: 'invalid_commit' };
+      }
+      var scope = normalizeScope(token);
+      if (!token.detached && !isCurrent(token)) return { ok: false, reason: 'stale_view' };
+      return adapter.withLock(scope, async function () {
+        if (!token.detached && !isCurrent(token)) return { ok: false, reason: 'stale_view' };
+        var currentMeta = await strictRead(adapter, scope);
+        if (!token.detached && !isCurrent(token)) return { ok: false, reason: 'stale_view' };
+        var conflict = currentMeta.revision !== normalizeRevision(token.revision);
+        if (conflict && !(commitOptions && commitOptions.rebase === true)) {
+          return {
+            ok: false,
+            reason: 'revision_conflict',
+            expectedRevision: token.revision,
+            actualRevision: currentMeta.revision
+          };
+        }
+        var queueMutations = normalizeQueueMutations(commitOptions);
+        if (queueMutations.length
+          && currentMeta.queueRevision !== normalizeRevision(token.queueRevision)) {
+          if (!token.detached && isCurrent(token)) {
+            active = makeToken(
+              scope,
+              token.generation,
+              currentMeta.revision,
+              false,
+              currentMeta.queueRevision
+            );
+          }
+          return {
+            ok: false,
+            reason: 'queue_revision_conflict',
+            expectedRevision: token.queueRevision,
+            actualRevision: currentMeta.queueRevision,
+            actualStateRevision: currentMeta.revision
+          };
+        }
+        var projected = applyQueueMutations(currentMeta, queueMutations, writerId);
+        if (!projected.ok) return projected;
+        var nextMeta = {
+          ...projected.meta,
+          revision: currentMeta.revision + 1,
+          writerId: writerId,
+          updatedAt: new Date().toISOString(),
+          sessionTombstones: mergeTombstones(
+            projected.meta.sessionTombstones,
+            commitOptions && commitOptions.sessionTombstones,
+            200
+          )
+        };
+        await adapter.write(scope, nextMeta);
+        if (!token.detached && isCurrent(token)) {
+          active = makeToken(
+            scope,
+            token.generation,
+            nextMeta.revision,
+            false,
+            nextMeta.queueRevision
+          );
+        }
+        var value;
+        try {
+          value = await action({
+            scope: scope,
+            baseRevision: currentMeta.revision,
+            conflict: conflict,
+            writerId: writerId,
+            currentMeta: currentMeta,
+            nextMeta: nextMeta
+          });
+        } catch (error) {
+          if (queueMutations.some(function (mutation) {
+            return ['remove', 'release', 'restore'].includes(cleanPart(mutation.type));
+          })) {
+            var recoveredMeta = {
+              ...currentMeta,
+              revision: nextMeta.revision + 1,
+              queueRevision: nextMeta.queueRevision + 1,
+              writerId: writerId,
+              updatedAt: new Date().toISOString()
+            };
+            try {
+              await adapter.write(scope, recoveredMeta);
+              if (!token.detached && isCurrent(token)) {
+                active = makeToken(
+                  scope,
+                  token.generation,
+                  recoveredMeta.revision,
+                  false,
+                  recoveredMeta.queueRevision
+                );
+              }
+            } catch (recoveryError) {
+              if (error && typeof error === 'object') {
+                error.persistenceRecoveryError = recoveryError.message || String(recoveryError);
+              }
+            }
+          }
+          throw error;
+        }
+        return {
+          ok: true,
+          value: value,
+          revision: nextMeta.revision,
+          queueRevision: nextMeta.queueRevision,
+          queueClaims: nextMeta.queueClaims,
+          rebased: conflict,
+          superseded: !token.detached && !isCurrent(token)
+        };
+      });
+    }
+
+    return Object.freeze({
+      beginHydration: beginHydration,
+      captureCommitView: captureCommitView,
+      commit: commit,
+      getActiveView: function () {
+        return active
+          ? makeToken(active, active.generation, active.revision, false, active.queueRevision)
+          : null;
+      },
+      getWriterId: function () { return writerId; },
+      invalidate: function () {
+        generation += 1;
+        active = null;
+      },
+      isCurrent: isCurrent
+    });
+  }
+
+  function makeToken(scope, tokenGeneration, revision, detached, queueRevision) {
+    return Object.freeze({
+      accountScopeId: scope.accountScopeId,
+      projectId: scope.projectId,
+      generation: normalizeRevision(tokenGeneration),
+      revision: normalizeRevision(revision),
+      queueRevision: normalizeRevision(queueRevision),
+      detached: detached === true
+    });
+  }
+
+  async function strictRead(adapter, scope) {
+    return normalizeMeta(await adapter.read(scope));
+  }
+
+  function randomId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+      return crypto.randomUUID();
+    }
+    return 'writer-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
+  }
+
+  return Object.freeze({
+    createBrowserAdapter: createBrowserAdapter,
+    createCoordinator: createCoordinator,
+    createQueueClaim: createQueueClaim,
+    isClaimCurrent: isClaimCurrent,
+    mergeTombstones: mergeTombstones,
+    normalizeScope: normalizeScope,
+    sameScope: sameScope,
+    scopeKey: scopeKey
+  });
+});

package/extension/src/shared/sessionState.js

@@ -1,16 +1,28 @@
 (function initSessionState(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(
+      require('./i18n'),
+      require('./settlementFacts'),
+      require('./runInputQueue'),
+      require('./lineReferences'),
+      require('./pathRedaction')
+    );
   } else {
-    root.CodexOverleafSessionState = factory();
-  }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function sessionStateFactory() {
+    root.CodexOverleafModuleRegistry.define(
+      'SessionState',
+      ['I18n', 'SettlementFacts', 'RunInputQueue', 'LineReferences', 'PathRedaction'],
+      factory
+    );
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function sessionStateFactory(
+  i18n,
+  SettlementFacts,
+  RunInputQueue,
+  LineReferences,
+  PathRedaction
+) {
   'use strict';
 
-  const i18n = (typeof module === 'object' && module.exports)
-    ? require('./i18n')
-    : (typeof globalThis !== 'undefined' ? globalThis : window).CodexOverleafI18n;
-
   const DEFAULT_PANEL_STATE = {
     mode: 'confirm',
     providerId: 'builtin',
@@ -109,9 +121,6 @@
     /\b(?:sk|pk)-[A-Za-z0-9][A-Za-z0-9_-]{7,}\b/g,
     /\b(?:api[_-]?key|token|password|passwd|secret)\b\s*[:=]\s*["']?[^"'\s,;]+["']?/gi
   ];
-  const LineReferences = loadLineReferences();
-  const PathRedaction = loadPathRedaction();
-
   function normalizePanelState(input = {}, options = {}) {
     const state = {
       ...DEFAULT_PANEL_STATE,
@@ -226,7 +235,15 @@
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
-      pendingInputs: normalizePendingInputs(session.pendingInputs, options.restoreRunningRuns === true)
+      pendingInputs: normalizePendingInputs(
+        session.pendingInputs,
+        options.restoreRunningRuns === true,
+        {
+          ...fallbackState,
+          ...session,
+          focusFiles: normalizeFocusFiles(session.focusFiles)
+        }
+      )
     };
   }
 
@@ -626,6 +643,18 @@
       interruptedDraft: run.interruptedDraft ? sanitizeAssistantVisibleValue(run.interruptedDraft) : undefined
     };
 
+    if (run.executionSnapshot && typeof run.executionSnapshot === 'object') {
+      normalized.executionSnapshot = sanitizeAssistantVisibleValue(run.executionSnapshot);
+    }
+    const storedSettlement = run.settlement && typeof run.settlement === 'object'
+      ? run.settlement
+      : run.settlementFacts;
+    if (storedSettlement && typeof storedSettlement === 'object') {
+      normalized.settlement = sanitizeAssistantVisibleValue(storedSettlement);
+    }
+    if (run.changedDocument === true) {
+      normalized.changedDocument = true;
+    }
     applyTrackedChangeStatus(normalized, run.trackedChangeStatus);
 
     return normalized;
@@ -658,7 +687,7 @@
     // the run returns to the legacy-undo world. A terminal status with no refs
     // is kept — step 3 already empties terminal payloads and the label stays
     // meaningful.
-    if (!hasRefs && status !== undefined && !TERMINAL_TRACKED_CHANGE_STATUS.has(status)) {
+    if (!hasRefs && status === 'pending') {
       status = undefined;
     }
 
@@ -1121,10 +1150,18 @@
       .filter(run => Array.isArray(run.undoOperations) && run.undoOperations.length)
       .slice(0, limits.maxUndoRunsPerSession)
       .map(run => run.id));
-    return selectedRuns.map(run => compactRunForStorage(run, limits, undoRunIds.has(run.id)));
+    const settlementFactsByRunId = SettlementFacts.compactSessionSettlementFacts(selectedRuns, {
+      sanitize: sanitizeAssistantVisibleValue
+    });
+    return selectedRuns.map(run => compactRunForStorage(
+      run,
+      limits,
+      undoRunIds.has(run.id),
+      settlementFactsByRunId.get(run.id)
+    ));
   }
 
-  function compactRunForStorage(run, limits, keepUndoPayload) {
+  function compactRunForStorage(run, limits, keepUndoPayload, settlementFacts = null) {
     const undoPayload = compactUndoPayload(run, limits, keepUndoPayload);
     const compact = {
       id: run.id,
@@ -1151,6 +1188,15 @@
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
       queueItemId: normalizeTextField(run.queueItemId, 160)
     };
+    if (run.executionSnapshot && typeof run.executionSnapshot === 'object') {
+      compact.executionSnapshot = sanitizeAssistantVisibleValue(run.executionSnapshot);
+    }
+    if (settlementFacts && typeof settlementFacts === 'object') {
+      compact.settlement = settlementFacts;
+    }
+    if (run.changedDocument === true) {
+      compact.changedDocument = true;
+    }
     if (run.interruptedDraft) {
       compact.interruptedDraft = sanitizeAssistantVisibleValue(run.interruptedDraft);
     }
@@ -1384,11 +1430,9 @@
       }));
   }
 
-  function normalizePendingInputs(value, recoverActive = false) {
-    const Queue = (typeof globalThis !== 'undefined' ? globalThis.CodexOverleafRunInputQueue : null)
-      || (typeof module === 'object' && module.exports ? require('./runInputQueue') : null);
-    if (Queue?.normalizeQueue) {
-      return Queue.normalizeQueue(value, { recoverActive });
+  function normalizePendingInputs(value, recoverActive = false, fallbackInput = {}) {
+    if (RunInputQueue?.normalizeQueue) {
+      return RunInputQueue.normalizeQueue(value, { recoverActive, fallbackInput });
     }
     return [];
   }
@@ -1442,34 +1486,6 @@
     return /(?:file:\/\/\/?|[A-Za-z]:[\\/]|\/(?:Users|home|private|var|tmp)\/|[\\/]\.codex-overleaf[\\/]projects[\\/]|\.codex-overleaf[\\/]projects[\\/])/i.test(String(value || ''));
   }
 
-  function loadLineReferences() {
-    if (typeof globalThis !== 'undefined' && globalThis.CodexOverleafLineReferences) {
-      return globalThis.CodexOverleafLineReferences;
-    }
-    if (typeof require === 'function') {
-      try {
-        return require('./lineReferences');
-      } catch (_error) {
-        return null;
-      }
-    }
-    return null;
-  }
-
-  function loadPathRedaction() {
-    if (typeof globalThis !== 'undefined' && globalThis.CodexOverleafPathRedaction) {
-      return globalThis.CodexOverleafPathRedaction;
-    }
-    if (typeof require === 'function') {
-      try {
-        return require('./pathRedaction');
-      } catch (_error) {
-        return null;
-      }
-    }
-    return null;
-  }
-
   function fallbackSanitizeLocalReferences(value) {
     return String(value || '')
       .replace(/\[([^\]]*)\]\(([^)]*)\)/g, (_raw, label, target) => {