codex-overleaf-link 2.2.0 → 2.3.0

package/extension/src/shared/runInputQueue.js

@@ -1,15 +1,16 @@
 (function initCodexOverleafRunInputQueue(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('./runExecutionSnapshot'));
   } else {
-    root.CodexOverleafRunInputQueue = factory();
+    root.CodexOverleafModuleRegistry.define('RunInputQueue', ['RunExecutionSnapshot'], factory);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function runInputQueueFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function runInputQueueFactory(RunExecutionSnapshot) {
   'use strict';
 
   const MAX_ITEMS = 20;
   const MAX_TEXT_CHARS = 12000;
   const MAX_QUEUE_BYTES = 128 * 1024;
+  const MAX_PERSISTED_QUEUE_BYTES = 512 * 1024;
   const ACTIVE_STATUSES = new Set(['claimed', 'executing', 'steering']);
   const VALID_STATUSES = new Set(['queued', 'paused', ...ACTIVE_STATUSES]);
 
@@ -27,6 +28,7 @@
       if (options.recoverActive === true && ACTIVE_STATUSES.has(status)) {
         status = 'paused';
       }
+      const executionSnapshot = normalizeExecutionSnapshot(raw, options.fallbackInput);
       normalized.push({
         id,
         clientUserMessageId: String(raw.clientUserMessageId || id),
@@ -38,7 +40,8 @@
         linkedRunId: status === 'executing' ? String(raw.linkedRunId || '') : '',
         claimToken: status === 'claimed' || status === 'executing' ? String(raw.claimToken || '') : '',
         pauseReason: status === 'paused' ? String(raw.pauseReason || '') : '',
-        payload: normalizePayload(raw.payload)
+        executionSnapshot: RunExecutionSnapshot.cloneSnapshot(executionSnapshot),
+        payload: RunExecutionSnapshot.toQueuePayload(executionSnapshot)
       });
       if (normalized.length >= MAX_ITEMS) {
         break;
@@ -63,6 +66,7 @@
     const nowFactory = deps.now || (() => new Date().toISOString());
     const id = String(input.id || idFactory());
     const timestamp = String(nowFactory());
+    const executionSnapshot = normalizeExecutionSnapshot(input, input.fallbackInput);
     const item = {
       id,
       clientUserMessageId: String(input.clientUserMessageId || id),
@@ -74,10 +78,11 @@
       linkedRunId: '',
       claimToken: '',
       pauseReason: input.status === 'paused' ? String(input.pauseReason || '') : '',
-      payload: normalizePayload(input.payload)
+      executionSnapshot: RunExecutionSnapshot.cloneSnapshot(executionSnapshot),
+      payload: RunExecutionSnapshot.toQueuePayload(executionSnapshot)
     };
     const next = [...queue, item];
-    if (estimateBytes(next) > MAX_QUEUE_BYTES) {
+    if (estimateLegacyBytes(next) > MAX_QUEUE_BYTES || estimateBytes(next) > MAX_PERSISTED_QUEUE_BYTES) {
       return failure(queue, 'queue_too_large');
     }
     return { ok: true, queue: next, item };
@@ -114,13 +119,37 @@
       return { ok: false, queue, item: null };
     }
     const tokenFactory = deps.randomUUID || (() => 'claim_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8));
-    const item = {
+    let item = {
       ...queue[index],
       status: 'claimed',
       claimToken: String(tokenFactory()),
       updatedAt: new Date().toISOString(),
       pauseReason: ''
     };
+    try {
+      const captured = RunExecutionSnapshot.normalizeSnapshot(
+        item.executionSnapshot || item.payload?.executionSnapshot || item.payload,
+        { source: item.executionSnapshot?.source || item.payload?.executionSnapshot?.source || 'submitted' }
+      );
+      const snapshot = deps.resolveExecutionSnapshot instanceof Function
+        ? deps.resolveExecutionSnapshot(captured)
+        : captured;
+      item = {
+        ...item,
+        executionSnapshot: RunExecutionSnapshot.cloneSnapshot(snapshot),
+        payload: RunExecutionSnapshot.toQueuePayload(snapshot)
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        queue,
+        item: null,
+        error: {
+          code: error?.code || 'provider_revision_conflict',
+          message: error?.message || ''
+        }
+      };
+    }
     queue[index] = item;
     return { ok: true, queue, item };
   }
@@ -160,21 +189,14 @@
     return normalizeQueue(items).map(item => item.id === id ? updater(item) : item);
   }
 
-  function normalizePayload(payload = {}) {
-    return {
-      mode: ['ask', 'confirm', 'auto'].includes(payload.mode) ? payload.mode : 'ask',
-      providerId: String(payload.providerId || 'builtin').slice(0, 160),
-      providerRevision: String(payload.providerRevision || '').slice(0, 160),
-      model: String(payload.model || '').slice(0, 160),
-      reasoningEffort: String(payload.reasoningEffort || '').slice(0, 32),
-      speedTier: payload.speedTier === 'fast' ? 'fast' : 'standard',
-      autoRecompile: payload.autoRecompile !== false,
-      requireReviewing: payload.requireReviewing !== false,
-      focusFiles: (Array.isArray(payload.focusFiles) ? payload.focusFiles : [])
-        .map(path => String(path || '').replace(/\\/g, '/').replace(/^\/+/, '').trim())
-        .filter(Boolean)
-        .slice(0, 100)
-    };
+  function normalizeExecutionSnapshot(raw = {}, fallbackInput = {}) {
+    return RunExecutionSnapshot.captureRawQueueTuple(raw, fallbackInput);
+  }
+
+  function normalizePayload(payload = {}, fallbackInput = {}) {
+    return RunExecutionSnapshot.toQueuePayload(
+      RunExecutionSnapshot.captureRawQueueTuple(payload, fallbackInput)
+    );
   }
 
   function normalizeTimestamp(value) {
@@ -183,7 +205,10 @@
 
   function trimToBudget(items) {
     const queue = items.slice(-MAX_ITEMS);
-    while (queue.length && estimateBytes(queue) > MAX_QUEUE_BYTES) {
+    while (queue.length && (
+      estimateLegacyBytes(queue) > MAX_QUEUE_BYTES
+      || estimateBytes(queue) > MAX_PERSISTED_QUEUE_BYTES
+    )) {
       queue.shift();
     }
     return queue;
@@ -196,6 +221,29 @@
       : text.length * 2;
   }
 
+  function estimateLegacyBytes(items) {
+    return estimateBytes((Array.isArray(items) ? items : []).map(item => {
+      const legacyItem = { ...(item || {}) };
+      delete legacyItem.executionSnapshot;
+      return {
+        ...legacyItem,
+        payload: item?.payload && typeof item.payload === 'object'
+          ? {
+              mode: item.payload.mode,
+              providerId: item.payload.providerId,
+              providerRevision: item.payload.providerRevision,
+              model: item.payload.model,
+              reasoningEffort: item.payload.reasoningEffort,
+              speedTier: item.payload.speedTier,
+              autoRecompile: item.payload.autoRecompile,
+              requireReviewing: item.payload.requireReviewing,
+              focusFiles: item.payload.focusFiles
+            }
+          : {}
+      };
+    }));
+  }
+
   function compactForStorage(items, helpers = {}) {
     const normalizeField = helpers.normalizeField || (value => String(value || ''));
     const normalizeDisplay = helpers.normalizeDisplay || normalizeField;
@@ -204,6 +252,11 @@
       .slice(-MAX_ITEMS)
       .map(item => {
         const payload = item?.payload && typeof item.payload === 'object' ? item.payload : {};
+        const snapshot = RunExecutionSnapshot.captureRawQueueTuple(item, payload);
+        const compactSnapshot = RunExecutionSnapshot.cloneSnapshot({
+          ...snapshot,
+          focusFiles: normalizePaths(snapshot.focusFiles)
+        });
         return {
           id: normalizeField(item?.id, 160),
           clientUserMessageId: normalizeField(item?.clientUserMessageId, 160),
@@ -215,17 +268,8 @@
           linkedRunId: normalizeField(item?.linkedRunId, 160),
           claimToken: normalizeField(item?.claimToken, 160),
           pauseReason: normalizeField(item?.pauseReason, 160),
-          payload: {
-            mode: typeof payload.mode === 'string' ? payload.mode : 'ask',
-            providerId: normalizeField(payload.providerId, 160) || 'builtin',
-            providerRevision: normalizeField(payload.providerRevision, 160),
-            model: normalizeField(payload.model, 160),
-            reasoningEffort: normalizeField(payload.reasoningEffort, 32),
-            speedTier: payload.speedTier === 'fast' ? 'fast' : 'standard',
-            autoRecompile: payload.autoRecompile !== false,
-            requireReviewing: payload.requireReviewing !== false,
-            focusFiles: normalizePaths(payload.focusFiles)
-          }
+          executionSnapshot: compactSnapshot,
+          payload: RunExecutionSnapshot.toQueuePayload(compactSnapshot)
         };
       })
       .filter(item => item.id && item.text);
@@ -238,10 +282,13 @@
   return {
     MAX_ITEMS,
     MAX_QUEUE_BYTES,
+    MAX_PERSISTED_QUEUE_BYTES,
     MAX_TEXT_CHARS,
     claimNext,
     compactForStorage,
     enqueue,
+    estimateBytes,
+    estimateLegacyBytes,
     markExecuting,
     markSteering,
     normalizeQueue,

package/extension/src/shared/scopedPersistenceBrowserAdapter.js

@@ -0,0 +1,79 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('./scopedPersistenceQueuePolicy'));
+  } else {
+    root.CodexOverleafModuleRegistry.define(
+      'ScopedPersistenceBrowserAdapter',
+      ['ScopedPersistenceQueuePolicy'],
+      factory
+    );
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (QueuePolicy) {
+  'use strict';
+
+  var META_PREFIX = 'codex-overleaf-scoped-persistence-v1:';
+  var fallbackMeta = new Map();
+  var cleanPart = QueuePolicy.cleanPart;
+  var normalizeMeta = QueuePolicy.normalizeMeta;
+
+  function normalizeScope(input) {
+    return Object.freeze({
+      accountScopeId: cleanPart(input && input.accountScopeId),
+      projectId: cleanPart(input && input.projectId)
+    });
+  }
+
+  function scopeKey(scope) {
+    var normalized = normalizeScope(scope);
+    if (!normalized.accountScopeId) {
+      var error = new Error('A stable account scope is required for durable persistence.');
+      error.code = 'account_scope_unavailable';
+      throw error;
+    }
+    return META_PREFIX + encodeURIComponent(normalized.accountScopeId)
+      + ':' + encodeURIComponent(normalized.projectId);
+  }
+
+  function createBrowserAdapter(options) {
+    options = options || {};
+    var chromeApi = options.chromeApi || (typeof chrome !== 'undefined' ? chrome : null);
+    var locksApi = Object.prototype.hasOwnProperty.call(options, 'locksApi')
+      ? options.locksApi
+      : (typeof navigator !== 'undefined' ? navigator.locks : null);
+    return {
+      async read(scope) {
+        var key = scopeKey(scope);
+        if (!chromeApi || !chromeApi.storage || !chromeApi.storage.local) {
+          return normalizeMeta(fallbackMeta.get(key));
+        }
+        var stored = await chromeApi.storage.local.get(key);
+        return normalizeMeta(stored && stored[key]);
+      },
+      async write(scope, meta) {
+        var key = scopeKey(scope);
+        var normalized = normalizeMeta(meta);
+        if (!chromeApi || !chromeApi.storage || !chromeApi.storage.local) {
+          fallbackMeta.set(key, normalized);
+          return normalized;
+        }
+        await chromeApi.storage.local.set({ [key]: normalized });
+        return normalized;
+      },
+      withLock(scope, work) {
+        var key = scopeKey(scope);
+        if (locksApi && typeof locksApi.request === 'function') {
+          return locksApi.request(key, { mode: 'exclusive' }, work);
+        }
+        var error = new Error('A cross-realm browser lock is required for durable persistence.');
+        error.code = 'storage_lock_unavailable';
+        return Promise.reject(error);
+      }
+    };
+  }
+
+  return Object.freeze({
+    createBrowserAdapter: createBrowserAdapter,
+    normalizeScope: normalizeScope,
+    scopeKey: scopeKey
+  });
+});

package/extension/src/shared/scopedPersistenceQueuePolicy.js

@@ -0,0 +1,181 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafScopedPersistenceQueuePolicy = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function createQueueClaim(input) {
+    return Object.freeze({
+      itemId: cleanPart(input && input.itemId),
+      ownerId: cleanPart(input && input.ownerId),
+      queueRevision: normalizeRevision(input && input.queueRevision),
+      claimedAt: cleanPart(input && input.claimedAt) || new Date().toISOString()
+    });
+  }
+
+  function isClaimCurrent(claim, queueState) {
+    return Boolean(claim && queueState
+      && cleanPart(claim.itemId) === cleanPart(queueState.itemId)
+      && cleanPart(claim.ownerId) === cleanPart(queueState.ownerId)
+      && normalizeRevision(claim.queueRevision) === normalizeRevision(queueState.queueRevision));
+  }
+
+  function mergeTombstones(existing, additions, limit) {
+    var result = Object.assign({}, existing && typeof existing === 'object' ? existing : {});
+    var now = new Date().toISOString();
+    (Array.isArray(additions) ? additions : []).forEach(function (id) {
+      var cleanId = cleanPart(id);
+      if (cleanId) result[cleanId] = now;
+    });
+    var max = Number.isFinite(Number(limit)) ? Math.max(1, Number(limit)) : 100;
+    return Object.fromEntries(Object.entries(result)
+      .sort(function (left, right) { return String(right[1]).localeCompare(String(left[1])); })
+      .slice(0, max));
+  }
+
+  function normalizeMeta(value) {
+    return {
+      revision: normalizeRevision(value && value.revision),
+      queueRevision: normalizeRevision(value && value.queueRevision),
+      writerId: cleanPart(value && value.writerId),
+      updatedAt: cleanPart(value && value.updatedAt),
+      queueClaims: normalizeQueueClaims(value && value.queueClaims),
+      queueTombstones: normalizeTombstoneMap(value && value.queueTombstones),
+      sessionTombstones: normalizeTombstoneMap(value && value.sessionTombstones)
+    };
+  }
+
+  function normalizeQueueMutations(options) {
+    var values = [];
+    if (options && options.queueMutation) values.push(options.queueMutation);
+    if (options && Array.isArray(options.queueMutations)) values.push.apply(values, options.queueMutations);
+    return values.filter(function (value) {
+      return value && typeof value === 'object' && cleanPart(value.type);
+    });
+  }
+
+  function applyQueueMutations(meta, mutations, writerId) {
+    var next = normalizeMeta(meta);
+    for (var mutation of mutations) {
+      var type = cleanPart(mutation.type);
+      var itemId = cleanPart(mutation.itemId);
+      var sessionId = cleanPart(mutation.sessionId);
+      if (!itemId && type !== 'transition') {
+        return { ok: false, reason: 'invalid_queue_mutation' };
+      }
+      if (type === 'remove' || type === 'release' || type === 'restore') {
+        var claimed = next.queueClaims[itemId];
+        var mutationToken = cleanPart(mutation.claimToken);
+        if (claimed && !isExpiredClaim(claimed)
+          && (claimed.ownerId !== writerId
+            || !mutationToken
+            || claimed.claimToken !== mutationToken)) {
+          return {
+            ok: false,
+            reason: 'queue_claim_conflict',
+            ownerId: claimed.ownerId,
+            itemId: itemId
+          };
+        }
+      }
+      if (type === 'claim') {
+        var existing = next.queueClaims[itemId];
+        if (existing && existing.ownerId !== writerId && !isExpiredClaim(existing)) {
+          return {
+            ok: false,
+            reason: 'queue_claim_conflict',
+            ownerId: existing.ownerId,
+            itemId: itemId
+          };
+        }
+        next.queueRevision += 1;
+        next.queueClaims[itemId] = {
+          ...createQueueClaim({
+            itemId: itemId,
+            ownerId: writerId,
+            queueRevision: next.queueRevision
+          }),
+          sessionId: sessionId,
+          claimToken: cleanPart(mutation.claimToken)
+        };
+        continue;
+      }
+      if (type === 'remove') {
+        next.queueRevision += 1;
+        next.queueTombstones = mergeTombstones(next.queueTombstones, [itemId], 500);
+        delete next.queueClaims[itemId];
+        continue;
+      }
+      if (type === 'release') {
+        next.queueRevision += 1;
+        delete next.queueClaims[itemId];
+        continue;
+      }
+      if (type === 'restore') {
+        next.queueRevision += 1;
+        delete next.queueClaims[itemId];
+        delete next.queueTombstones[itemId];
+        continue;
+      }
+      if (type === 'enqueue' || type === 'transition') {
+        next.queueRevision += 1;
+        continue;
+      }
+      return { ok: false, reason: 'invalid_queue_mutation' };
+    }
+    return { ok: true, meta: next };
+  }
+
+  function normalizeQueueClaims(value) {
+    var source = value && typeof value === 'object' ? value : {};
+    var result = {};
+    Object.entries(source).forEach(function (entry) {
+      var itemId = cleanPart(entry[0]);
+      var claim = entry[1] && typeof entry[1] === 'object' ? entry[1] : {};
+      var ownerId = cleanPart(claim.ownerId);
+      if (!itemId || !ownerId) return;
+      result[itemId] = {
+        itemId: itemId,
+        ownerId: ownerId,
+        sessionId: cleanPart(claim.sessionId),
+        claimToken: cleanPart(claim.claimToken),
+        queueRevision: normalizeRevision(claim.queueRevision),
+        claimedAt: cleanPart(claim.claimedAt)
+      };
+    });
+    return result;
+  }
+
+  function normalizeTombstoneMap(value) {
+    var source = value && typeof value === 'object' ? value : {};
+    return Object.fromEntries(Object.entries(source)
+      .map(function (entry) { return [cleanPart(entry[0]), cleanPart(entry[1])]; })
+      .filter(function (entry) { return entry[0] && entry[1]; }));
+  }
+
+  function isExpiredClaim(claim, now) {
+    var claimedAt = Date.parse(claim && claim.claimedAt || '');
+    return !claimedAt || (Number(now || Date.now()) - claimedAt) > 60 * 1000;
+  }
+
+  function normalizeRevision(value) {
+    var number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : 0;
+  }
+
+  function cleanPart(value) {
+    return typeof value === 'string' ? value.trim() : '';
+  }
+
+  return Object.freeze({
+    applyQueueMutations: applyQueueMutations,
+    cleanPart: cleanPart,
+    createQueueClaim: createQueueClaim,
+    isClaimCurrent: isClaimCurrent,
+    mergeTombstones: mergeTombstones,
+    normalizeMeta: normalizeMeta,
+    normalizeQueueMutations: normalizeQueueMutations,
+    normalizeRevision: normalizeRevision
+  });
+});