codex-overleaf-link 2.2.1 → 2.3.0

package/extension/src/shared/storageMigration.js

@@ -1,10 +1,10 @@
 (function initStorageMigration(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('./storageDb'));
   } else {
-    root.CodexOverleafStorageMigration = factory();
+    root.CodexOverleafModuleRegistry.define('StorageMigration', ['StorageDb'], factory);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function storageMigrationFactory() {
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageMigrationFactory(StorageDb) {
   'use strict';
 
   var PREFS_KEY = 'codexOverleafPrefs';
@@ -13,74 +13,249 @@
   var MAX_DELETED_SESSION_IDS_PER_PROJECT = 100;
   var CUSTOM_INSTRUCTIONS_MAX_CHARS = 12000;
   var PROJECT_PREF_KEY_MAX_CHARS = 160;
+  var PROJECT_SCOPED_PREF_MAPS = [
+    'activeSessionByProject',
+    'experimentalOtByProject',
+    'customInstructionsByProject',
+    'governanceRulesByProject',
+    'selectedLocalSkillIdsByProject'
+  ];
+  var projectPreferenceLockTails = {};
 
-  function runMigrationIfNeeded(projectId, legacyStorageKey) {
-    var StorageDb = (typeof window !== 'undefined' && window.CodexOverleafStorageDb)
-      ? window.CodexOverleafStorageDb
-      : require('./storageDb');
-    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) {
-          var visibleSessions = sessions.filter(function (session) {
-            return deletedSessionIds.indexOf(session && session.id) === -1;
-          });
-          return { prefs: prefs, sessions: visibleSessions, activeSessionId: activeSessionId, migrated: false };
-        });
+  function buildScopedProjectPreferenceKey(accountScopeId, projectId) {
+    var account = compactScopePart(accountScopeId);
+    var project = compactScopePart(projectId);
+    return account && project ? 'account:' + account + ':project:' + project : '';
+  }
+
+  function compactScopePart(value) {
+    var text = normalizeTextField(value, PROJECT_PREF_KEY_MAX_CHARS);
+    if (!text) {
+      return '';
+    }
+    var encoded = encodeURIComponent(text);
+    if (encoded.length <= 64) {
+      return encoded;
+    }
+    return encoded.slice(0, 48) + '-' + hashText(encoded);
+  }
+
+  function hashText(value) {
+    var hash = 2166136261;
+    for (var i = 0; i < value.length; i++) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+  }
+
+  function withProjectPreferenceLock(projectId, work) {
+    var lockName = 'codex-overleaf-project-prefs:' + compactScopePart(projectId);
+    var lockManager = typeof navigator !== 'undefined' && navigator && navigator.locks;
+    if (lockManager && typeof lockManager.request === 'function') {
+      return lockManager.request(lockName, work);
+    }
+    var previous = projectPreferenceLockTails[lockName] || Promise.resolve();
+    var current = previous.then(work, work);
+    projectPreferenceLockTails[lockName] = current;
+    return current.finally(function () {
+      if (projectPreferenceLockTails[lockName] === current) {
+        delete projectPreferenceLockTails[lockName];
       }
+    });
+  }
 
-      // Migration v0 → v1
-      var legacyBlob = stored[legacyStorageKey] || {};
-      var legacySessions = Array.isArray(legacyBlob.sessions) ? legacyBlob.sessions : [];
-      var migratedSessions = [];
-
-      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)
-        );
-        migratedSessions.push(record);
+  function copyPreferenceValue(value) {
+    if (!value || typeof value !== 'object') {
+      return value;
+    }
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (_error) {
+      return value;
+    }
+  }
+
+  function claimLegacyProjectPreferences(prefs, accountScopeId, projectId) {
+    var scopedKey = buildScopedProjectPreferenceKey(accountScopeId, projectId);
+    var next = normalizePrefs(prefs);
+    var changed = false;
+    PROJECT_SCOPED_PREF_MAPS.forEach(function (mapName) {
+      var source = next[mapName] && typeof next[mapName] === 'object'
+        ? Object.assign({}, next[mapName])
+        : {};
+      if (Object.prototype.hasOwnProperty.call(source, projectId)) {
+        if (!Object.prototype.hasOwnProperty.call(source, scopedKey)) {
+          source[scopedKey] = copyPreferenceValue(source[projectId]);
+        }
+        delete source[projectId];
+        changed = true;
+      }
+      next[mapName] = source;
+    });
+    return { prefs: next, changed: changed };
+  }
+
+  function buildProjectPreferenceView(prefs, accountScopeId, projectId) {
+    var source = normalizePrefs(prefs);
+    var scopedKey = buildScopedProjectPreferenceKey(accountScopeId, projectId);
+    var view = Object.assign({}, source);
+    PROJECT_SCOPED_PREF_MAPS.forEach(function (mapName) {
+      var sourceMap = source[mapName] && typeof source[mapName] === 'object'
+        ? source[mapName]
+        : {};
+      var projectMap = {};
+      if (Object.prototype.hasOwnProperty.call(sourceMap, scopedKey)) {
+        projectMap[projectId] = copyPreferenceValue(sourceMap[scopedKey]);
       }
+      view[mapName] = projectMap;
+    });
+    return normalizePrefs(view);
+  }
 
