codex-overleaf-link 2.3.6 → 2.4.1

package/extension/src/content/runResultActions.js

@@ -107,7 +107,22 @@
       if (!copied) throw new Error('clipboard_copy_failed');
     }
 
-    return Object.freeze({ configureResultActions });
+    return Object.freeze({ configureResultActions, projectUndoAvailability });
+  }
+
+  function projectUndoAvailability(run, projectRunSettlement) {
+    const payload = run.recoveryPayload && typeof run.recoveryPayload === 'object'
+      ? run.recoveryPayload : run;
+    if (!Array.isArray(payload.appliedOperations)) return projectRunSettlement(run);
+    // Forward binary writes do not provide a rollback. Filter them only for
+    // display; preserve the canonical settlement and every real recovery field.
+    const appliedOperations = payload.appliedOperations.filter(operation =>
+      operation?.type !== 'binary-create' && operation?.type !== 'overwrite-binary');
+    if (appliedOperations.length === payload.appliedOperations.length) return projectRunSettlement(run);
+    return projectRunSettlement({
+      ...run,
+      recoveryPayload: { ...payload, appliedOperations }
+    });
   }
 
   return Object.freeze({ create });

package/extension/src/content/runTimelineView.js

@@ -932,7 +932,7 @@
       return;
     }
 
-    const projection = projectRunSettlement(run);
+    const projection = RunResultActions.projectUndoAvailability(run, projectRunSettlement);
     if (!projection.canUndo && run.undoStatus !== 'applied') {
       button.hidden = true;
       return;
@@ -960,12 +960,12 @@
   // same executable state as `pending`.
   function configureLifecycleUndoButton(button, run) {
     const status = run.trackedChangeStatus || '';
+    const inFlight = trackedChangeInFlight.get(run.id);
     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 = !projection.canUndo || inFlight === 'reject' || inFlight === 'accept';
       button.textContent = tr('undoRun');
@@ -976,14 +976,14 @@
       });
       return;
     }
-    if (status === 'rejected') {
+    if (status === 'rejected' && !inFlight) {
       button.hidden = false;
       button.disabled = true;
       button.textContent = tr('undoApplied');
       button.title = tr('undoAppliedTitle');
       return;
     }
-    if (status === 'accepted') {
+    if (status === 'accepted' && !inFlight) {
       // The run was accepted — terminal. Undo stays visible but greyed so the
       // card shows both controls disabled, never removed.
       button.hidden = false;
@@ -992,11 +992,10 @@
       button.title = tr('undoRunTitle');
       return;
     }
-    if (status !== 'pending') {
+    if (status !== 'pending' && !inFlight) {
       button.hidden = true;
       return;
     }
-    const inFlight = trackedChangeInFlight.get(run.id);
     button.hidden = false;
     button.disabled = !projection.canUndo || inFlight === 'reject' || inFlight === 'accept';
     button.textContent = tr('undoRun');
@@ -1034,12 +1033,12 @@
     }
 
     const status = run.trackedChangeStatus || '';
+    const inFlight = trackedChangeInFlight.get(run.id);
     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 = !projection.canAccept || inFlight === 'accept' || inFlight === 'reject';
       if (inFlight === 'accept') {
@@ -1052,14 +1051,14 @@
       wireAcceptInlineConfirm(button, run.id);
       return;
     }
-    if (status === 'accepted') {
+    if (status === 'accepted' && !inFlight) {
       button.hidden = false;
       button.disabled = true;
       button.textContent = tr('runAcceptTrackedDone');
       button.title = tr('runAcceptTrackedDoneTitle');
       return;
     }
-    if (status === 'rejected') {
+    if (status === 'rejected' && !inFlight) {
       // The run was rejected — terminal. Accept All stays visible but greyed so
       // the card shows both controls disabled, never removed.
       button.hidden = false;
@@ -1068,12 +1067,11 @@
       button.title = tr('runAcceptTrackedTitle');
       return;
     }
-    if (status !== 'pending') {
+    if (status !== 'pending' && !inFlight) {
       button.hidden = true;
       return;
     }
 
-    const inFlight = trackedChangeInFlight.get(run.id);
     button.hidden = false;
     button.disabled = !projection.canAccept || inFlight === 'accept' || inFlight === 'reject';
     if (inFlight === 'accept') {

package/extension/src/content/scopedPersistenceCoordinator.js

@@ -95,6 +95,7 @@
   }
   return Object.freeze({
     createController: createController,
-    persistPanelState: PanelState?.persistPanelState || null
+    persistPanelState: PanelState?.persistPanelState || null,
+    applyReviewTransition: PanelState?.applyReviewTransition || null
   });
 });

package/extension/src/content/scopedPersistencePanelState.js

@@ -15,6 +15,42 @@
     return JSON.parse(JSON.stringify(value));
   }
 
+  async function applyReviewTransition({ getState, runId, transition, persist }) {
+    const targets = () => Array.from(new Set([
+      ...(getState().runs || []),
+      ...(getState().sessions || []).flatMap(session => session.runs || [])
+    ])).filter(run => run.id === runId);
+    const records = targets();
+    const sessions = (getState().sessions || []).filter(session =>
+      (session.runs || []).some(run => run.id === runId));
+    if (!records.length || !sessions.length) throw reviewPersistenceError();
+    const previous = cloneSnapshot(records[0]);
+    for (const record of records) Object.assign(record, cloneSnapshot(transition));
+    for (const session of sessions) {
+      session.updatedAt = new Date(Math.max(Date.now(), (Date.parse(session.updatedAt) || 0) + 1,
+        (Date.parse(session.lastActivityAt) || 0) + 1)).toISOString();
+      session.lastActivityAt = session.updatedAt;
+    }
+    try {
+      await persist({ preserveRunActionPayload: true, reviewRunIds: [runId] });
+    } catch (error) {
+      // The remote action may have succeeded. Keep its recovery data and expose uncertainty.
+      for (const record of targets()) {
+        Object.assign(record, cloneSnapshot(previous), { trackedChangeStatus: 'needs_review' });
+        for (const field of ['settlement', 'settlementFacts']) {
+          if (!Object.prototype.hasOwnProperty.call(previous, field)) delete record[field];
+        }
+      }
+      throw error;
+    }
+  }
+
+  function reviewPersistenceError() {
+    return Object.assign(new Error('The review outcome was not durably saved. Check Overleaf before retrying.'), {
+      code: 'review_state_not_persisted'
+    });
+  }
+
   async function persistPanelState(input) {
     var state = cloneSnapshot(input.state || {});
     var compactState = cloneSnapshot(input.compactState || {});
@@ -35,6 +71,9 @@
         code: 'stale_view'
       });
     }
