codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/content/scopedPersistencePanelState.js

@@ -15,11 +15,13 @@
     return JSON.parse(JSON.stringify(value));
   }
 
-  async function applyReviewTransition({ getState, runId, transition, persist }) {
+  async function applyReviewTransition({ getState, runId, transition, persist, legacyUndo = false, assertCurrent }) {
     const targets = () => Array.from(new Set([
       ...(getState().runs || []),
       ...(getState().sessions || []).flatMap(session => session.runs || [])
     ])).filter(run => run.id === runId);
+    assertCurrent?.();
+    const capturedState = getState(), capturedSessionId = capturedState.activeSessionId;
     const records = targets();
     const sessions = (getState().sessions || []).filter(session =>
       (session.runs || []).some(run => run.id === runId));
@@ -31,12 +33,19 @@
         (Date.parse(session.lastActivityAt) || 0) + 1)).toISOString();
       session.lastActivityAt = session.updatedAt;
     }
+    const staged = records.map(record => JSON.stringify(record));
     try {
-      await persist({ preserveRunActionPayload: true, reviewRunIds: [runId] });
+      await persist({ preserveRunActionPayload: true, reviewRunIds: [runId], requireDurable: true });
+      assertCurrent?.();
+      if (getState() !== capturedState || getState().activeSessionId !== capturedSessionId
+        || records.some(record => !targets().includes(record))) throw reviewPersistenceError();
     } catch (error) {
+      try { assertCurrent?.(); } catch (_stale) { throw 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 record of records) {
+        if (getState() !== capturedState || !targets().includes(record)
+          || JSON.stringify(record) !== staged[records.indexOf(record)]) continue;
+        Object.assign(record, cloneSnapshot(previous), legacyUndo ? { undoStatus: 'partial' } : { trackedChangeStatus: 'needs_review' });
         for (const field of ['settlement', 'settlementFacts']) {
           if (!Object.prototype.hasOwnProperty.call(previous, field)) delete record[field];
         }
@@ -51,6 +60,28 @@
     });
   }
 
+  function verifyRecoveredRuns(recoveredRuns, proposed, written) {
+    for (var target of recoveredRuns || []) {
+      var expectedSession = proposed.find(session => session.id === target.sessionId);
+      var storedSession = (written || []).find(session => session.id === target.sessionId
+        && session.projectId === expectedSession?.projectId
+        && session.accountScopeId === expectedSession?.accountScopeId);
+      var expected = expectedSession?.runs?.find(run => run.id === target.runId);
+      var stored = storedSession?.runs?.find(run => run.id === target.runId);
+      var retained = expected && stored
+        && expected.runProjectId === target.projectId && stored.runProjectId === target.projectId
+        && Number(stored.nativeEventSeq || 0) >= Number(expected.nativeEventSeq || 0)
+        && stored.codexThreadId === expected.codexThreadId
+        && stored.codexTurnId === expected.codexTurnId
+        && JSON.stringify(stored.interruptedDraft) === JSON.stringify(expected.interruptedDraft)
+        && (expected.events || []).every(event => (stored.events || [])
+          .some(saved => JSON.stringify(saved) === JSON.stringify(event)));
+      if (!retained) throw Object.assign(new Error('Recovered run was not durably saved; its replay journal is retained.'), {
+        code: 'recovery_state_not_persisted'
+      });
+    }
+  }
+
   async function persistPanelState(input) {
     var state = cloneSnapshot(input.state || {});
     var compactState = cloneSnapshot(input.compactState || {});
@@ -71,6 +102,12 @@
         code: 'stale_view'
       });
     }
+    if ((input.recoveryRuns || []).some(target => target.projectId !== projectId
+      || target.accountScopeId !== accountScopeId)) {
+      throw Object.assign(new Error('Journal recovery scope changed before persistence.'), {
+        code: 'recovery_scope_changed'
+      });
+    }
     var reviewRuns = (input.reviewRunIds || []).map(id =>
       (state.sessions || []).flatMap(session => session.runs || []).find(run => run.id === id));
     if (reviewRuns.some(run => !run)) throw reviewPersistenceError();
