codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/backgroundBootstrapMigration.js

@@ -0,0 +1,181 @@
+(function initBootstrapMigration(root) {
+  'use strict';
+
+  const UPDATE_STATE_KEY = 'codex-overleaf-managed-update-state-v1';
+  const RETRY_ALARM = 'codex-overleaf-bootstrap-migration-retry';
+  const RETRY_MS = 4000;
+  const MAX_WAIT_MS = 2 * 60 * 1000;
+  let readyPromise;
+  let lockedOwner;
+  let setExecutionLocked;
+
+  function init(options) {
+    if (readyPromise) return readyPromise;
+    readyPromise = prepare(options);
+    return readyPromise;
+  }
+
+  async function prepare(options) {
+    let transaction;
+    let reloadProtected = false;
+    let rollbackState = 'bootstrap_pending';
+    const revision = String(root.__CODEX_OVERLEAF_BOOTSTRAP_REVISION__ || '');
+    const request = async (method, params = {}) => {
+      const response = await options.request({ id: crypto.randomUUID(), method,
+        params: { ...params, bootstrapRevision: revision } });
+      if (!response?.ok) throw Object.assign(new Error(response?.error?.message || 'Managed update request failed.'),
+        { code: response?.error?.code || 'update_health_failed' });
+      return response.result || {};
+    };
+    try {
+      const status = await request('update.status');
+      transaction = status.transaction;
+      if (transaction?.state !== 'bootstrap_pending') return { continueInitialization: true };
+      options.setExecutionLocked(true);
+      lockedOwner = { id: transaction.id, targetVersion: transaction.targetVersion, revision };
+      setExecutionLocked = options.setExecutionLocked;
+      if (!transaction.id || transaction.targetVersion !== root.CodexOverleafCompatibility?.BUILD_TARGET_VERSION) {
+        throw codedError('The running update does not match the pending Bootstrap transaction.');
+      }
+      reloadProtected = await options.protectReloadTabs(transaction);
+      if (!reloadProtected) throw codedError('The previous page refresh list could not be protected.');
+      await writeState({ state: 'awaiting_health', transactionId: transaction.id,
+        latestVersion: transaction.targetVersion, code: '', message: '' });
+
+      // The first reload may leave old content contexts alive. Recheck the same
+      // idle/save contract before replacing their loader and reloading again.
+      const deadline = Date.now() + MAX_WAIT_MS;
+      while (true) {
+        const gate = await options.verifySafety({ transactionId: transaction.id, targetVersion: transaction.targetVersion,
+          sourceVersion: transaction.sourceVersion, expectedState: 'bootstrap_pending' });
+        if (gate?.ok) break;
+        if (Date.now() >= deadline) throw codedError('The Bootstrap update did not reach a safe point.');
+        await writeState({ blockers: gate?.error?.blockers || ['busy'] });
+        await waitForRetry();
+        const refreshed = await request('update.status');
+        if (refreshed.transaction?.id !== transaction.id || refreshed.transaction?.state !== 'bootstrap_pending') {
+          throw Object.assign(codedError('The pending Bootstrap transaction changed before activation.'), { restoredStatus: refreshed });
+        }
+      }
+
+      const result = await request('update.bootstrap', { transactionId: transaction.id });
+      if (result.transactionId !== transaction.id || result.targetVersion !== transaction.targetVersion) {
+        throw codedError('The Bootstrap activation result does not match the pending update.');
+      }
+      await writeState({ blockers: [], blocker: '' });
+      if (result.state === 'reload_required') {
+        // Only one reload per worker. Native owns the persistent attempt limit
+        // so a broken target cannot create a loop across worker restarts.
+        chrome.runtime.reload();
+        return { continueInitialization: false, state: result.state };
+      }
+      if (result.state !== 'awaiting_health' || revision !== '3.1' || result.bootstrapRevision !== revision) {
+        throw codedError('The updated Bootstrap did not provide its loaded revision.');
+      }
+      rollbackState = 'awaiting_health';
+      if (!await options.releaseReloadTabs(transaction, 'awaiting_health')) throw codedError('The original page identities could not be confirmed.');
+      return { continueInitialization: true, state: result.state };
+    } catch (error) {
+      if (!transaction || transaction.state !== 'bootstrap_pending') return { continueInitialization: true };
+      if (!reloadProtected) {
+        await writeState({ state: 'failed', recoveryPending: true, code: 'update_recovery_pending' }).catch(() => {});
+        return { continueInitialization: false, state: 'failed' };
+      }
+      const code = /^[a-z0-9_]{1,80}$/.test(error?.code || '') ? error.code : 'update_health_failed';
+      await writeState({ state: 'rolling_back', code }).catch(() => {});
+      let restored = false;
+      try {
+        let status = error.restoredStatus;
+        let rollback = status && { transactionId: status.transaction?.id, state: status.transaction?.state,
+          version: status.activeVersion, restoredPair: status.restoredPair };
+        if (!hasRestoredSource(transaction, rollback, status)) {
+          rollback = await request('update.rollback', { transactionId: transaction.id,
+            expectedState: rollbackState, reasonCode: code });
+          status = await request('update.status');
+        }
+        if (!hasRestoredSource(transaction, rollback, status)) throw codedError('Bootstrap rollback is unconfirmed.');
+        await writeState({ state: 'rolled_back', currentVersion: transaction.sourceVersion,
+          transactionId: transaction.id, recoveryPending: false, blockers: [], blocker: '', code });
+        restored = true;
+        while (true) {
+          try {
+            // A new document must never inherit the old document's refresh
+            // authorization. The source worker sees an empty legacy list;
+            // the guarded evidence remains for a later natural/user refresh.
+            if (await options.hasReplacedReloadDocument(transaction)) break;
+            const gate = await options.verifySafety({ transactionId: transaction.id, targetVersion: transaction.targetVersion,
+              sourceVersion: transaction.sourceVersion, expectedState: 'rolled_back' });
+            if (gate?.ok && await options.releaseReloadTabs(transaction, 'rolled_back')) break;
+          } catch (_) { /* Restored files stay restored while a page probe retries. */ }
+          await waitForRetry();
+        }
+        chrome.runtime.reload();
+        return { continueInitialization: false, state: 'rolled_back' };
+      } catch (_rollbackError) {
+        if (restored) return { continueInitialization: false, state: 'rolled_back' };
+        await writeState({ state: 'failed', recoveryPending: true, transactionId: transaction.id,
+          code: 'update_recovery_pending', message: 'The installed update result has not been confirmed.' }).catch(() => {});
+        return { continueInitialization: false, state: 'failed' };
+      }
+    } finally {
+      await chrome.alarms?.clear?.(RETRY_ALARM).catch?.(() => {});
+    }
+  }
+
+  async function writeState(patch) {
+    const stored = await chrome.storage.local.get(UPDATE_STATE_KEY);
+    const state = root.CodexOverleafManagedUpdateProjection.transition(stored[UPDATE_STATE_KEY] || {}, patch,
+      { currentVersion: chrome.runtime.getManifest().version });
+    await chrome.storage.local.set({ [UPDATE_STATE_KEY]: state });
+  }
+
+  function waitForRetry() {
+    return new Promise(resolve => {
+      let settled = false;
+      let timer;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        chrome.alarms?.onAlarm?.removeListener?.(onAlarm);
+        resolve();
+      };
+      const onAlarm = alarm => { if (alarm?.name === RETRY_ALARM) finish(); };
+      chrome.alarms?.onAlarm?.addListener?.(onAlarm);
+      chrome.alarms?.create?.(RETRY_ALARM, { delayInMinutes: 0.5 });
+      timer = setTimeout(finish, RETRY_MS);
+    });
+  }
+
+  function hasRestoredSource(transaction, rollback, status) {
+    const pair = status?.restoredPair;
+    return rollback?.transactionId === transaction.id && rollback.state === 'rolled_back'
+      && rollback.version === transaction.sourceVersion && status?.transaction?.id === transaction.id
+      && status.transaction.state === 'rolled_back' && status.activeVersion === transaction.sourceVersion
+      && status.installedAligned === true && pair?.extensionVersion === transaction.sourceVersion
+      && pair?.nativeVersion === transaction.sourceVersion
+      && /^[0-9a-f]{64}$/.test(pair.extensionSha256 || '') && /^[0-9a-f]{64}$/.test(pair.nativeSha256 || '')
+      && /^[0-9a-f]{64}$/.test(pair.bootstrapSha256 || '')
+      && ['extensionVersion', 'nativeVersion', 'extensionSha256', 'nativeSha256', 'bootstrapSha256']
+        .every(key => pair[key] === rollback.restoredPair?.[key]);
+  }
+
+  function codedError(message) {
+    return Object.assign(new Error(message), { code: 'update_health_failed' });
+  }
+
+  function observeConfirmation(params, response) {
+    if (!lockedOwner || !response?.ok || response.result?.state !== 'committed'
+      || response.result.version !== lockedOwner.targetVersion || params?.transactionId !== lockedOwner.id
+      || params.extensionVersion !== lockedOwner.targetVersion || params.nativeVersion !== lockedOwner.targetVersion
+      || params.bootstrapRevision !== lockedOwner.revision || lockedOwner.revision !== '3.1') return;
+    lockedOwner = null;
+    setExecutionLocked(false);
+  }
+
+  root.CodexOverleafBootstrapMigration = Object.freeze({
+    init,
+    observeConfirmation,
+    ready: () => readyPromise || Promise.resolve({ continueInitialization: true })
+  });
+})(globalThis);