+    var reviewRuns = (input.reviewRunIds || []).map(id =>
+      (state.sessions || []).flatMap(session => session.runs || []).find(run => run.id === id));
+    if (reviewRuns.some(run => !run)) throw reviewPersistenceError();
     var latestPrefs = typeof Migration.loadPrefs === 'function'
       ? await Migration.loadPrefs(accountScopeId, projectId)
       : {};
@@ -94,18 +133,22 @@
           .filter(function (item) { return !queueTombstones[item?.id]; })
       }), { preserveRunActionPayload: true });
     });
-    await input.SessionPersistence.writeSessions({
+    var written = await input.SessionPersistence.writeSessions({
       Migration: Migration,
       StorageDb: StorageDb,
       projectId: projectId,
       accountScopeId: accountScopeId,
       deletedSessionIds: deletedSessionIds,
       sessionRecords: sessionRecords,
+      reviewRunIds: input.reviewRunIds,
       queueClaims: persistenceMeta.queueClaims || {},
       queueTombstones: queueTombstones,
       writerId: input.persistenceContext?.writerId || ''
     });
+    if (!reviewRuns.every(reviewRun => (written || []).some(session => (session.runs || []).some(run =>
+      run.id === reviewRun.id && run.trackedChangeStatus === reviewRun.trackedChangeStatus
+    )))) throw reviewPersistenceError();
   }
 
-  return Object.freeze({ persistPanelState: persistPanelState });
+  return Object.freeze({ persistPanelState: persistPanelState, applyReviewTransition: applyReviewTransition });
 });

package/extension/src/content/sessionForkController.js

@@ -16,19 +16,28 @@
       const source = findSource(previousState, runId);
       if (!source) return failFork('session_fork_source_missing', tr('forkRunUnavailable'));
       const { session, run, runIndex } = source;