-      var putPromise = migratedSessions.length
-        ? StorageDb.putRecords('sessions', migratedSessions)
-        : Promise.resolve([]);
+  function mergeScopedProjectPreferences(existingPrefs, incomingPrefs, accountScopeId, projectId) {
+    var existing = normalizePrefs(existingPrefs);
+    var incoming = normalizePrefs(incomingPrefs);
+    var scopedKey = buildScopedProjectPreferenceKey(accountScopeId, projectId);
+    var next = Object.assign({}, existing, incoming);
+    PROJECT_SCOPED_PREF_MAPS.forEach(function (mapName) {
+      var storedMap = existing[mapName] && typeof existing[mapName] === 'object'
+        ? Object.assign({}, existing[mapName])
+        : {};
+      var incomingMap = incoming[mapName] && typeof incoming[mapName] === 'object'
+        ? incoming[mapName]
+        : {};
+      if (Object.prototype.hasOwnProperty.call(incomingMap, projectId)) {
+        storedMap[scopedKey] = copyPreferenceValue(incomingMap[projectId]);
+      }
+      delete storedMap[projectId];
+      next[mapName] = storedMap;
+    });
+    return normalizePrefs(next);
+  }
 
-      return putPromise.then(function () {
-        var newPrefs = StorageDb.extractLightweightPrefs(legacyBlob, projectId);
-        newPrefs.activeSessionByProject = StorageDb.buildActiveSessionByProject(
-          {},
-          projectId,
-          legacyBlob.activeSessionId || (migratedSessions.length ? migratedSessions[migratedSessions.length - 1].id : '')
+  function runMigrationIfNeeded(projectId, legacyStorageKey, accountScopeId) {
+    projectId = normalizeProjectPrefKey(projectId);
+    var normalizedAccountScopeId = normalizeTextField(accountScopeId, PROJECT_PREF_KEY_MAX_CHARS);
+    if (!normalizedAccountScopeId || !projectId) {
+      return Promise.resolve({
+        prefs: normalizePrefs({}),
+        sessions: [],
+        activeSessionId: '',
+        migrated: false,
+        reason: 'account_scope_unavailable'
+      });
+    }
+    return withProjectPreferenceLock(projectId, function () {
+      return chrome.storage.local.get(null).then(function (stored) {
+        var claimed = claimLegacyProjectPreferences(
+          stored[PREFS_KEY] || {},
+          normalizedAccountScopeId,
+          projectId
         );
-        newPrefs = normalizePrefs(newPrefs);
-
-        return chrome.storage.local.set({ [PREFS_KEY]: newPrefs }).then(function () {
-          return chrome.storage.local.remove(legacyStorageKey).catch(function () {});
-        }).then(function () {
-          return {
-            prefs: newPrefs,
-            sessions: migratedSessions,
-            activeSessionId: newPrefs.activeSessionByProject[projectId] || '',
-            migrated: true
-          };
+        var storedPrefs = claimed.prefs;
+        var persistClaim = claimed.changed
+          ? chrome.storage.local.set({ [PREFS_KEY]: storedPrefs })
+          : Promise.resolve();
+        return persistClaim.then(function () {
+          var prefs = buildProjectPreferenceView(
+            storedPrefs,
+            normalizedAccountScopeId,
+            projectId
+          );
+          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] || '';
+            if (typeof StorageDb.claimSessionsForAccount !== 'function') {
+              return Promise.reject(Object.assign(
+                new Error('Atomic legacy-session claiming is unavailable.'),
+                { code: 'scoped_claim_unavailable' }
+              ));
+            }
+            return StorageDb.claimSessionsForAccount(
+              projectId,
+              normalizedAccountScopeId,
+              deletedSessionIds
+            ).then(function (visibleSessions) {
+              var visibleActiveSessionId = visibleSessions.some(function (session) {
+                return session && session.id === activeSessionId;
+              })
+                ? activeSessionId
+                : visibleSessions.length
+                  ? visibleSessions[visibleSessions.length - 1].id
+                  : '';
+              return {
+                prefs: prefs,
+                sessions: visibleSessions,
+                activeSessionId: visibleActiveSessionId,
+                migrated: false
+              };
+            });
+          }
+
+          // Migration v0 → v1
+          var legacyBlob = stored[legacyStorageKey] || {};
+          var legacySessions = Array.isArray(legacyBlob.sessions) ? legacyBlob.sessions : [];
+          var migratedSessions = [];
+
+          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, normalizedAccountScopeId)
+            );
+            migratedSessions.push(record);
+          }
+
+          var putPromise = migratedSessions.length
+            ? StorageDb.putRecords('sessions', migratedSessions)
+            : Promise.resolve([]);
+
+          return putPromise.then(function () {
+            var newPrefs = StorageDb.extractLightweightPrefs(legacyBlob, projectId);
+            newPrefs.activeSessionByProject = StorageDb.buildActiveSessionByProject(
+              {},
+              projectId,
+              legacyBlob.activeSessionId || (migratedSessions.length ? migratedSessions[migratedSessions.length - 1].id : '')
+            );
+            var mergedPrefs = mergeScopedProjectPreferences(
+              storedPrefs,
+              newPrefs,
+              normalizedAccountScopeId,
+              projectId
+            );
+            var prefsView = buildProjectPreferenceView(
+              mergedPrefs,
+              normalizedAccountScopeId,
+              projectId
+            );
+
+            return chrome.storage.local.set({ [PREFS_KEY]: mergedPrefs }).then(function () {
+              return chrome.storage.local.remove(legacyStorageKey).catch(function () {});
+            }).then(function () {
+              return {
+                prefs: prefsView,
+                sessions: migratedSessions,
+                activeSessionId: prefsView.activeSessionByProject[projectId] || '',
+                migrated: true
+              };
+            });
+          });
         });
       });
     });
   }
 