@@ -129,10 +166,11 @@
         focusFiles: Array.isArray(session.focusFiles) ? session.focusFiles : [],
         createdAt: session.createdAt,
         updatedAt: session.updatedAt,
-        pendingInputs: (Array.isArray(session.pendingInputs) ? session.pendingInputs : [])
+      pendingInputs: (Array.isArray(session.pendingInputs) ? session.pendingInputs : [])
           .filter(function (item) { return !queueTombstones[item?.id]; })
       }), { preserveRunActionPayload: true });
     });
+    sessionRecords = StorageDb.compactSessionBatchActions?.(sessionRecords, { activeSessionId: state.activeSessionId }) || sessionRecords;
     var written = await input.SessionPersistence.writeSessions({
       Migration: Migration,
       StorageDb: StorageDb,
@@ -146,8 +184,15 @@
       writerId: input.persistenceContext?.writerId || ''
     });
     if (!reviewRuns.every(reviewRun => (written || []).some(session => (session.runs || []).some(run =>
-      run.id === reviewRun.id && run.trackedChangeStatus === reviewRun.trackedChangeStatus
+      run.id === reviewRun.id
+      && (!reviewRun.trackedChangeStatus && ['applied', 'partial'].includes(reviewRun.undoStatus)
+        ? run.undoStatus === reviewRun.undoStatus && (reviewRun.undoStatus === 'applied'
+          || ['undoOperations', 'undoBaseFiles', 'undoExpectedFiles', 'undoTrackedChanges']
+            .every(field => JSON.stringify(run[field] || []) === JSON.stringify(reviewRun[field] || [])))
+        : run.trackedChangeStatus === reviewRun.trackedChangeStatus)
     )))) throw reviewPersistenceError();
+    verifyRecoveredRuns(input.recoveryRuns, sessionRecords, written);
+    return written;
   }
 
   return Object.freeze({ persistPanelState: persistPanelState, applyReviewTransition: applyReviewTransition });

package/extension/src/content/selectionContextView.js