package/extension/src/backgroundSharedSessions.js

@@ -1,11 +1,13 @@
 (function (root, factory) {
-  const api = factory();
+  const api = factory(typeof module === 'object' && module.exports
+    ? require('./shared/sharedSessionTransfer') : root.CodexOverleafSharedSessionTransfer);
   if (typeof module === 'object' && module.exports) module.exports = api;
   if (root) root.CodexOverleafSharedSessionsBackground = api;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (Transfer) {
   'use strict';
   const MESSAGE = 'codex-overleaf/shared-sessions-v1';
   const LOCK_PORT = 'codex-overleaf/shared-session-lock-v1';
+  const REVIEW_LEASE_PREFIX = 'codex-overleaf-review-lease-v1:';
   const CHANGE_KEY = 'codex-overleaf-shared-sessions-changed-v1';
   const HOSTS = ['overleaf.com', 'www.overleaf.com', 'cn.overleaf.com'];
   const META_PREFIX = 'codex-overleaf-scoped-persistence-v1:';
@@ -14,16 +16,18 @@
   const clone = value => value === undefined ? undefined : JSON.parse(JSON.stringify(value));
   const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
   const failure = (code, message) => Object.assign(new Error(message), { code });
+  const conflict = () => failure('shared_session_conflict', 'The same session was edited in another tab. Refresh its history before retrying; the local draft was kept.');
   function part(value) {
     if (typeof value !== 'string' || !value.trim() || value.length > 256 || /[\0\r\n]/.test(value))
       throw failure('shared_store_scope_invalid', 'The shared session identity is invalid.');
     return value;
   }
   function scope(input) {
-    return { accountScopeId: part(input?.accountScopeId), projectId: typeof input?.projectId === 'string' ? input.projectId : '' };
+    return { accountScopeId: part(input?.accountScopeId), projectId: typeof input?.projectId === 'string' ? input.projectId : '', ...(input?.runId ? { runId: part(input.runId) } : {}) };
   }
   function keyFor(kind, value) {
-    return kind === 'preferences' ? 'preferences'
+    return kind === 'review' ? 'review:' + JSON.stringify([value.accountScopeId, part(value.projectId), part(value.runId)])
+      : kind === 'preferences' ? 'preferences'
       : 'state:' + encodeURIComponent(value.accountScopeId);
   }
   function metaKey(value) {
@@ -68,7 +72,59 @@
       }
       return result;
     }
-    throw failure('shared_session_conflict', 'The same session was edited in another tab. Refresh its history before retrying; the local draft was kept.');
+    throw conflict();
+  }
+
+  function titleValue(record) {
+    return { title: record.title || '', titleSource: record.titleSource === 'manual' ? 'manual' : 'auto' };
+  }
+  function manualTitleChange(base, next) {
+    return next.titleSource === 'manual' ? next.title !== base.title : base.titleSource === 'manual';
+  }
+  function mergeTitle(base, current, incoming) {
+    const before = titleValue(base), stored = titleValue(current), proposed = titleValue(incoming);
+    if (equal(proposed, before)) return stored;
+    if (equal(stored, before) || equal(stored, proposed)) return proposed;
+    // Auto derivations (including legacy normalization) carry no rename intent.
+    if (!manualTitleChange(before, proposed)) return stored;
+    if (!manualTitleChange(before, stored)) return proposed;
+    // The pair is one intent; merging its scalar members separately could
+    // combine a peer rename with this page's reset to auto.
+    throw conflict();
+  }
+  function draftConsumption(record) {
+    const marker = record.draftConsumption;
+    return record.task === '' && typeof marker?.task === 'string' && marker.task
+      && typeof marker.runId === 'string' && marker.runId
+      && (record.runs || []).some(run => run.id === marker.runId && !run.forkSnapshot
+        && run.runProjectId === record.projectId) ? marker : null;
+  }
+  function mergeSession(base, current, incoming) {
+    const currentConsumption = draftConsumption(current), incomingConsumption = draftConsumption(incoming);
+    const consumed = marker => marker && marker.task === base.task && !equal(marker, base.draftConsumption);
+    let task;
+    if (equal(incoming.task, base.task)) task = current.task;
+    else if (equal(current.task, base.task) || equal(current.task, incoming.task)) task = incoming.task;
+    else if (consumed(incomingConsumption)) task = current.task;
+    else if (consumed(currentConsumption)) task = incoming.task;
+    else task = mergeValue(base.task, current.task, incoming.task, 'task');
+
+    const result = { ...mergeTitle(base, current, incoming) };
+    if (task !== undefined) result.task = clone(task);
+    // Summaries are derived metadata, never a second draft edit. Prefer the
+    // stored summary when both sides have the winning task (including legacy forms).
+    const taskOwner = equal(task, current.task) ? current : incoming;
+    if (taskOwner.safeTaskSummary !== undefined) result.safeTaskSummary = clone(taskOwner.safeTaskSummary);
+    if (task === '' && (incomingConsumption || currentConsumption))
+      result.draftConsumption = clone(consumed(incomingConsumption)
+        ? incomingConsumption : currentConsumption || incomingConsumption);
+    const derived = new Set(['title', 'titleSource', 'task', 'safeTaskSummary', 'draftConsumption', 'sharedRevision']);
+    for (const key of new Set([...Object.keys(base), ...Object.keys(current), ...Object.keys(incoming)])) {
+      if (derived.has(key)) continue;
+      const value = mergeValue(base[key], current[key], incoming[key], key);
+      if (value !== undefined) Object.defineProperty(result, key, { value, enumerable: true, configurable: true, writable: true });
+    }
+    return result;
   }
 
   function createService(options = {}) {
@@ -137,7 +193,7 @@
           const stored = item.value;
           if (value.projectId && stored.projectId !== value.projectId) { item.continue(); return; }
           const record = { ...stored.record, sharedRevision: stored.revision };
-          const size = JSON.stringify(record).length * 2;
+          const size = Transfer.byteLength(JSON.stringify(record));
           if (result.length && (result.length >= 8 || bytes + size > MAX_BYTES)) {
             resolve({ records: result, next: last }); return;
           }
@@ -162,10 +218,9 @@
           appliedOperations: [], trackedChangeCaptures: [], undoStatus: '' })) };
     }
     async function writeMany(message, value, importing, origin, sender) {
-      const entries = (importing ? [{ record: message.record }] : message.entries || [])
-        .map(entry => ({ record: clone(entry.record), base: clone(entry.base) }));
-      if (JSON.stringify(entries).length * 2 > MAX_BYTES * 3)
-        throw failure('shared_session_too_large', 'The session batch exceeds the shared storage transfer limit.');
+      // Reject a lost owner before doing any bounded decompression work.
+      ensureLock(message, value, sender);
+      const entries = (await Transfer.decode(message)).map(entry => ({ record: clone(entry.record), base: clone(entry.base) }));
       for (const { record, base } of entries) {
         if (!record || record.accountScopeId !== value.accountScopeId || record.projectId !== value.projectId)
           throw failure('shared_store_scope_mismatch', 'The session does not belong to the captured account and project.');
@@ -197,6 +252,14 @@
             putAt(entry.record, entry.base);
           }
         };
