codex-overleaf-link 2.1.4 → 2.2.0

package/extension/src/shared/storageDb.js

@@ -1,12 +1,12 @@
 (function initStorageDb(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory(require('./storageRunActions'));
+    module.exports = factory(require('./storageRunActions'), require('./runInputQueue'));
   } else {
-    root.CodexOverleafStorageDb = factory(root.CodexOverleafStorageRunActions);
+    root.CodexOverleafStorageDb = factory(root.CodexOverleafStorageRunActions, root.CodexOverleafRunInputQueue);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions) {
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue) {
   'use strict';
-  if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot) {
+  if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage) {
     throw new Error('Codex Overleaf storage run-action helpers are unavailable.');
   }
   // IndexedDB versions are monotonic; v2.0 RC profiles have already opened v3.
@@ -272,6 +272,11 @@
       codexThreadId: typeof input.codexThreadId === 'string' ? input.codexThreadId : '',
       status: typeof input.status === 'string' && input.status ? input.status : 'active',
       focusFiles: normalizePathList(input.focusFiles),
+      pendingInputs: RunInputQueue.compactForStorage(input.pendingInputs, {
+        normalizeField: normalizeTextField,
+        normalizeDisplay: normalizeDisplayTextForStorage,
+        normalizePaths: normalizePathList
+      }),
       history: compactHistoryForStorage(input.history),
       runs: compactRunsForStorage(input.runs, options),
       task: normalizeDisplayTextForStorage(input.task, SESSION_STORAGE_LIMITS.taskChars),
@@ -663,8 +668,23 @@
       undoBaseFiles: actionPayload.undoBaseFiles,
       undoTrackedChanges: actionPayload.undoTrackedChanges,
       undoExpectedFiles: actionPayload.undoExpectedFiles,
-      undoStatus: normalizeDisplayTextForStorage(run.undoStatus, SESSION_STORAGE_LIMITS.statusTextChars)
+      undoStatus: normalizeDisplayTextForStorage(run.undoStatus, SESSION_STORAGE_LIMITS.statusTextChars),
+      nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
+      codexTurnId: normalizeTextField(run.codexTurnId, 160),
+      nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
+      queueItemId: normalizeTextField(run.queueItemId, 160)
     };
+    if (run.interruptedDraft && typeof run.interruptedDraft === 'object') {
+      compact.interruptedDraft = {
+        requestId: normalizeTextField(run.interruptedDraft.requestId, 160),
+        threadId: normalizeTextField(run.interruptedDraft.threadId, 160),
+        turnId: normalizeTextField(run.interruptedDraft.turnId, 160),
+        lastEventSeq: Number.isFinite(Number(run.interruptedDraft.lastEventSeq))
+          ? Number(run.interruptedDraft.lastEventSeq)
+          : 0,
+        reason: normalizeTextField(run.interruptedDraft.reason, 80)
+      };
+    }
     if (VALID_TRACKED_CHANGE_STATUSES[run.trackedChangeStatus] === true) {
       compact.trackedChangeStatus = run.trackedChangeStatus;
     }
@@ -712,27 +732,11 @@
   // its shape while redacting + truncating every string field. Bounded depth +
   // breadth so a pathological value can't blow up the stored record.
   function compactStructuredEventValueForStorage(value, depth) {
-    var d = depth || 0;
-    if (typeof value === 'string') {
-      return normalizeDisplayTextForStorage(value, SESSION_STORAGE_LIMITS.reportDetailChars);
-    }
-    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
-      return value;
-    }
-    if (d > 6 || typeof value !== 'object') {
-      return null;
-    }
-    if (Array.isArray(value)) {
-      return value.slice(0, 32).map(function (item) {
-        return compactStructuredEventValueForStorage(item, d + 1);
-      });
-    }
-    var out = {};
-    var keys = Object.keys(value).slice(0, 32);
-    for (var i = 0; i < keys.length; i++) {
-      out[keys[i]] = compactStructuredEventValueForStorage(value[keys[i]], d + 1);
-    }
-    return out;
+    return StorageRunActions.compactStructuredEventValue(value, {
+      normalizeString: function (text) {
+        return normalizeDisplayTextForStorage(text, SESSION_STORAGE_LIMITS.reportDetailChars);
+      }
+    }, depth);
   }
 
   function getEventDetailLimit(event) {
@@ -1142,7 +1146,11 @@
       return Promise.resolve([]);
     }
     return getAllSessions().then(function (all) {
-      return filterRecentProjectsAcrossAccount(all, { accountScopeId: accountScopeId, limit: limit });
+      return filterRecentProjectsAcrossAccount(all, {
+        accountScopeId: accountScopeId,
+        limit: limit,
+        deletedSessionIdsByProject: options && options.deletedSessionIdsByProject
+      });
     });
   }
 