@@ -0,0 +1,300 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory(require('../shared/selectionContext'));
+  else root.CodexOverleafModuleRegistry.define('SelectionContextView', ['SelectionContext'], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : window, function (SelectionContext) {
+  'use strict';
+
+  // The chip shared by the composer and sent messages: file:lines, the edit-only
+  // scope label, and the selected text behind a disclosure.
+  function buildChip(selection, { document: doc = globalThis.document, tx = en => en, expanded = false } = {}) {
+    const lines = selection.lineStart === selection.lineEnd
+      ? String(selection.lineStart) : selection.lineStart + '-' + selection.lineEnd;
+    const location = selection.path + ':' + lines;
+    const details = doc.createElement('details');
+    details.open = expanded;
+    const summary = doc.createElement('summary');
+    summary.title = location;
+    summary.setAttribute('aria-label', tx('Preview selection from ' + location, '预览选区：' + location));
+    const file = doc.createElement('span');
+    file.className = 'codex-selection-file';
+    file.textContent = selection.path.split('/').pop();
+    const range = doc.createElement('span');
+    range.className = 'codex-selection-range';
+    range.textContent = ':' + lines;
+    summary.append(file, range);
+    if (selection.mode === 'edit') {
+      const scope = doc.createElement('span');
+      scope.className = 'codex-selection-scope';
+      scope.textContent = tx('Selection only', '仅此处');
+      summary.append(scope);
+    }
+    const source = doc.createElement('pre');
+    source.textContent = selection.text;
+    details.append(summary, source);
+    return details;
+  }
+
+  // Read-only chip for a sent message: the selection travels with the run's
+  // execution snapshot, so the bubble keeps showing what was attached.
+  function renderSent(host, value, options = {}) {
+    if (!host) return;
+    const selection = SelectionContext.normalize(value);
+    host.replaceChildren();
+    host.hidden = !selection;
+    if (selection) host.append(buildChip(selection, options));
+  }
+
+  function create(deps = {}) {
+    let generation = 0;
+    let probeGeneration = 0;
+    let timer = null;
+    let controller = null;
+    let toolbar = null;
+    let candidate = null;
+    let pointerSelecting = false;
+    let pointerEditor = null;
+    const resetEvent = 'codex-overleaf-selection-ui-reset';
+    const tx = (en, zh) => deps.tx ? deps.tx(en, zh) : en;
+
+    function capture() {
+      const selection = SelectionContext.normalize(deps.getState()?.selectionContext);
+      return selection?.projectId === deps.getProjectId() ? selection : null;
+    }
+
+    function clear() {
+      generation += 1;
+      hideFloating();
+      deps.setSelection(null);
+      render();
+    }
+
+    function render() {
+      const panel = deps.getPanel();
+      if (toolbar && !toolbar.hidden) syncFloatingAppearance();
+      const host = panel?.querySelector('[data-composer-selection]');
+      if (!host) return;
+      const selection = capture();
+      const id = selection ? [selection.projectId, selection.path, selection.from, selection.to,
+        selection.documentHash, selection.capturedAt, selection.mode].join(':') : '';
+      const expanded = Boolean(id && host.dataset.selectionId === id && host.querySelector('details')?.open);
+      host.replaceChildren();
+      host.dataset.selectionId = id;
+      host.hidden = !selection;
+      if (!selection) return;
+
+      host.append(buildChip(selection, { document, tx, expanded }));
+      const remove = document.createElement('button');
+      remove.type = 'button';
+      remove.textContent = '\u00d7';
+      remove.title = tx('Remove selection', '移除选区');
+      remove.setAttribute('aria-label', remove.title);
+      remove.addEventListener('click', clear);
+      host.append(remove);
+    }
+
+    async function attach(mode = 'reference', selected = null) {
+      const request = ++generation;
+      const projectId = deps.getProjectId();
+      const sessionId = deps.getState()?.activeSessionId;
+      if (selected && (selected.projectId !== projectId || selected.sessionId !== sessionId)) return null;
+      hideFloating();
+      try {
+        const response = selected
+          ? { ok: true, selection: selected.selection }
+          : await deps.callPageBridge('getSelectionContext', { runProjectId: projectId });
+        if (request !== generation || projectId !== deps.getProjectId()
+          || sessionId !== deps.getState()?.activeSessionId) return null;
+        const selection = SelectionContext.normalize({
+          ...(response?.selection || response), mode: mode === 'edit' ? 'edit' : 'reference'
+        });
+        if (response?.ok !== true || !selection || selection.projectId !== projectId) {
+          deps.toast?.(response?.code === 'selection_too_large'
+            ? tx('Select a shorter passage (up to 20,000 characters).', '请选择较短的片段，最多 20,000 个字符。')
+            : tx('Select text in the source editor first.', '请先在源码编辑器中选中文字。'));
+          return null;
+        }
+        await deps.openComposer?.();
+        if (request !== generation || projectId !== deps.getProjectId()
+          || sessionId !== deps.getState()?.activeSessionId) return null;
+        deps.setSelection(selection, { edit: selection.mode === 'edit' });
+        render();
+        const panel = deps.getPanel();
+        const tray = panel?.querySelector('[data-context-tray]');
+        if (tray) tray.hidden = true;
+        panel?.querySelector('[data-add-context]')?.setAttribute('aria-expanded', 'false');
+        panel?.querySelector('[data-task]')?.focus();
+        return selection;
+      } catch (_) {
+        if (request === generation && projectId === deps.getProjectId()
+          && sessionId === deps.getState()?.activeSessionId) {
+          deps.toast?.(tx('Could not attach the selection. Select it again and retry.', '未能添加选区，请重新选取后再试。'));
+        }
+        return null;
+      }
+    }
+
+    function editorFor(node) {
+      const element = node?.nodeType === 1 ? node : node?.parentElement;
+      const editor = element?.closest?.('.cm-editor');
+      return editor && !editor.closest('#codex-overleaf-panel') ? editor : null;
+    }
+
+    function hideFloating() {
+      probeGeneration += 1;
+      clearTimeout(timer);
+      timer = null;
+      candidate = null;
+      if (!toolbar) return;
+      if (typeof toolbar.hidePopover === 'function' && toolbar.matches(':popover-open')) toolbar.hidePopover();
+      toolbar.hidden = true;
+    }
+
+    function syncFloatingAppearance() {
+      if (!toolbar) return;
+      const panel = deps.getPanel();
+      const computed = panel ? window.getComputedStyle(panel) : null;
+      const theme = deps.getState()?.theme;
+      const dark = theme === 'dark' || (theme !== 'light' && window.matchMedia('(prefers-color-scheme: dark)').matches);
+      const colors = dark
+        ? ['#26282b', '#f1f2f4', '#adb4be', '#454b53', '#353a41', '#91b7e1']
+        : ['#ffffff', '#24292f', '#67717e', '#d8dde3', '#f0f3f6', '#2f73b8'];
+      ['--tl-surface-0', '--tl-fg-1', '--tl-fg-3', '--tl-border-strong', '--tl-hover', '--tl-accent']
+        .forEach((name, index) => toolbar.style.setProperty(name, computed?.getPropertyValue(name).trim() || colors[index]));
+      if (computed?.fontFamily) toolbar.style.fontFamily = computed.fontFamily;
+      toolbar.setAttribute('aria-label', tx('Selected text actions', '选区操作'));
+      toolbar.querySelector('[data-selection-action="reference"]').textContent = tx('Add to Chat', '加入对话');
+      toolbar.querySelector('[data-selection-action="edit"]').textContent = tx('Edit Selection', '仅编辑此处');
+    }
+
+    function ensureToolbar() {
+      if (toolbar) return;
+      toolbar = document.createElement('div');
+      toolbar.className = 'codex-selection-actions';
+      toolbar.setAttribute('data-codex-selection-actions', '');
+      toolbar.setAttribute('role', 'toolbar');
+      toolbar.hidden = true;
+      if (typeof toolbar.showPopover === 'function') toolbar.setAttribute('popover', 'manual');
+      for (const mode of ['reference', 'edit']) {
+        if (mode === 'edit') {
+          const divider = document.createElement('span');
+          divider.className = 'codex-selection-action-divider';
+          divider.setAttribute('aria-hidden', 'true');
+          toolbar.append(divider);
+        }
+        const button = document.createElement('button');
+        button.type = 'button';
+        button.dataset.selectionAction = mode;
+        button.addEventListener('click', () => {
+          const selected = candidate;
+          if (selected) void attach(mode, selected);
+        });
+        toolbar.append(button);
+      }
+      document.body.append(toolbar);
+      syncFloatingAppearance();
+    }
+
+    function showFloating(anchor) {
+      ensureToolbar();
+      syncFloatingAppearance();
+      toolbar.hidden = false;
+      if (typeof toolbar.showPopover === 'function' && !toolbar.matches(':popover-open')) toolbar.showPopover();
+      const rect = toolbar.getBoundingClientRect();
+      const width = window.innerWidth, height = window.innerHeight;
+      const left = Math.max(8, Math.min(width - rect.width - 8,
+        (anchor.left + anchor.right) / 2 - rect.width / 2));
+      const preferredTop = anchor.top - rect.height - 8;
+      const top = Math.max(8, Math.min(height - rect.height - 8,
+        preferredTop >= 8 ? preferredTop : anchor.bottom + 8));
+      toolbar.style.left = left + 'px';
+      toolbar.style.top = top + 'px';
+    }
+
+    function schedule(editor) {
+      hideFloating();
+      if (!controller || pointerSelecting || !editor) return;
+      const request = ++probeGeneration;
+      timer = setTimeout(() => { timer = null; void probe(editor, request); }, 90);
+    }
+
+    async function probe(editor, request) {
+      if (!controller || request !== probeGeneration || document.hidden
+        || !editor.isConnected || !editor.contains(document.activeElement)) return;
+      const projectId = deps.getProjectId();
+      const sessionId = deps.getState()?.activeSessionId;
+      try {
+        const response = await deps.callPageBridge('getSelectionContext', { runProjectId: projectId });
+        if (request !== probeGeneration || projectId !== deps.getProjectId()
+          || sessionId !== deps.getState()?.activeSessionId || !editor.isConnected
+          || !editor.contains(document.activeElement)) return;
+        const selection = SelectionContext.normalize(response?.selection || response);
+        const anchor = response?.anchor;
+        if (!response?.ok || !selection || selection.projectId !== projectId || !anchor
+          || !['left', 'right', 'top', 'bottom'].every(key => Number.isFinite(anchor[key]))
+          || anchor.bottom < 0 || anchor.top > window.innerHeight) return;
+        candidate = { selection, anchor, projectId, sessionId };
+        showFloating(anchor);
+      } catch (_) { /* Transient editor states do not interrupt ordinary selection. */ }
+    }
+
+    function start() {
+      if (controller) return;
+      // Replacing a content runtime retires the old selection listener set.
+      document.dispatchEvent(new Event(resetEvent));
+      controller = new AbortController();
+      const options = { capture: true, signal: controller.signal };
+      document.addEventListener(resetEvent, destroy, options);
+      document.addEventListener('pointerdown', event => {
+        if (toolbar?.contains(event.target)) {
+          if (event.button === 0) event.preventDefault();
+          return;
+        }
+        hideFloating();
+        pointerEditor = editorFor(event.target);
+        pointerSelecting = Boolean(pointerEditor && event.button === 0);
+      }, options);
+      document.addEventListener('pointerup', () => {
+        if (!pointerSelecting) return;
+        pointerSelecting = false;
+        const editor = pointerEditor;
+        pointerEditor = null;
+        schedule(editor);
+      }, options);
+      document.addEventListener('pointercancel', () => {
+        pointerSelecting = false;
+        pointerEditor = null;
+        hideFloating();
+      }, options);
+      document.addEventListener('selectionchange', () => {
+        if (pointerSelecting || toolbar?.contains(document.activeElement)) return;
+        schedule(editorFor(document.activeElement));
+      }, options);
+      document.addEventListener('keyup', event => {
+        if (event.key !== 'Escape' && editorFor(event.target)) schedule(editorFor(event.target));
+      }, options);
+      document.addEventListener('keydown', event => {
+        if (event.key === 'Escape') hideFloating();
+      }, options);
+      document.addEventListener('scroll', hideFloating, { ...options, passive: true });
+      document.addEventListener('visibilitychange', () => { if (document.hidden) hideFloating(); }, options);
+      window.addEventListener('resize', hideFloating, { ...options, passive: true });
+      window.addEventListener('blur', hideFloating, options);
+      window.addEventListener('pagehide', event => { if (event.persisted) hideFloating(); else destroy(); }, options);
+    }
+
+    function destroy() {
+      generation += 1;
+      hideFloating();
+      controller?.abort();
+      controller = null;
+      pointerSelecting = false;
+      pointerEditor = null;
+      toolbar?.remove();
+      toolbar = null;
+    }
+
+    return { attach, capture, clear, render, start, destroy, getRevision: () => generation };
+  }
+
+  return { create, buildChip, renderSent };
+});

