codex-overleaf-link 2.2.1 → 2.3.1

package/extension/src/content/runTimelineView.js

@@ -1,7 +1,6 @@
 (function initCodexOverleafRunTimelineView() {
   'use strict';
 
-  const RunGuidanceView = window.CodexOverleafRunGuidanceView;
   // Run-timeline view — the timeline render pipeline carved out of
   // contentRuntime.js (v1.4.6 structural-debt phase 2): the scroll engine +
   // jump-to-latest button, the live-elapsed tick and collapsed-header summary,
@@ -13,6 +12,7 @@
   // that owns it.
   function create(deps = {}) {
     const {
+      RunGuidanceView,
       tr,
       tx,
       getLocale,
@@ -40,7 +40,8 @@
       showNativeSetupGuidance,
       openProjectFileForFailure,
       openStorageSettings,
-      trackedChangeInFlight
+      trackedChangeInFlight,
+      projectRunSettlement
     } = deps;
 
   let logAutoFollow = true;
@@ -273,6 +274,9 @@
     if (status === 'failed') {
       return tr('processedFailed', { elapsed });
     }
+    if (status === 'rejected' || status === 'cancelled') {
+      return tr('processedCancelled', { elapsed });
+    }
     if (status === 'running') {
       return tr('processing', { elapsed });
     }
@@ -410,6 +414,9 @@
     if (run.startedAt && run.finishedAt) {
       return formatProcessedSummary(run.status || 'completed', new Date(run.finishedAt).getTime() - new Date(run.startedAt).getTime());
     }
+    if (run.status === 'rejected' || run.status === 'cancelled') {
+      return tx('Cancelled', '已取消');
+    }
     return run.status === 'failed' ? tx('Failed', '处理失败') : tx('Done', '已处理');
   }
 
@@ -884,8 +891,8 @@
       return;
     }
 
-    const undoCount = getRunUndoCount(run);
-    if (!undoCount && run.undoStatus !== 'applied') {
+    const projection = projectRunSettlement(run);
+    if (!projection.canUndo && run.undoStatus !== 'applied') {
       button.hidden = true;
       return;
     }
@@ -912,13 +919,14 @@
   // same executable state as `pending`.
   function configureLifecycleUndoButton(button, run) {
     const status = run.trackedChangeStatus || '';
+    const projection = projectRunSettlement(run);
     // §7 settlement matrix: needs_review keeps BOTH controls visible AND
     // actionable. Branch placed before the terminal branches so a
     // needs_review run is never treated as terminal.
     if (status === 'needs_review') {
       const inFlight = trackedChangeInFlight.get(run.id);
       button.hidden = false;
-      button.disabled = inFlight === 'reject' || inFlight === 'accept';
+      button.disabled = !projection.canUndo || inFlight === 'reject' || inFlight === 'accept';
       button.textContent = tr('undoRun');
       button.title = tr('undoRunTitle');
       button.addEventListener('click', event => {
@@ -949,7 +957,7 @@
     }
     const inFlight = trackedChangeInFlight.get(run.id);
     button.hidden = false;
-    button.disabled = inFlight === 'reject' || inFlight === 'accept';
+    button.disabled = !projection.canUndo || inFlight === 'reject' || inFlight === 'accept';
     button.textContent = tr('undoRun');
     button.title = tr('undoRunTitle');
     button.addEventListener('click', event => {
@@ -980,13 +988,14 @@
     }
 
     const status = run.trackedChangeStatus || '';
+    const projection = projectRunSettlement(run);
     // §7 settlement matrix: needs_review keeps BOTH controls visible AND
     // actionable. It remains an internal retryable proof state, while the
     // primary button label stays in the same executable state as `pending`.
     if (status === 'needs_review') {
       const inFlight = trackedChangeInFlight.get(run.id);
       button.hidden = false;
-      button.disabled = inFlight === 'accept' || inFlight === 'reject';
+      button.disabled = !projection.canAccept || inFlight === 'accept' || inFlight === 'reject';
       if (inFlight === 'accept') {
         button.textContent = tr('runAcceptTrackedConfirming');
         button.title = tr('runAcceptTrackedConfirming');
@@ -1020,7 +1029,7 @@
 
     const inFlight = trackedChangeInFlight.get(run.id);
     button.hidden = false;
-    button.disabled = inFlight === 'accept' || inFlight === 'reject';
+    button.disabled = !projection.canAccept || inFlight === 'accept' || inFlight === 'reject';
     if (inFlight === 'accept') {
       button.textContent = tr('runAcceptTrackedConfirming');
       button.title = tr('runAcceptTrackedConfirming');

package/extension/src/content/scopedPersistenceCoordinator.js

@@ -0,0 +1,100 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(
+      require('./scopedPersistencePanelState'),
+      require('./scopedPersistenceDetachedCommit')
+    );
+  } else {
+    root.CodexOverleafModuleRegistry.define(
+      'ScopedPersistenceCoordinator',
+      ['ScopedPersistencePanelState', 'ScopedPersistenceDetachedCommit'],
+      factory
+    );
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (PanelState, DetachedCommit) {
+  'use strict';
+
+  function createController(options) {
+    options = options || {};
+    var Transaction = options.Transaction;
+    if (!Transaction || typeof Transaction.createCoordinator !== 'function') return null;
+    var writerId = getStableWriterId(options.sessionStorage);
+    var coordinator = Transaction.createCoordinator({
+      adapter: Transaction.createBrowserAdapter({ chromeApi: options.chromeApi }),
+      writerId: writerId
+    });
+    var commitDetached = (options.DetachedCommit || DetachedCommit)?.create?.({
+      Transaction: Transaction, chromeApi: options.chromeApi, writerId: writerId
+    });
+    var activeScope = null;
+
+    function scope(projectId) {
+      var accountScopeId = '';
+      try {
+        accountScopeId = typeof options.getAccountScopeId === 'function'
+          ? options.getAccountScopeId() || ''
+          : '';
+      } catch (_error) {
+        accountScopeId = '';
+      }
+      return { accountScopeId: accountScopeId, projectId: projectId };
+    }
+
+    return Object.freeze({
+      async beginHydration(projectId) {
+        var nextScope = scope(projectId);
+        if (!nextScope.accountScopeId) {
+          activeScope = null;
+          return null;
+        }
+        var token = await coordinator.beginHydration(nextScope);
+        if (coordinator.isCurrent(token)) activeScope = nextScope;
+        return token;
+      },
+      isCurrent: coordinator.isCurrent,
+      async commit(projectId, commitOptions, action) {
+        var nextScope = scope(projectId);
+        if (!nextScope.accountScopeId) {
+          return { ok: false, reason: 'account_scope_unavailable' };
+        }
+        if (!activeScope
+          || activeScope.accountScopeId !== nextScope.accountScopeId
+          || activeScope.projectId !== nextScope.projectId) {
+          var hydration = await coordinator.beginHydration(nextScope);
+          if (!coordinator.isCurrent(hydration)) {
+            return { ok: false, reason: 'stale_view' };
+          }
+          activeScope = nextScope;
+        }
+        var view = await coordinator.captureCommitView(nextScope, {
+          detached: Boolean(commitOptions && commitOptions.detached)
+        });
+        return coordinator.commit(view, action, {
+          rebase: !commitOptions || commitOptions.rebase !== false,
+          queueMutation: commitOptions && commitOptions.queueMutation,
+          queueMutations: commitOptions && commitOptions.queueMutations,
+          sessionTombstones: commitOptions && commitOptions.sessionTombstones
+        });
+      },
+      commitDetached: commitDetached
+    });
+  }
+  function getStableWriterId(storage) {
+    var key = 'codex-overleaf-scoped-writer-id';
+    try {
+      var existing = storage?.getItem?.(key);
+      if (existing) return existing;
+      var created = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+        ? crypto.randomUUID()
+        : 'writer-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
+      storage?.setItem?.(key, created);
+      return created;
+    } catch (_error) {
+      return '';
+    }
+  }
+  return Object.freeze({
+    createController: createController,
+    persistPanelState: PanelState?.persistPanelState || null
+  });
+});

package/extension/src/content/scopedPersistenceDetachedCommit.js

@@ -0,0 +1,47 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafScopedPersistenceDetachedCommit = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function create(options) {
+    options = options || {};
+    var Transaction = options.Transaction;
+    if (!Transaction
+      || typeof Transaction.createBrowserAdapter !== 'function'
+      || typeof Transaction.createCoordinator !== 'function') {
+      return null;
+    }
+    var adapter = Transaction.createBrowserAdapter({ chromeApi: options.chromeApi });
+    return async function commitDetached(projectId, accountScopeId, commitOptions, action) {
+      var nextScope = {
+        accountScopeId: String(accountScopeId || '').trim(),
+        projectId: String(projectId || '').trim()
+      };
+      if (!nextScope.accountScopeId) {
+        return { ok: false, reason: 'account_scope_unavailable' };
+      }
+      if (!nextScope.projectId) {
+        return { ok: false, reason: 'project_scope_unavailable' };
+      }
+      var coordinator = Transaction.createCoordinator({
+        adapter: adapter,
+        writerId: options.writerId
+      });
+      var hydration = await coordinator.beginHydration(nextScope);
+      if (!coordinator.isCurrent(hydration)) {
+        return { ok: false, reason: 'stale_view' };
+      }
+      var view = await coordinator.captureCommitView(nextScope, { detached: true });
+      return coordinator.commit(view, action, {
+        rebase: !commitOptions || commitOptions.rebase !== false,
+        queueMutation: commitOptions && commitOptions.queueMutation,
+        queueMutations: commitOptions && commitOptions.queueMutations,
+        sessionTombstones: commitOptions && commitOptions.sessionTombstones
+      });
+    };
+  }
+
+  return Object.freeze({ create: create });
+});

package/extension/src/content/scopedPersistencePanelState.js

@@ -0,0 +1,111 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafScopedPersistencePanelState = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function cloneSnapshot(value) {
+    if (!value || typeof value !== 'object') {
+      return value;
+    }
+    if (typeof structuredClone === 'function') {
+      return structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value));
+  }
+
+  async function persistPanelState(input) {
+    var state = cloneSnapshot(input.state || {});
+    var compactState = cloneSnapshot(input.compactState || {});
+    var projectId = input.projectId;
+    var Migration = input.Migration;
+    var StorageDb = input.StorageDb;
+    var scope = input.persistenceContext?.scope || {};
+    var accountScopeId = typeof scope.accountScopeId === 'string'
+      ? scope.accountScopeId.trim()
+      : '';
+    if (!accountScopeId) {
+      throw Object.assign(new Error('Scoped persistence requires an account identity.'), {
+        code: 'account_scope_unavailable'
+      });
+    }
+    if (scope.projectId !== projectId) {
+      throw Object.assign(new Error('Scoped persistence project changed before commit.'), {
+        code: 'stale_view'
+      });
+    }
+    var latestPrefs = typeof Migration.loadPrefs === 'function'
+      ? await Migration.loadPrefs(accountScopeId, projectId)
+      : {};
+    var prefs = Object.assign(
+      {},
+      latestPrefs && typeof latestPrefs === 'object' ? latestPrefs : {},
+      StorageDb.extractLightweightPrefs(compactState, projectId)
+    );
+    prefs.activeSessionByProject = StorageDb.buildActiveSessionByProject(
+      latestPrefs && latestPrefs.activeSessionByProject || {},
+      projectId,
+      compactState.activeSessionId || state.activeSessionId || ''
+    );
+    prefs.experimentalOtByProject = Object.assign(
+      {},
+      latestPrefs && latestPrefs.experimentalOtByProject || {},
+      { [projectId]: input.normalizeExperimentalOtByProject(state.experimentalOtByProject)[projectId] === true }
+    );
+    prefs.governanceRulesByProject = Object.assign(
+      {},
+      latestPrefs && latestPrefs.governanceRulesByProject || {},
+      input.normalizeGovernanceRulesByProject(state.governanceRulesByProject)
+    );
+    var normalizedCustomProject = input.normalizeCustomInstructionsByProject({ [projectId]: '' });
+    var customProjectId = Object.keys(normalizedCustomProject)[0] || '';
+    var currentCustom = input.normalizeCustomInstructionsByProject(state.customInstructionsByProject);
+    prefs.customInstructionsByProject = Object.assign(
+      {},
+      latestPrefs && latestPrefs.customInstructionsByProject || {}
+    );
+    if (customProjectId) {
+      prefs.customInstructionsByProject[customProjectId] =
+        Object.prototype.hasOwnProperty.call(currentCustom, customProjectId)
+          ? currentCustom[customProjectId]
+          : '';
+    }
+    await Migration.savePrefs(prefs, accountScopeId, projectId);
+    var persistenceMeta = input.persistenceContext?.nextMeta || {};
+    var queueTombstones = persistenceMeta.queueTombstones || {};
+    var sessionTombstones = persistenceMeta.sessionTombstones || {};
+    var deletedSessionIds = Array.from(new Set([
+      ...(Array.isArray(input.deletedSessionIds) ? input.deletedSessionIds : []),
+      ...Object.keys(sessionTombstones)
+    ]));
+    var sessionRecords = (state.sessions || []).map(function (session) {
+      return StorageDb.buildSessionRecord(Object.assign({}, session, {
+        projectId: projectId,
+        accountScopeId: accountScopeId,
+        title: session.title || '',
+        titleSource: session.titleSource || 'auto',
+        codexThreadId: session.codexThreadId || '',
+        status: 'active',
+        focusFiles: Array.isArray(session.focusFiles) ? session.focusFiles : [],
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        pendingInputs: (Array.isArray(session.pendingInputs) ? session.pendingInputs : [])
+          .filter(function (item) { return !queueTombstones[item?.id]; })
+      }), { preserveRunActionPayload: true });
+    });
+    await input.SessionPersistence.writeSessions({
+      Migration: Migration,
+      StorageDb: StorageDb,
+      projectId: projectId,
+      accountScopeId: accountScopeId,
+      deletedSessionIds: deletedSessionIds,
+      sessionRecords: sessionRecords,
+      queueClaims: persistenceMeta.queueClaims || {},
+      queueTombstones: queueTombstones,
+      writerId: input.persistenceContext?.writerId || ''
+    });
+  }
+
+  return Object.freeze({ persistPanelState: persistPanelState });
+});

package/extension/src/content/sessionManager.js

@@ -1,17 +1,6 @@
 (function initCodexOverleafSessionManager() {
   'use strict';
 
-  const SessionPanel = window.CodexOverleafSessionPanel;
-  const {
-    createSession,
-    deleteSession,
-    setActiveSession,
-    getActiveSession,
-    isDisplayableSession,
-    normalizePanelState,
-    deriveSessionTitle
-  } = window.CodexOverleafSessionState;
-
   // Session manager — the session lifecycle + list/delete surface
   // carved out of contentRuntime.js (v1.4.7 structural-debt phase 3). Code
   // moved verbatim except that mutable runtime state is read through
@@ -19,6 +8,20 @@
   // setState() (sessions are immutable-update: every mutation rebuilds state
   // via the shared sessionState helpers and hands it back to the runtime).
   function create(deps = {}) {
+    const {
+      SessionPanel,
+      SessionState,
+      SessionMenuView
+    } = deps;
+    const {
+      createSession,
+      deleteSession,
+      setActiveSession,
+      getActiveSession,
+      isDisplayableSession,
+      normalizePanelState,
+      deriveSessionTitle
+    } = SessionState;
     const {
       tr,
       showPluginConfirm,
@@ -36,7 +39,7 @@
       formatSessionTime
     } = deps;
 
-    const sessionMenuView = window.CodexOverleafSessionMenuView.create({
+    const sessionMenuView = SessionMenuView.create({
       commitSessionRename,
       deleteSessionWithConfirm,
       document,

package/extension/src/content/sessionPersistence.js

@@ -1,8 +1,14 @@
-(function initCodexOverleafSessionPersistence() {
+(function initCodexOverleafSessionPersistence(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('../shared/storageMigration'));
+  } else {
+    root.CodexOverleafModuleRegistry.define('SessionPersistence', ['StorageMigration'], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function sessionPersistenceFactory(Migration) {
   'use strict';
 
   function migration() {
-    return window.CodexOverleafStorageMigration;
+    return Migration;
   }
 
   async function loadTombstones() {
@@ -21,11 +27,20 @@
   function isVisibleRecord(record, deletedIds, accountScopeId) {
     return Boolean(record)
       && !(deletedIds || []).includes(record.id)
-      && (!accountScopeId || record.accountScopeId === accountScopeId);
+      && Boolean(accountScopeId)
+      && record.accountScopeId === accountScopeId;
   }
 
   async function writeSessions(options = {}) {
     const { StorageDb, projectId } = options;
+    const accountScopeId = typeof options.accountScopeId === 'string'
+      ? options.accountScopeId.trim()
+      : '';
+    if (!accountScopeId) {
+      throw Object.assign(new Error('Session persistence requires an account identity.'), {
+        code: 'account_scope_unavailable'
+      });
+    }
     const Migration = options.Migration || migration();
     const requested = (Array.isArray(options.deletedSessionIds) ? options.deletedSessionIds : [])
       .filter(id => typeof id === 'string' && id);
@@ -34,8 +49,23 @@
       : await Migration?.loadSessionTombstones?.() || {};
     const deleted = new Set(requested);
     for (const id of Migration?.getDeletedSessionIds?.(tombstones, projectId) || []) deleted.add(id);
-    const sessionRecords = (options.sessionRecords || []).filter(record => !deleted.has(record.id));
-    const existingSessions = await StorageDb.getAllByIndex('sessions', 'projectId', projectId);
+    const queueTombstones = options.queueTombstones && typeof options.queueTombstones === 'object'
+      ? options.queueTombstones
+      : {};
+    const rawSessionRecords = (options.sessionRecords || [])
+      .filter(record => !deleted.has(record.id) && record.accountScopeId === accountScopeId);
+    const rawExistingSessions = (await StorageDb.getAllByIndex('sessions', 'projectId', projectId))
+      .filter(record => record?.accountScopeId === accountScopeId);
+    const rawExistingById = new Map(rawExistingSessions.map(record => [record.id, record]));
+    const sessionRecords = rawSessionRecords
+      .map(record => applyQueuePolicy(
+        record,
+        rawExistingById.get(record.id),
+        options,
+        queueTombstones
+      ));
+    const existingSessions = rawExistingSessions
+      .map(record => applyQueuePolicy(record, record, options, queueTombstones));
     const deletedExisting = existingSessions.filter(record => deleted.has(record.id));
     if (deletedExisting.length) {
       await Promise.all(deletedExisting.map(record => StorageDb.deleteRecord('sessions', record.id)));
@@ -48,15 +78,44 @@
       if (!existing) return true;
       return (Date.parse(record.updatedAt || '') || 0) >= (Date.parse(existing.updatedAt || '') || 0);
     });
-    if (writable.length) await StorageDb.putRecords('sessions', writable);
+    const cleanedExisting = existingSessions.filter((record, index) =>
+      record !== rawExistingSessions[index] && !writable.some(item => item.id === record.id)
+    );
+    if (cleanedExisting.length || writable.length) {
+      await StorageDb.putRecords('sessions', [...cleanedExisting, ...writable]);
+    }
     return writable;
   }
 
-  window.CodexOverleafSessionPersistence = {
+  function applyQueuePolicy(record, existingRecord, options, queueTombstones) {
+    const original = Array.isArray(record?.pendingInputs) ? record.pendingInputs : [];
+    let pendingInputs = original.filter(item => item?.id && !queueTombstones[item.id]);
+    const existingById = new Map(
+      (Array.isArray(existingRecord?.pendingInputs) ? existingRecord.pendingInputs : [])
+        .filter(item => item?.id && !queueTombstones[item.id])
+        .map(item => [item.id, item])
+    );
+    const claims = options.queueClaims && typeof options.queueClaims === 'object'
+      ? options.queueClaims
+      : {};
+    for (const claim of Object.values(claims)) {
+      if (!claim?.itemId || claim.ownerId === options.writerId) continue;
+      const index = pendingInputs.findIndex(item => item.id === claim.itemId);
+      const authoritative = existingById.get(claim.itemId);
+      if (authoritative && index >= 0) pendingInputs[index] = authoritative;
+      else if (authoritative) pendingInputs.push(authoritative);
+      else if (index >= 0) pendingInputs.splice(index, 1);
+    }
+    const unchanged = pendingInputs.length === original.length
+      && pendingInputs.every((item, index) => item === original[index]);
+    return unchanged ? record : { ...record, pendingInputs };
+  }
+
+  return {
     loadTombstones,
     getDeletedSessionIds,
     addTombstones,
     isVisibleRecord,
     writeSessions
   };
-})();
+});

package/extension/src/content/updateNotice.js

@@ -1,4 +1,10 @@
-(function initCodexOverleafUpdateNotice(root) {
+(function initCodexOverleafUpdateNotice(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('../shared/managedUpdateProjection'));
+  } else {
+    root.CodexOverleafModuleRegistry.define('UpdateNotice', ['ManagedUpdateProjection'], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function updateNoticeFactory(UpdateProjection) {
   'use strict';
 
   let notice = null;
@@ -11,7 +17,7 @@
   let settingsActionInFlight = false;
   let restartWatchdog = null;
   let manualCommandCopied = false;
-  const ACTIVE_UPDATE_STATES = new Set(['downloading', 'staged', 'waiting_for_idle', 'applying', 'awaiting_health']);
+  const ACTIVE_UPDATE_STATES = new Set(UpdateProjection.activePhases('panel'));
   const RESTART_WATCHDOG_MS = 30 * 1000;
 
   function mount(panelLike, options = {}) {
@@ -467,5 +473,5 @@
     return /^zh\b/i.test(locale) ? chinese : english;
   }
 
-  root.CodexOverleafUpdateNotice = Object.freeze({ mount });
-})(window);
+  return Object.freeze({ mount });
+});