@@ -1153,6 +1161,7 @@
   function filterRecentProjectsAcrossAccount(sessions, options) {
     var accountScopeId = options && options.accountScopeId;
     var limit = options && Number.isFinite(options.limit) ? options.limit : 10;
+    var deletedSessionIdsByProject = options && options.deletedSessionIdsByProject;
     if (!accountScopeId) {
       return [];
     }
@@ -1163,6 +1172,8 @@
       var s = all[i];
       if (!s) continue;
       if (s.accountScopeId !== accountScopeId) continue;
+      if (deletedSessionIdsByProject && Array.isArray(deletedSessionIdsByProject[s.projectId])
+        && deletedSessionIdsByProject[s.projectId].indexOf(s.id) !== -1) continue;
       if (typeof s.lastActivityAt !== 'string' || !s.lastActivityAt) continue;
       if (!isValidOverleafProjectId(s.projectId)) continue;
       var prev = byProject[s.projectId];
@@ -1303,23 +1314,7 @@
     }
   }
 
-  function hashString(value) {
-    var hash = 2166136261;
-    var text = String(value || '');
-    for (var i = 0; i < text.length; i++) {
-      hash ^= text.charCodeAt(i);
-      hash = Math.imul(hash, 16777619);
-    }
-    return (hash >>> 0).toString(16).padStart(8, '0');
-  }
-
-  function cloneJsonValue(value) {
-    try {
-      return JSON.parse(JSON.stringify(value));
-    } catch (_error) {
-      return Array.isArray(value) ? value.slice() : value;
-    }
-  }
+  var hashString = StorageRunActions.hashString;
 
   return {
     TARGET_SCHEMA_VERSION: TARGET_SCHEMA_VERSION,

package/extension/src/shared/storageMigration.js

@@ -8,6 +8,9 @@
   'use strict';
 
   var PREFS_KEY = 'codexOverleafPrefs';
+  var SESSION_TOMBSTONES_KEY = 'codexOverleafSessionTombstones';
+  var SESSION_TOMBSTONE_ENTRY_PREFIX = 'codexOverleafSessionTombstone:v2:';
+  var MAX_DELETED_SESSION_IDS_PER_PROJECT = 100;
   var CUSTOM_INSTRUCTIONS_MAX_CHARS = 12000;
   var PROJECT_PREF_KEY_MAX_CHARS = 160;
 
@@ -15,15 +18,20 @@
     var StorageDb = (typeof window !== 'undefined' && window.CodexOverleafStorageDb)
       ? window.CodexOverleafStorageDb
       : require('./storageDb');
-    return chrome.storage.local.get([PREFS_KEY, legacyStorageKey]).then(function (stored) {
+    return chrome.storage.local.get(null).then(function (stored) {
       var prefs = normalizePrefs(stored[PREFS_KEY] || {});
+      var tombstones = collectSessionTombstones(stored);
+      var deletedSessionIds = getDeletedSessionIds(tombstones, projectId);
       var schemaVersion = prefs.storageSchemaVersion || 0;
 
       if (schemaVersion >= StorageDb.TARGET_SCHEMA_VERSION) {
         var activeSessionByProject = prefs.activeSessionByProject || {};
         var activeSessionId = activeSessionByProject[projectId] || '';
         return StorageDb.getAllByIndex('sessions', 'projectId', projectId).then(function (sessions) {
-          return { prefs: prefs, sessions: sessions, activeSessionId: activeSessionId, migrated: false };
+          var visibleSessions = sessions.filter(function (session) {
+            return deletedSessionIds.indexOf(session && session.id) === -1;
+          });
+          return { prefs: prefs, sessions: visibleSessions, activeSessionId: activeSessionId, migrated: false };
         });
       }
 
@@ -35,6 +43,7 @@
       for (var i = 0; i < legacySessions.length; i++) {
         var legacy = legacySessions[i];
         if (!legacy || !legacy.id) { continue; }
+        if (deletedSessionIds.indexOf(legacy.id) !== -1) { continue; }
         var record = StorageDb.buildSessionRecord(
           buildLegacySessionRecordInput(projectId, legacyBlob, legacy)
         );
@@ -101,6 +110,112 @@
     });
   }
 
+  function normalizeDeletedSessionIdsByProject(value) {
+    var result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return result;
+    }
+    Object.keys(value).forEach(function (rawProjectId) {
+      var projectId = normalizeProjectPrefKey(rawProjectId);
+      if (!projectId || !Array.isArray(value[rawProjectId])) {
+        return;
+      }
+      var seen = {};
+      var ids = value[rawProjectId].map(function (id) {
+        return normalizeTextField(id, PROJECT_PREF_KEY_MAX_CHARS);
+      }).filter(function (id) {
+        if (!id || seen[id]) { return false; }
+        seen[id] = true;
+        return true;
+      }).slice(-MAX_DELETED_SESSION_IDS_PER_PROJECT);
+      if (ids.length) {
+        result[projectId] = ids;
+      }
+    });
+    return result;
+  }
+
+  function getDeletedSessionIds(tombstones, projectId) {
+    var normalized = normalizeDeletedSessionIdsByProject(tombstones);
+    var key = normalizeProjectPrefKey(projectId);
+    return key && Array.isArray(normalized[key]) ? normalized[key].slice() : [];
+  }
+
+  function loadSessionTombstones() {
+    return chrome.storage.local.get(null).then(function (stored) {
+      return collectSessionTombstones(stored);
+    });
+  }
+
+  function addSessionTombstones(projectId, sessionIds) {
+    var key = normalizeProjectPrefKey(projectId);
+    if (!key) {
+      return loadSessionTombstones();
+    }
+    var incoming = (Array.isArray(sessionIds) ? sessionIds : [])
+      .map(function (id) { return normalizeTextField(id, PROJECT_PREF_KEY_MAX_CHARS); })
+      .filter(Boolean);
+    if (!incoming.length) {
+      return loadSessionTombstones();
+    }
+    var deletedAt = new Date().toISOString();
+    var payload = {};
+    incoming.forEach(function (sessionId) {
+      payload[buildSessionTombstoneEntryKey(key, sessionId)] = {
+        projectId: key,
+        sessionId: sessionId,
+        deletedAt: deletedAt
+      };
+    });
+    return chrome.storage.local.set(payload)
+      .then(function () { return pruneSessionTombstoneEntries(key); })
+      .then(loadSessionTombstones);
+  }
+
+  function collectSessionTombstones(stored) {
+    var tombstones = normalizeDeletedSessionIdsByProject(
+      stored && stored[SESSION_TOMBSTONES_KEY] || {}
+    );
+    Object.keys(stored || {}).forEach(function (storageKey) {
+      if (storageKey.indexOf(SESSION_TOMBSTONE_ENTRY_PREFIX) !== 0) {
+        return;
+      }
+      var entry = stored[storageKey];
+      var projectId = normalizeProjectPrefKey(entry && entry.projectId);
+      var sessionId = normalizeTextField(entry && entry.sessionId, PROJECT_PREF_KEY_MAX_CHARS);
+      if (!projectId || !sessionId) {
+        return;
+      }
+      tombstones[projectId] = (tombstones[projectId] || [])
+        .filter(function (id) { return id !== sessionId; })
+        .concat(sessionId)
+        .slice(-MAX_DELETED_SESSION_IDS_PER_PROJECT);
+    });
+    return normalizeDeletedSessionIdsByProject(tombstones);
+  }
+
+  function buildSessionTombstoneEntryKey(projectId, sessionId) {
+    return SESSION_TOMBSTONE_ENTRY_PREFIX +
+      encodeURIComponent(projectId) + ':' +
+      encodeURIComponent(sessionId);
+  }
+
+  function pruneSessionTombstoneEntries(projectId) {
+    return chrome.storage.local.get(null).then(function (stored) {
+      var entries = Object.keys(stored || {}).filter(function (storageKey) {
+        var entry = stored[storageKey];
+        return storageKey.indexOf(SESSION_TOMBSTONE_ENTRY_PREFIX) === 0 &&
+          normalizeProjectPrefKey(entry && entry.projectId) === projectId;
+      }).sort(function (leftKey, rightKey) {
+        var left = String(stored[leftKey] && stored[leftKey].deletedAt || '');
+        var right = String(stored[rightKey] && stored[rightKey].deletedAt || '');
+        return left === right ? leftKey.localeCompare(rightKey) : left.localeCompare(right);
+      });
+      var obsolete = entries.slice(0, Math.max(0, entries.length - MAX_DELETED_SESSION_IDS_PER_PROJECT));
+      return obsolete.length ? chrome.storage.local.remove(obsolete) : undefined;
+    });
+  }
+
   function normalizePrefs(prefs) {
     var source = prefs && typeof prefs === 'object' ? prefs : {};
     return Object.assign({}, source, {
@@ -162,8 +277,13 @@
 
   return {
     PREFS_KEY: PREFS_KEY,
+    SESSION_TOMBSTONES_KEY: SESSION_TOMBSTONES_KEY,
     runMigrationIfNeeded: runMigrationIfNeeded,
     savePrefs: savePrefs,
-    loadPrefs: loadPrefs
+    loadPrefs: loadPrefs,
+    loadSessionTombstones: loadSessionTombstones,
+    addSessionTombstones: addSessionTombstones,
+    getDeletedSessionIds: getDeletedSessionIds,
+    normalizeDeletedSessionIdsByProject: normalizeDeletedSessionIdsByProject
   };
 });

package/extension/src/shared/storageRunActions.js

@@ -101,9 +101,42 @@
     };
   }
 
+  function compactStructuredEventValue(value, options, depth) {
+    var config = options || {};
+    var d = depth || 0;
+    if (typeof value === 'string') {
+      return typeof config.normalizeString === 'function' ? config.normalizeString(value) : value;
+    }
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') return value;
+    if (d > 6 || typeof value !== 'object') return null;
+    if (Array.isArray(value)) {
+      return value.slice(0, 32).map(function (item) {
+        return compactStructuredEventValue(item, config, d + 1);
+      });
+    }
+    var out = {};
+    var keys = Object.keys(value).slice(0, 32);
+    for (var i = 0; i < keys.length; i++) {
+      out[keys[i]] = compactStructuredEventValue(value[keys[i]], config, d + 1);
+    }
+    return out;
+  }
+
+  function hashString(value) {
+    var hash = 2166136261;
+    var text = String(value || '');
+    for (var i = 0; i < text.length; i++) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+  }
+
   return {
+    compactStructuredEventValue: compactStructuredEventValue,
     compactRunsForStorage: compactRunsForStorage,
     compactRunActionPayload: compactRunActionPayload,
-    compactProviderSnapshot: compactProviderSnapshot
+    compactProviderSnapshot: compactProviderSnapshot,
+    hashString: hashString
   };
 });