-  function buildLegacySessionRecordInput(projectId, legacyBlob, legacy) {
+  function buildLegacySessionRecordInput(projectId, legacyBlob, legacy, accountScopeId) {
     return {
       id: legacy.id,
       projectId: projectId,
+      accountScopeId: accountScopeId,
       title: legacy.title || '',
       titleSource: legacy.titleSource === 'manual' ? 'manual' : 'auto',
       codexThreadId: '',
@@ -100,13 +275,51 @@
     };
   }
 
-  function savePrefs(prefs) {
-    return chrome.storage.local.set({ [PREFS_KEY]: normalizePrefs(prefs) });
+  function savePrefs(prefs, accountScopeId, projectId) {
+    var account = normalizeTextField(accountScopeId, PROJECT_PREF_KEY_MAX_CHARS);
+    var project = normalizeProjectPrefKey(projectId);
+    if (!account && !project) {
+      return chrome.storage.local.set({ [PREFS_KEY]: normalizePrefs(prefs) });
+    }
+    if (!account || !project) {
+      return Promise.reject(Object.assign(
+        new Error('Scoped project preferences require account and project identity.'),
+        { code: 'account_scope_unavailable' }
+      ));
+    }
+    return withProjectPreferenceLock(project, function () {
+      return chrome.storage.local.get([PREFS_KEY]).then(function (stored) {
+        var claimed = claimLegacyProjectPreferences(stored[PREFS_KEY] || {}, account, project);
+        var next = mergeScopedProjectPreferences(claimed.prefs, prefs, account, project);
+        return chrome.storage.local.set({ [PREFS_KEY]: next });
+      });
+    });
   }
 
-  function loadPrefs() {
-    return chrome.storage.local.get([PREFS_KEY]).then(function (stored) {
-      return normalizePrefs(stored[PREFS_KEY] || {});
+  function loadPrefs(accountScopeId, projectId) {
+    var account = normalizeTextField(accountScopeId, PROJECT_PREF_KEY_MAX_CHARS);
+    var project = normalizeProjectPrefKey(projectId);
+    if (!account && !project) {
+      return chrome.storage.local.get([PREFS_KEY]).then(function (stored) {
+        return normalizePrefs(stored[PREFS_KEY] || {});
+      });
+    }
+    if (!account || !project) {
+      return Promise.reject(Object.assign(
+        new Error('Scoped project preferences require account and project identity.'),
+        { code: 'account_scope_unavailable' }
+      ));
+    }
+    return withProjectPreferenceLock(project, function () {
+      return chrome.storage.local.get([PREFS_KEY]).then(function (stored) {
+        var claimed = claimLegacyProjectPreferences(stored[PREFS_KEY] || {}, account, project);
+        var persisted = claimed.changed
+          ? chrome.storage.local.set({ [PREFS_KEY]: claimed.prefs })
+          : Promise.resolve();
+        return persisted.then(function () {
+          return buildProjectPreferenceView(claimed.prefs, account, project);
+        });
+      });
     });
   }
 
@@ -278,6 +491,7 @@
   return {
     PREFS_KEY: PREFS_KEY,
     SESSION_TOMBSTONES_KEY: SESSION_TOMBSTONES_KEY,
+    buildScopedProjectPreferenceKey: buildScopedProjectPreferenceKey,
     runMigrationIfNeeded: runMigrationIfNeeded,
     savePrefs: savePrefs,
     loadPrefs: loadPrefs,

package/extension/src/shared/storageSessionClaims.js

@@ -0,0 +1,60 @@
+(function initStorageSessionClaims(root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafStorageSessionClaims = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function storageSessionClaimsFactory() {
+  'use strict';
+
+  function createSessionClaimer(openDb, getKeyRange) {
+    return function claimSessionsForAccount(projectId, accountScopeId, deletedSessionIds) {
+      var normalizedProjectId = typeof projectId === 'string' ? projectId.trim() : '';
+      var normalizedAccountScopeId = typeof accountScopeId === 'string' ? accountScopeId.trim() : '';
+      if (!normalizedProjectId || !normalizedAccountScopeId) {
+        return Promise.reject(Object.assign(
+          new Error('A project and account scope are required to claim legacy sessions.'),
+          { code: !normalizedAccountScopeId ? 'account_scope_unavailable' : 'project_scope_unavailable' }
+        ));
+      }
+      var deleted = {};
+      (Array.isArray(deletedSessionIds) ? deletedSessionIds : []).forEach(function (id) {
+        if (typeof id === 'string' && id) deleted[id] = true;
+      });
+      return openDb().then(function (db) {
+        return new Promise(function (resolve, reject) {
+          var visible = [];
+          var tx = db.transaction('sessions', 'readwrite');
+          var store = tx.objectStore('sessions');
+          var index = store.index('projectId');
+          var request = index.openCursor(getKeyRange().only(normalizedProjectId));
+          request.onsuccess = function (event) {
+            var cursor = event.target.result;
+            if (!cursor) return;
+            var record = cursor.value;
+            if (record && !deleted[record.id]) {
+              var recordScopeId = typeof record.accountScopeId === 'string'
+                ? record.accountScopeId.trim()
+                : '';
+              if (recordScopeId === normalizedAccountScopeId) {
+                visible.push(record);
+              } else if (!recordScopeId) {
+                var claimed = Object.assign({}, record, {
+                  accountScopeId: normalizedAccountScopeId,
+                  accountScopeUnavailable: false
+                });
+                cursor.update(claimed);
+                visible.push(claimed);
+              }
+            }
+            cursor.continue();
+          };
+          request.onerror = function (event) { reject(event.target.error); };
+          tx.oncomplete = function () { resolve(visible); };
+          tx.onerror = function (event) { reject(event.target.error || tx.error); };
+          tx.onabort = function (event) { reject(event.target.error || tx.error); };
+        });
+      });
+    };
+  }
+
+  return Object.freeze({ createSessionClaimer: createSessionClaimer });
+});

package/extension/src/shared/updateConsent.js

@@ -87,6 +87,10 @@
       authorizedVersion: safeVersion(value.authorizedVersion),
       authorizationId: safeId(value.authorizationId),
       authorizedAt: finiteNumber(value.authorizedAt),
+      revokingAuthorizationId: safeId(value.revokingAuthorizationId),
+      revokingVersion: safeVersion(value.revokingVersion),
+      revokingTransactionId: safeId(value.revokingTransactionId),
+      revokingAt: finiteNumber(value.revokingAt),
       lastPromptedVersion: safeVersion(value.lastPromptedVersion),
       lastPromptedAt: finiteNumber(value.lastPromptedAt)
     };

package/extension/src/shared/updateRevocationIntent.js

@@ -0,0 +1,109 @@
+(function initUpdateRevocationIntent(root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) {
+    module.exports = api;
+  }
+  if (root) {
+    root.CodexOverleafUpdateRevocation = api;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : this, function createUpdateRevocationIntent() {
+  "use strict";
+
+  function safeString(value) {
+    return typeof value === "string" ? value.trim() : "";
+  }
+
+  function safeTime(value, fallback = 0) {
+    return Number.isFinite(value) && value >= 0 ? value : fallback;
+  }
+
+  function begin(consentState, updateState, now = Date.now()) {
+    const consent = consentState && typeof consentState === "object" ? consentState : {};
+    const update = updateState && typeof updateState === "object" ? updateState : {};
+    return {
+      ...consent,
+      revokingAuthorizationId: safeString(consent.authorizationId),
+      revokingVersion:
+        safeString(consent.authorizedVersion) || safeString(update.latestVersion),
+      revokingTransactionId: safeString(update.transactionId),
+      revokingAt: safeTime(now)
+    };
+  }
+
+  function prepareAuthorization(consentState, authorizationId, targetVersion, now = Date.now()) {
+    const consent = consentState && typeof consentState === "object" ? consentState : {};
+    return {
+      ...consent,
+      revokingAuthorizationId: safeString(authorizationId),
+      revokingVersion: safeString(targetVersion),
+      revokingTransactionId: "",
+      revokingAt: safeTime(now)
+    };
+  }
+
+  function hasPending(consentState) {
+    const consent = consentState && typeof consentState === "object" ? consentState : {};
+    return Boolean(
+      safeString(consent.revokingAuthorizationId) &&
+        safeString(consent.revokingVersion)
+    );
+  }
+
+  function clear(consentState) {
+    const consent = consentState && typeof consentState === "object" ? consentState : {};
+    return {
+      ...consent,
+      revokingAuthorizationId: "",
+      revokingVersion: "",
+      revokingTransactionId: "",
+      revokingAt: 0
+    };
+  }
+
+  function complete(updateState, consentState, options = {}) {
+    const update = updateState && typeof updateState === "object" ? updateState : {};
+    const consent = consentState && typeof consentState === "object" ? consentState : {};
+    const now = safeTime(options.now, Date.now());
+    const snoozeMs = safeTime(options.snoozeMs);
+    const version =
+      safeString(consent.revokingVersion) ||
+      safeString(consent.authorizedVersion) ||
+      safeString(update.latestVersion);
+    return {
+      updateState: {
+        ...update,
+        state: "update_available",
+        transactionId: "",
+        stagedPath: "",
+        stagedAt: 0,
+        applyingAt: 0,
+        awaitingHealthAt: 0,
+        blocker: "",
+        blockers: [],
+        blockingReason: "",
+        code: "",
+        message: "",
+        error: null,
+        postponeUntil: safeTime(options.postponeUntil),
+        postponeGuardVersion: version
+      },
+      consentState: clear({
+        ...consent,
+        mode: "snoozed",
+        snoozedVersion: version,
+        snoozedUntil: now + snoozeMs,
+        authorizedVersion: "",
+        authorizationId: "",
+        authorizedAt: 0
+      })
+    };
+  }
+
+  return Object.freeze({
+    begin,
+    prepareAuthorization,
+    hasPending,
+    clear,
+    complete
+  });
+});