-      if (run.status === 'running' || !session.codexThreadId || !run.codexTurnId) {
+      const draftThreadId = run.codexTurnId && run.interruptedDraft?.turnId === run.codexTurnId
+        ? run.interruptedDraft.threadId : '';
+      // Provider switches replace the session thread, not the selected node's origin.
+      const sourceThreadId = String(run.codexThreadId || draftThreadId || session.codexThreadId || '').trim();
+      if (run.status === 'running' || !sourceThreadId || !run.codexTurnId) {
         return failFork('session_fork_unavailable', tr('forkRunUnavailable'));
       }
-      const response = await sendBackgroundNative({
-        method: 'codex.thread.fork',
-        params: {
-          threadId: session.codexThreadId,
-          lastTurnId: run.codexTurnId,
-          speedTier: session.speedTier,
-          loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
-          loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
-        }
-      });
+      let response;
+      try {
+        response = await sendBackgroundNative({
+          method: 'codex.thread.fork',
+          params: {
+            threadId: sourceThreadId,
+            lastTurnId: run.codexTurnId,
+            speedTier: session.speedTier,
+            loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
+            loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
+          }
+        });
+      } catch (error) {
+        return failFork(error?.code || 'session_fork_failed', error?.message || tr('forkRunFailed'));
+      }
       if (!response?.ok || !response.result?.threadId) {
         return failFork(response?.error?.code || 'session_fork_failed', response?.error?.message || tr('forkRunFailed'));
       }

package/extension/src/content/sessionPersistence.js

@@ -73,7 +73,10 @@
     const existingById = new Map(existingSessions
       .filter(record => !deleted.has(record.id))
       .map(record => [record.id, record]));
-    const writable = sessionRecords.filter(record => {
+    const mergedRecords = sessionRecords.map(record => StorageDb.mergeSessionReviewState?.(
+      record, existingById.get(record.id), options.reviewRunIds
+    ) || record);
+    const writable = mergedRecords.filter(record => {
       const existing = existingById.get(record.id);
       if (!existing) return true;
       return (Date.parse(record.updatedAt || '') || 0) >= (Date.parse(existing.updatedAt || '') || 0);

package/extension/src/content/settingsPanel.js

@@ -38,8 +38,8 @@
         <div class="codex-custom-instructions-head">
           <button type="button" data-settings-back title="Back" aria-label="Back">‹</button>
           <div>
-            <div class="codex-custom-instructions-title" data-i18n="projectSettingsTitle">Project Settings</div>
-            <div class="codex-custom-instructions-subtitle" data-i18n="projectSettingsSubtitle">Customize how Codex behaves in this and all projects.</div>
+            <div class="codex-custom-instructions-title" data-settings-title data-i18n="projectSettingsTitle">Project Settings</div>
+            <div class="codex-custom-instructions-subtitle" data-settings-subtitle data-i18n="projectSettingsSubtitle">Customize how Codex behaves in this and all projects.</div>
           </div>
         </div>
         <div class="codex-project-settings-status" data-project-settings-status></div>
@@ -304,6 +304,7 @@
     if (!root) {
       return;
     }
+    refreshSettingsScope(instance, root);
     const button = getButton(instance);
     if (button) {
       button.dataset.active = 'true';
@@ -312,6 +313,18 @@
     root.querySelector('[data-custom-instructions-input]')?.focus?.();
   }
 
+  function refreshSettingsScope(instance, root) {
+    const accountScope = instance.container?.closest?.('[data-settings-scope]')?.dataset?.settingsScope === 'account';
+    const prefix = accountScope ? 'recentProjects_settings' : 'projectSettings';
+    for (const [selector, suffix] of [['[data-settings-title]', 'Title'], ['[data-settings-subtitle]', 'Subtitle']]) {
+      const label = root.querySelector(selector);
+      if (!label) continue;
+      const key = prefix + suffix;
+      label.setAttribute('data-i18n', key);
+      label.textContent = t(instance, key);
+    }
+  }
+
   function hide(target) {
     const instance = target?._instance || target;
     const root = getRoot(instance);
@@ -346,6 +359,7 @@
     if (!root) {
       return;
     }
+    refreshSettingsScope(instance, root);
     if (Object.prototype.hasOwnProperty.call(state, 'customInstructions')) {
       const input = root.querySelector('[data-custom-instructions-input]');
       if (input) {

package/extension/src/content/trackedChangeCaptureController.js

@@ -0,0 +1,153 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafTrackedChangeCaptureController = api;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+  function create(deps = {}) {
+    const now = deps.now || (() => Date.now());
+    const defer = deps.setTimeout || setTimeout;
+    const cancelTimer = deps.clearTimeout || clearTimeout;
+    let timer = null, busy = false, disposed = false;
+    const runs = () => deps.getRuns() || [];
+    const pending = run => Array.isArray(run.trackedChangeCaptures)
+      && run.trackedChangeCaptures.some(capture => capture.state === 'pending');
+    const terminal = run => ['accepted', 'rejected'].includes(run.trackedChangeStatus)
+      || run.undoStatus === 'applied' || run.forkSnapshot === true;
+    function buildPostFiles(run) {
+      const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
+      const appliedOperations = Array.isArray(run?.appliedOperations) ? run.appliedOperations : [];
+      if (!expectedFiles.length || !appliedOperations.length) return [];
+      const postFilesByPath = deps.buildExpectedFilesAfterOperations({ files: expectedFiles }, appliedOperations);
+      const expectedPaths = new Set(expectedFiles.map(file => file?.path).filter(Boolean));
+      return Array.from(postFilesByPath.entries())
+        .filter(([path, content]) => expectedPaths.has(path) && typeof content === 'string')
+        .map(([path, content]) => ({ path, content }));
+    }
+    function hasLegacyUntrackedCheckpoint(run) {
+      if (!run || run.executionSnapshot || run.trackedChangeStatus || run.undoStatus === 'applied'
+        || run.forkSnapshot || run.undoTrackedChanges?.length || run.trackedChangeCaptures?.length) return false;
+      const operations = Array.isArray(run.undoOperations) ? run.undoOperations : [];
+      const before = Array.isArray(run.undoExpectedFiles) ? run.undoExpectedFiles : [];
+      if (!operations.length || !before.length || before.some(file => !file?.path || typeof file.content !== 'string')) return false;
+      const paths = new Set(before.map(file => file.path));
+      if (paths.size !== before.length || operations.some(op => op?.type !== 'edit' || !paths.has(op.path))) return false;
+      const complete = files => Array.isArray(files) && files.length === paths.size
+        && new Set(files.map(file => file?.path)).size === paths.size
+        && files.every(file => paths.has(file?.path) && typeof file.content === 'string');
+      const storedPost = run.undoBaseFiles;
+      try {
+        const post = buildPostFiles(run);
+        if (!complete(storedPost) || !complete(post)) return false;
+        const postByPath = new Map(post.map(file => [file.path, file.content]));
+        if (!storedPost.every(file => postByPath.get(file.path) === file.content)) return false;
+        const restored = deps.buildExpectedFilesAfterOperations({ files: storedPost }, operations);
+        // A legacy checkpoint must prove both directions; empty refs alone grant nothing.
+        return before.every(file => restored.get(file.path) === file.content);
+      } catch (_error) { return false; }
+    }
+    function schedule() {
+      if (disposed || timer !== null || busy || !runs().some(pending)) return;
+      timer = defer(() => {
+        timer = null;
+        flush().catch(error => deps.onError?.(error));
+      }, 500);
+    }
+    function record(run, captures) {
+      if (!Array.isArray(captures) || !captures.length) return;
+      const next = [...(run.trackedChangeCaptures || []), ...captures.filter(Boolean)];
+      if (next.every(capture => capture.state === 'observed')) return;
+      run.trackedChangeCaptures = next;
+      deps.notify?.(run, next.some(capture => capture.state === 'pending') ? 'pending' : 'needs_review', {
+        captures: next.map(capture => ({ path: capture.path, reason: capture.reason, ...capture.diagnostics }))
+      });
+      deps.persist().then(schedule).catch(error => deps.onError?.(error));
+    }
+    async function flush() {
+      if (disposed || busy) return;
+      busy = true;
+      try {
+        for (const run of runs().filter(pending)) {
+          if (terminal(run)) { run.trackedChangeCaptures = []; await deps.persist(); continue; }
+          if (run.runProjectId !== deps.getProjectId()) continue;
+          const newer = runs().some(other => other.id !== run.id
+            && other.runProjectId === run.runProjectId
+            && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+          const original = run.trackedChangeCaptures;
+          const captures = original.map(capture => ({ ...capture }));
+          const postFiles = buildPostFiles(run);
+          for (let i = 0; i < captures.length; i++) {
+            const capture = captures[i];
+            if (capture.state !== 'pending') continue;
+            const expected = postFiles.find(file => file.path === capture.path);
+            if (newer || !expected || now() >= capture.expiresAt || run.status === 'cancelled') {
+              capture.state = 'needs_review';
+              capture.reason = newer ? 'capture_superseded' : !expected ? 'capture_baseline_missing'
+                : run.status === 'cancelled' ? 'capture_cancelled' : 'capture_expired';
+              continue;
+            }
+            let response;
+            try {
+              response = await deps.callPageBridge('reconcileTrackedChangeCapture', {
+                runProjectId: run.runProjectId, capture, expectedContent: expected.content
+              });
+            } catch (_error) {
+              response = null;
+            }
+            // Never patch a superseded hydrated record or another project's state.
+            if (disposed || deps.getProjectId() !== run.runProjectId
+              || !runs().includes(run) || terminal(run) || run.trackedChangeCaptures !== original) return;
+            const superseded = runs().some(other => other.id !== run.id
+              && other.runProjectId === run.runProjectId
+              && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+            if (superseded || run.status === 'cancelled') {
+              captures[i] = { ...capture, state: 'needs_review', reason: 'capture_superseded' };
+            } else if (response?.capture?.path === capture.path
+              && response.capture.runProjectId === run.runProjectId
+              && ['observed', 'pending', 'needs_review'].includes(response.capture.state)) {
+              captures[i] = response.capture;
+            } else {
+              captures[i] = { ...capture, state: 'needs_review', reason: 'capture_bridge_unavailable' };
+            }
+          }
+          if (!runs().includes(run) || terminal(run) || deps.getProjectId() !== run.runProjectId) continue;
+          if (captures.length && captures.every(capture => capture.state === 'observed')) {
+            const refs = deps.normalizeTrackedChanges([
+              ...(run.undoTrackedChanges || []), ...captures.flatMap(capture => capture.refs || [])
+            ]);
+            if (refs.length) {
+              run.undoTrackedChanges = refs;
+              run.trackedChangeStatus = 'pending';
+              run.trackedChangeCaptures = [];
+              await deps.persist();
+              deps.refresh(run);
+              deps.notify?.(run, 'observed', { count: refs.length });
+              continue;
+            }
+          }
+          const changed = JSON.stringify(original.map(summary)) !== JSON.stringify(captures.map(summary));
+          if (changed) {
+            run.trackedChangeCaptures = captures;
+            await deps.persist();
+            if (!pending(run)) deps.notify?.(run, 'needs_review', {
+              reasons: captures.filter(capture => capture.state !== 'observed').map(capture => capture.reason)
+            });
+          }
+        }
+      } finally {
+        busy = false;
+        if (runs().some(run => pending(run) && run.runProjectId === deps.getProjectId())) schedule();
+      }
+    }
+    function summary(capture) {
+      return { state: capture.state, reason: capture.reason, refs: (capture.refs || []).map(ref => ref.key) };
+    }
+    function dispose() {
+      disposed = true;
+      if (timer !== null) cancelTimer(timer);
+      timer = null;
+    }
+    return { record, schedule, flush, dispose, buildPostFiles, hasLegacyUntrackedCheckpoint };
+  }
+  return { create };
+});

package/extension/src/content/writebackOrchestrator.js

@@ -18,6 +18,7 @@
   let tx;
   let getLocale;
   let appendRunEvent;
+  let appendRunRecordEvent;
   // In-flight background mirror refresh (v1.7.5) — see the writeback path.
   let pendingMirrorRefresh = null;
   let appendChangeSummary;
@@ -69,6 +70,34 @@
       : null;
   }
 
+  function invalidateMirrorAfterUndo(runId, projectId, result = {}) {
+    if (!projectId || (result?.changedDocument !== true && !result?.applied?.length)) return Promise.resolve('not-attempted');
+    const pending = Promise.resolve(pendingMirrorRefresh).catch(() => {}).then(async () => {
+      const response = await sendBackgroundNative({ method: 'mirror.invalidate', params: { projectId } });
+      if (!response?.ok || response.result?.invalidated !== true) {
+        throw new Error(response?.error?.message || 'Native host did not confirm mirror invalidation.');
+      }
+      if (getCurrentProjectId() === projectId) {
+        resetContextProject();
+        await callPageBridge('invalidateProjectSnapshot', { invalidateFileList: true });
+      }
+      return 'invalidated';
+    }).catch(error => {
+      appendRunRecordEvent?.(runId, {
+        status: 'warning',
+        title: tx(
+          `Overleaf undo finished, but local mirror invalidation failed: ${error.message}. Refresh this project or reconnect the native host before running again.`,
+          `Overleaf 撤销已完成，但本地镜像失效处理失败：${error.message}。请刷新项目或重新连接 Native Host 后再运行。`
+        )
+      });
+      return 'failed';
+    }).finally(() => {
+      if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
+    });
+    pendingMirrorRefresh = pending;
+    return pending;
+  }
+
   async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options = {}) {
     const runMode = options.mode || getState().mode;
     const runRequireReviewing = typeof options.requireReviewing === 'boolean'
@@ -822,6 +851,7 @@
       tx,
       getLocale,
       appendRunEvent,
+      appendRunRecordEvent,
       appendChangeSummary,
       appendCompletionReport,
       appendOperationsPreview,
@@ -867,6 +897,7 @@
     return {
       applySyncChangesToOverleaf,
       resolveCompileLogContext,
+      invalidateMirrorAfterUndo,
       getPendingMirrorRefresh: () => pendingMirrorRefresh
     };
   }