package/extension/src/shared/updateConsent.js

@@ -18,6 +18,7 @@
     'waiting_for_idle',
     'applying',
     'awaiting_health',
+    'rolling_back',
     'committed',
     'rolled_back',
     'failed'
@@ -27,7 +28,8 @@
     'staged',
     'waiting_for_idle',
     'applying',
-    'awaiting_health'
+    'awaiting_health',
+    'rolling_back'
   ]);
   const TERMINAL_STATES = new Set(['committed', 'rolled_back', 'failed']);
   const QUIET_FAILURE_CODES = new Set([
@@ -44,6 +46,7 @@
     waiting_for_idle: { value: 65, determinate: true, phase: 'waiting' },
     applying: { value: 82, determinate: false, phase: 'applying' },
     awaiting_health: { value: 94, determinate: false, phase: 'health' },
+    rolling_back: { value: 94, determinate: false, phase: 'rollback' },
     committed: { value: 100, determinate: true, phase: 'committed' },
     rolled_back: { value: 94, determinate: true, phase: 'rolled_back' },
     failed: { value: 0, determinate: true, phase: 'failed' }
@@ -63,8 +66,12 @@
       blocker: blockers[0] || '',
       blockers,
       transactionId: safeId(value.transactionId),
+      initiatedBy: ['automatic', 'manual'].includes(value.initiatedBy) ? value.initiatedBy : '',
       lastCheckedAt: finiteNumber(value.lastCheckedAt),
       stagedAt: finiteNumber(value.stagedAt),
+      phaseStartedAt: finiteNumber(value.phaseStartedAt),
+      deadlineAt: finiteNumber(value.deadlineAt),
+      heartbeatAt: finiteNumber(value.heartbeatAt),
       postponeUntil: finiteNumber(value.postponeUntil),
       code: safeToken(value.code),
       message: String(value.message || '').replace(/\s+/g, ' ').trim().slice(0, 300)
@@ -96,7 +103,11 @@
     const execution = EXECUTION_STATES.has(state.state);
     const available = state.state === 'update_available' && newer;
     const progress = getProgressModel(state);
-    const quietFailure = state.state === 'failed' && QUIET_FAILURE_CODES.has(state.code);
+    const quietFailure = state.state === 'failed' &&
+      state.initiatedBy !== 'manual' &&
+      QUIET_FAILURE_CODES.has(state.code);
+    const visibleFailure = state.state === 'failed' &&
+      (state.initiatedBy === 'manual' || (!quietFailure && newer));
 
     return {
       state,
@@ -112,7 +123,7 @@
       snoozed,
       execution,
       showPanel: (available && !snoozed) || execution || state.state === 'rolled_back' ||
-        (state.state === 'failed' && !quietFailure && newer),
+        visibleFailure,
       badge: getBadge(state, { available, snoozed }),
       actions: {
         check: ['idle', 'committed', 'rolled_back', 'failed'].includes(state.state),
@@ -135,7 +146,7 @@
   }
 
   function getBadge(state, flags) {
-    if (state.state === 'applying' || state.state === 'awaiting_health') {
+    if (state.state === 'applying' || state.state === 'awaiting_health' || state.state === 'rolling_back') {
       return { text: '...', color: '#3578bd' };
     }
     if (state.state === 'failed' || state.state === 'rolled_back') {