+        function appendResult(record, revision) {
+          // Merge may grow beyond either input. Reject inside this transaction,
+          // before returning success or committing any sibling record.
+          Transfer.validateRecord(record);
+          const result = { ...record, sharedRevision: revision };
+          Transfer.validateResponse([...results, result]);
+          results.push(result);
+        }
         function putAt(candidate, base, copy = false) {
           const key = [value.accountScopeId, candidate.id];
           const tombstone = deleted.get(key);
@@ -214,7 +277,7 @@
                 let next = candidate;
                 if (importing && existing) {
                   if (equal(existing.record, candidate) || copy) {
-                    results.push({ ...existing.record, sharedRevision: existing.revision }); return;
+                    appendResult(existing.record, existing.revision); return;
                   }
                   putAt(recoveryCopy(candidate, origin), null, true); return;
                 }
@@ -222,14 +285,14 @@
                   if (!base) throw failure('shared_session_conflict', 'Reload the session before updating existing history.');
                   // Keep the established first-durable-review-decision policy.
                   const reviewed = options.mergeSessionReviewState?.(candidate, existing.record, message.reviewRunIds || []) || candidate;
-                  next = mergeValue(base, existing.record, reviewed);
+                  next = mergeSession(base, existing.record, reviewed);
                 } else if (base && !importing) {
                   throw failure('shared_session_deleted', 'The session no longer exists.');
                 }
                 const revision = (existing?.revision || 0) + 1;