package/extension/src/content/sensitivePreflight.js

@@ -0,0 +1,140 @@
+(function initCodexOverleafSensitivePreflight(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafSensitivePreflight = factory();
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function sensitivePreflightFactory() {
+  'use strict';
+
+  function create({
+    SensitiveScan, normalizeGovernanceRules, isTextSnapshotFile, sendBackgroundNative,
+    getCurrentProjectId, appendRunEvent, appendCompletionReport, showPluginConfirm, tr, tx
+  }) {
+    async function runSensitivePreflight(options) {
+      options = options || {};
+      const { task, project, rules, useExistingMirror = false, guidance = false } = options;
+      const normalizedRules = normalizeGovernanceRules(rules);
+      if (normalizedRules.sensitiveCheckEnabled === false) {
+        return { blocked: false, findings: [] };
+      }
+      if (!SensitiveScan?.scanSensitiveInputs && !useExistingMirror) {
+        return { blocked: false, findings: [] };
+      }
+      let findings = SensitiveScan?.scanSensitiveInputs
+        ? SensitiveScan.scanSensitiveInputs({
+          task,
+          files: guidance ? [] : (project?.files || []).filter(isTextSnapshotFile)
+        })
+        : [];
+      if (useExistingMirror && !guidance) {
+        findings = dedupeSensitiveFindings([
+          ...findings,
+          ...await scanNativeMirrorSensitiveFindings()
+        ]);
+      }
+      if (!findings.length) {
+        return { blocked: false, findings: [] };
+      }
+      options.assertCurrent?.();
+      appendRunEvent({
+        title: tx(
+          `Sensitive content check found ${findings.length} item(s).`,
+          `敏感内容检查发现 ${findings.length} 项。`
+        ),
+        status: 'failed',
+        detail: findings.slice(0, 8).map(finding => ({
+          [tr('detailFile')]: finding.path || finding.source || 'task',
+          [tr('detailReason')]: finding.detectorId,
+          [tx('Preview', '预览')]: finding.preview || '[REDACTED]'
+        }))
+      });
+      if (normalizedRules.sensitiveConfirmAllowed === true) {
+        const approved = await showPluginConfirm({
+          title: tr('sensitiveConfirmTitle'),
+          message: formatSensitiveConfirmMessage(findings),
+          confirmLabel: guidance ? tx('Send guidance', '发送指导') : tr('sensitiveConfirmRun'),
+          cancelLabel: tr('confirmDefaultCancel'),
+          destructive: true
+        });
+        options.assertCurrent?.();
+        return { blocked: !approved, findings };
+      }
+      // Blocking an extra message must not finish the task already in progress.
+      if (guidance) return { blocked: true, findings };
+      appendCompletionReport({
+        conclusion: tx(
+          'This run was blocked before Codex received project context because sensitive content was detected.',
+          '检测到敏感内容，本轮已在向 Codex 发送项目上下文前阻止。'
+        ),
+        status: 'blocked',
+        operations: [],
+        applyResults: [],
+        nextStep: tx(
+          'Remove the sensitive content, narrow @context, or enable explicit sensitive confirmation in Project Settings.',
+          '请移除敏感内容、缩小 @context，或在项目设置里允许敏感内容显式确认。'
+        )
+      });
+      return { blocked: true, findings };
+    }
+
+    function formatSensitiveConfirmMessage(findings = []) {
+      const visible = findings.slice(0, 8).map(finding => {
+        const path = finding.path || finding.source || 'task';
+        return `${path}: ${finding.detectorId || 'sensitive'} (${finding.preview || '[REDACTED]'})`;
+      });
+      return [
+        tr('sensitiveConfirmMessage'),
+        '',
+        ...visible,
+        findings.length > visible.length ? tx(`${findings.length - visible.length} more finding(s).`, `另有 ${findings.length - visible.length} 项。`) : ''
+      ].filter(Boolean).join('\n');
+    }
+
+    async function scanNativeMirrorSensitiveFindings() {
+      try {
+        const response = await sendBackgroundNative({
+          method: 'mirror.scanSensitive',
+          params: { projectId: getCurrentProjectId() }
+        });
+        if (response?.ok) {
+          return Array.isArray(response.result?.findings) ? response.result.findings : [];
+        }
+        return [{
+          detectorId: 'mirror-sensitive-scan-unavailable',
+          source: 'local-mirror',
+          preview: response?.error?.message || 'Could not scan the local mirror before Codex runs.'
+        }];
+      } catch (error) {
+        return [{
+          detectorId: 'mirror-sensitive-scan-unavailable',
+          source: 'local-mirror',
+          preview: error?.message || 'Could not scan the local mirror before Codex runs.'
+        }];
+      }
+    }
+
+    function dedupeSensitiveFindings(findings = []) {
+      const seen = new Set();
+      const deduped = [];
+      for (const finding of findings || []) {
+        const key = [
+          finding?.detectorId || '',
+          finding?.source || '',
+          finding?.path || '',
+          finding?.preview || ''
+        ].join('\u0000');
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        deduped.push(finding);
+      }
+      return deduped;
+    }
+
+    return { run: runSensitivePreflight };
+  }
+
+  return { create };
+});