+                appendResult(next, revision);
                 store.put({ accountScopeId: value.accountScopeId, projectId: value.projectId,
                   id: next.id, record: next, revision });
-                results.push({ ...next, sharedRevision: revision });
               } catch (error) { abort(error); }
             };
           };
@@ -264,9 +327,41 @@
       }
       await done;
     }
+    const reviewLeaseKey = (key, token) => REVIEW_LEASE_PREFIX + key + ':' + token;
+    async function activeReviewLease(key) {
+      const prefix = REVIEW_LEASE_PREFIX + key + ':', records = await chromeApi.storage.local.get(null);
+      const active = [], expired = [];
+      for (const [id, lease] of Object.entries(records)) {
+        if (!id.startsWith(prefix)) continue;
+        const valid = lease && typeof lease.token === 'string' && lease.token.length > 0 && lease.token.length <= 256
+          && id === reviewLeaseKey(key, lease.token) && Number.isSafeInteger(lease.deadlineAt) && lease.deadlineAt > 0;
+        if (!valid) throw failure('review_lease_invalid', 'Undo ownership storage could not be verified.');
+        if (lease.deadlineAt > Date.now()) active.push(lease); else expired.push(id);
+      }
+      // Immutable token rows can only be removed by their exact expired key.
+      await Promise.all(expired.map(id => chromeApi.storage.local.remove(id).catch(() => {})));
+      return active.sort((a, b) => b.deadlineAt - a.deadlineAt)[0];
+    }
     async function handle(message, sender) {
       const origin = senderOrigin(sender), value = scope(message.scope);
       const method = message.method;
+      if (method === 'review-dispatched') {
+        const key = keyFor('review', { ...value, runId: part(message.runId) }), held = locks.get(key);
+        if (!held || held.disconnected || held.token !== message.reviewToken || held.tabId !== sender.tab.id)
+          throw failure('storage_lock_lost', 'The shared Undo owner was lost before dispatch.');
+        const deadlineAt = held.deadlineAt || (held.deadlineAt = Date.now() + 120000);
+        held.inFlight += 1;
+        try {
+          await chromeApi.storage.local.set({ [reviewLeaseKey(key, held.token)]: { token: held.token, deadlineAt } });
+          if (held.disconnected) throw failure('storage_lock_lost', 'The shared Undo owner disconnected before dispatch.');
+          return { deadlineAt };
+        } finally { held.inFlight -= 1; if (held.disconnected && !held.inFlight) held.release(); }
+      }
+      if (method === 'review-owner') {
+        const key = keyFor('review', { ...value, runId: part(message.runId) });
+        const lease = await activeReviewLease(key);
+        return { busy: locks.has(key) || lease?.deadlineAt > Date.now(), deadlineAt: lease?.deadlineAt || 0 };
+      }
       if (method === 'list') return list(value, typeof message.after === 'string' ? message.after : '');
       if (method === 'get') {
         const record = await readOne('sessions', [value.accountScopeId, part(message.id)]);
@@ -284,7 +379,7 @@
         tx.objectStore('migrations').put({ ...value, origin, complete: true, at: Date.now() });
         await done; return { complete: true };
       }
-      if (method === 'put' || method === 'import') {
+      if (method === 'put' || method === 'put-compressed' || method === 'import') {
         const result = await writeMany(message, value, method === 'import', origin, sender);
         if (result.length) await notify(value, message.clientId);
         return result;
@@ -327,12 +422,30 @@
         queues.delete(key);
       }
       port.onMessage.addListener(message => {
+        if (message?.type === 'release-review') {
+          const held = locks.get(heldKey);
+          if (held?.port !== port || held.token !== message.token || !heldKey.startsWith('review:')) return;
+          held.inFlight += 1;
+          void chromeApi.storage.local.remove(reviewLeaseKey(heldKey, held.token)).then(() => {
+            held.inFlight -= 1; held.release(); if (!closed) port.postMessage({ type: 'released' });
+          }, () => { held.inFlight -= 1; port.disconnect(); if (held.disconnected && !held.inFlight) held.release(); });
+          return;
+        }
         if (message?.type === 'ping') { port.postMessage({ type: 'pong' }); return; }
         if (message?.type !== 'acquire' || job) return;
         try {
-          const value = scope(message.scope), kind = message.kind === 'preferences' ? 'preferences' : 'state';
+          const value = scope(message.scope), kind = message.kind === 'review' ? 'review' : message.kind === 'preferences' ? 'preferences' : 'state';
           heldKey = keyFor(kind, value);
-          job = { port, tabId: port.sender.tab.id, closed: () => closed, grant: token => port.postMessage({ type: 'granted', token }) };
+          if (kind === 'review' && locks.has(heldKey)) { port.postMessage({ type: 'busy' }); return; }
+          job = { port, tabId: port.sender.tab.id, closed: () => closed, grant: token => {
+            if (kind !== 'review') { port.postMessage({ type: 'granted', token }); return; }
+            const held = locks.get(heldKey); held.inFlight += 1;
+            void (async () => {
+              const existing = await activeReviewLease(heldKey);
+              if (existing?.deadlineAt > Date.now()) { locks.get(heldKey)?.release(); if (!closed) port.postMessage({ type: 'busy' }); return; }
+              if (!closed) port.postMessage({ type: 'granted', token });
+            })().catch(() => port.disconnect()).finally(() => { held.inFlight -= 1; if (held.disconnected && !held.inFlight) held.release(); });
+          } };
           if (!queues.has(heldKey)) queues.set(heldKey, []);
           queues.get(heldKey).push(job);
           pump(heldKey);