codex-overleaf-link 2.3.6 → 2.4.1

package/extension/src/content/generated/content.bundle.meta.json

@@ -2,9 +2,9 @@
   "schemaVersion": 1,
   "entry": "extension/entries/content-entry.mjs",
   "output": "extension/src/content/generated/content.bundle.js",
-  "sourceDigest": "15c3e103532c84dea57aeac33e02ec665fbf7518543e14daac2459c434b3e5d5",
-  "outputDigest": "5e1dba4bfcf4c595835312deabefa5ecdd2ee7c6d98f29d1b2bd9711ad5b195c",
-  "byteLength": 2375784,
+  "sourceDigest": "b19a018ab6eb9c7bdca8cfad8ff6efcc4a30e80f81c3c0a2e89a7f78b6361d97",
+  "outputDigest": "7640649ee012b3224d696703c2a1ab323d549418a3fcc31e2219bf14399416b5",
+  "byteLength": 2422231,
   "inputs": [
     "extension/entries/content-entry.mjs",
     "extension/src/content/activeTurnControl.js",
@@ -62,6 +62,7 @@
     "extension/src/content/sessionPersistence.js",
     "extension/src/content/settingsPanel.js",
     "extension/src/content/themeController.js",
+    "extension/src/content/trackedChangeCaptureController.js",
     "extension/src/content/updateIdle.js",
     "extension/src/content/updateNotice.js",
     "extension/src/content/writebackController.js",

package/extension/src/content/legacyGlobalRegistry.js

@@ -75,6 +75,7 @@
     'StorageMigration',
     'Summary',
     'Theme',
+    'TrackedChangeCaptureController',
     'UndoOperations',
     'UpdateIdle',
     'UpdateNotice',

package/extension/src/content/modelPicker.js

@@ -134,7 +134,8 @@
         return { stale: false, error: response?.error || { code: 'provider_models_unavailable' } };
       }
       const sourceModels = hasDiscoveredModels ? response.result.models : fallbackModels;
-      const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel);
+      const preserveBuiltin = (selection?.providerId || 'builtin') === 'builtin' && (getState()?.providerId || 'builtin') === 'builtin';
+      const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel, { preserveUnavailable: preserveBuiltin });
       const normalized = modelCatalog.normalizeDiscoveredModels({ models: sourceModels, selectedModel: retainedSelectedModel });
       if (normalized.usedFallback && response.result?.providerId && response.result.providerId !== 'builtin') {
         applyUnavailableModelOptions({ code: 'provider_model_catalog_invalid', message: 'The active provider returned no usable models.' });
@@ -143,9 +144,12 @@
           error: { code: 'provider_model_catalog_invalid', message: 'The active provider returned no usable models.' }
         };
       }
-      renderModelOptions(normalized.models, retainedSelectedModel, { allowUnknownSelected: false });
+      const renderedModels = preserveBuiltin
+        ? Support.preserveSelectedCapabilities(normalized.models, retainedSelectedModel, getState(), !hasDiscoveredModels || response.result?.source === 'fallback')
+        : normalized.models;
+      renderModelOptions(renderedModels, retainedSelectedModel, { allowUnknownSelected: false });
       modelDiscovery = {
-        status: hasDiscoveredModels && !normalized.usedFallback ? 'discovered' : 'fallback',
+        status: hasDiscoveredModels && !normalized.usedFallback && response.result?.source !== 'fallback' ? 'discovered' : 'fallback',
         source: hasDiscoveredModels ? response.result?.source || 'unknown' : 'fallback',
         fetchedAt: hasDiscoveredModels ? response.result?.fetchedAt || '' : '',
         errorCode: hasDiscoveredModels ? '' : response?.error?.code || '',
@@ -172,15 +176,16 @@
   }
 
   function applyUnavailableModelOptions(error) {
+    const selectedModel = resolveSelectedModel();
     const modelSelect = getPanel()?.querySelector('[data-model]');
     if (modelSelect) {
       modelSelect.textContent = '';
       const option = document.createElement('option');
-      option.value = resolveSelectedModel();
+      option.value = selectedModel;
       option.textContent = tx('Models unavailable', '模型不可用');
       option.disabled = true;
       modelSelect.append(option);
-      modelSelect.value = '';
+      modelSelect.value = selectedModel;
       modelSelect.disabled = true;
     }
     modelDiscovery = {
@@ -190,8 +195,15 @@
       errorCode: error?.code || '',
       errorMessage: error?.message || (error ? String(error) : '')
     };
-    renderReasoningOptions([]);
-    renderSpeedOptions([]);
+    const pendingModels = Support.preserveSelectedCapabilities(
+      [{ id: selectedModel, unverified: true }], selectedModel, getState(), true
+    );
+    renderReasoningOptions(pendingModels);
+    renderSpeedOptions(pendingModels);
+    for (const selector of ['[data-reasoning]', '[data-speed]']) {
+      const input = getPanel()?.querySelector(selector);
+      if (input) input.disabled = true;
+    }
     renderModelConfigChoices();
     updateModelDisplay();
   }
@@ -200,9 +212,9 @@
     const modelCatalog = getModelCatalog();
     const fallbackModels = modelCatalog.FALLBACK_MODELS;
     const sourceModels = fallbackModels;
-    const retainedSelectedModel = retainSelectedModel(sourceModels, selectedModel);
+    const retainedSelectedModel = retainSelectedModel(sourceModels, selectedModel, { preserveUnavailable: (getState()?.providerId || 'builtin') === 'builtin' });
     const normalized = modelCatalog.normalizeDiscoveredModels({ models: sourceModels, selectedModel: retainedSelectedModel });
-    renderModelOptions(normalized.models, retainedSelectedModel);
+    renderModelOptions(Support.preserveSelectedCapabilities(normalized.models, retainedSelectedModel, getState(), true), retainedSelectedModel);
     modelDiscovery = {
       status: 'fallback',
       source: 'fallback',

package/extension/src/content/modelPickerSupport.js

@@ -29,14 +29,49 @@
     return String(label || '').replace(/^gpt[-\s]*/i, '');
   }
 
-  function retainSelectedModel(models, selectedModel) {
+  function retainSelectedModel(models, selectedModel, options = {}) {
     const selectedId = normalizeModelOptionId(selectedModel);
     if (!selectedId) return '';
+    if (options.preserveUnavailable === true) return selectedId;
     return (Array.isArray(models) ? models : []).some(model => (
       normalizeModelOptionId(typeof model === 'string' ? model : model?.id) === selectedId
     )) ? selectedId : '';
   }
 
+  // A fallback or missing catalog entry cannot revoke an explicit selection.
+  // Keep its saved controls provisional until real capability data arrives.
+  function preserveSelectedCapabilities(models, selectedModel, preferences = {}, provisional = false) {
+    const selectedId = normalizeModelOptionId(selectedModel);
+    const saved = preferences || {};
+    return (Array.isArray(models) ? models : []).map(model => {
+      if (model.id !== selectedId || (!provisional && !model.unverified)) return model;
+      const reasoningEfforts = normalizeReasoningEffortsForSelect([
+        ...(model.reasoningEfforts || []), saved.reasoningEffort
+      ]);
+      const speedTiers = normalizeSpeedTiersForSelect(model.speedTiers);
+      const speed = ['standard', 'fast'].includes(saved.speedTier) ? saved.speedTier : '';
+      if (speed && !speedTiers.includes(speed)) speedTiers.push(speed);
+      return {
+        ...model, unverified: true, reasoningEfforts, speedTiers,
+        defaultReasoningEffort: reasoningEfforts.includes(saved.reasoningEffort)
+          ? saved.reasoningEffort : model.defaultReasoningEffort,
+        defaultSpeedTier: speed || model.defaultSpeedTier || 'standard'
+      };
+    });
+  }
+
+  function getRenderedModelEntries(panel) {
+    return Array.from(panel?.querySelector('[data-model]')?.options || []).map(option => ({
+      id: option.value,
+      label: option.textContent,
+      reasoningEfforts: (option.dataset.reasoningEfforts || '').split(',').filter(Boolean),
+      defaultReasoningEffort: option.dataset.defaultReasoningEffort || '',
+      reasoningPresentation: option.dataset.reasoningPresentation || '',
+      speedTiers: (option.dataset.speedTiers || 'standard').split(',').filter(Boolean),
+      defaultSpeedTier: option.dataset.defaultSpeedTier || 'standard'
+    }));
+  }
+
   function shouldUseBuiltInFallback(response) {
     const providerId = normalizeModelOptionId(response?.result?.providerId);
     return response?.ok === true && (!providerId || providerId === 'builtin');
@@ -114,6 +149,8 @@
     normalizeReasoningEffortsForSelect,
     normalizeSpeedTiersForSelect,
     retainSelectedModel,
+    preserveSelectedCapabilities,
+    getRenderedModelEntries,
     shouldUseBuiltInFallback
   };
   return api;

package/extension/src/content/nativeCompatibilityController.js

@@ -23,7 +23,10 @@
     async function dispatch(payload, channelMethod) {
       const compatibilityGate = await ensureForMethod(payload?.method);
       if (!compatibilityGate.ok) return compatibilityGate.response;
-      if (gatedMethods.has(payload?.method)) options.throwIfCancellationRequested?.();
+      // Post-Undo cache bookkeeping must survive the ended run's cancellation.
+      if (gatedMethods.has(payload?.method) && payload.method !== 'mirror.invalidate') {
+        options.throwIfCancellationRequested?.();
+      }
       return nativeChannel[channelMethod](
         attachEvidence(payload, compatibilityGate.compatibility)
       );

package/extension/src/content/otWarmMirror.js

@@ -1,6 +1,5 @@
 (function initCodexOverleafOtWarmMirror() {
   'use strict';
-
   // Experimental OT warm-mirror glue carved out of contentRuntime.js (v1.4.9
   // structural-debt phase 5): the per-project enable toggle flow, the
   // poll/flush timers and patch queue, mirror prefetch, warm-start
@@ -52,6 +51,7 @@
   let currentOtStatus = 'off';
   let otTogglePending = false;
   let otSyncRequestId = 0;
+  let otStartRetryCount = 0;
   let otWarmMirrorProjectId = '';
   let lastExperimentalOtProjectId = '';
   let otWarmMirrorState = {
@@ -226,6 +226,7 @@
     const projectId = getCurrentProjectId();
     otWarmMirrorState.failureActive = false;
     lastExperimentalOtProjectId = projectId;
+    otStartRetryCount = 0;
     setExperimentalOtEnabledForProject(projectId, checkbox.checked);
     updateExperimentalOtToggleControl(checkbox.checked);
     // Per-card saved feedback, same contract as every other settings card.
@@ -306,8 +307,10 @@
       await pauseOtWarmMirror(pauseAfterStart.reason || 'paused');
       return response;
     }
-    otWarmMirrorState.failureActive = false;
+    if (status === 'starting') recordOtFailure('missing_active_path', 'start');
+    else otWarmMirrorState.failureActive = false;
     updateOtStatusDisplay(status);
+    otStartRetryCount = 0;
     scheduleOtEventPolling(projectId, { immediate: true });
     return response;
   }
@@ -338,21 +341,36 @@
     clearOtEventPolling({ clearPatchQueue: true });
     recordOtFailure(readOtBridgeErrorCode(response, 'ot_start_failed'), 'start');
     otWarmMirrorState.suspended = true;
-    setExperimentalOtEnabledForProject(projectId, false);
-    const experimentalOtCheckbox = getPanel()?.querySelector('[data-experimental-ot]');
-    if (experimentalOtCheckbox) {
-      experimentalOtCheckbox.checked = false;
-    }
+    // Observer availability is transient; only an explicit user action may
+    // change the persisted opt-in. A cold editor/bridge must not turn OT off
+    // permanently. failureActive/suspended already prohibit cache reuse.
+    updateExperimentalOtToggleControl(isExperimentalOtEnabledForProject(projectId));
     updateOtStatusDisplay('unavailable');
-    saveStateSoon();
     try { await callPageBridge('stopOtObserver', { projectId }); } catch (_error) { /* preserve the original failure */ }
+    scheduleOtStartRetry(projectId, requestId);
+  }
+
+  function scheduleOtStartRetry(projectId, requestId) {
+    const retryDelays = [1000, 3000, 6000];
+    const canRetry = () => isCurrentOtSync(requestId, projectId) && getCurrentProjectId() === projectId
+      && isExperimentalOtEnabledForProject(projectId) && !getCurrentRunView();
+    if (!canRetry() || otStartRetryCount >= retryDelays.length) return;
+    // Use the existing owned timer so disabling OT, changing projects and
+    // starting a new observation all cancel pending retries normally.
+    const delayMs = retryDelays[otStartRetryCount++];
+    otWarmMirrorState.pollTimer = window.setTimeout(() => {
+      otWarmMirrorState.pollTimer = null;
+      if (!canRetry()) return;
+      syncOtWarmMirrorController().catch(() => {
+        if (getCurrentProjectId() === projectId && isExperimentalOtEnabledForProject(projectId)) {
+          updateOtStatusDisplay('unavailable');
+        }
+      });
+    }, delayMs);
   }
 
   function readOtBridgeStatus(response) {
-    if (!response || response.ok === false) {
-      return 'unavailable';
-    }
-    return response.state || response.status || response.result?.state || response.result?.status || 'unavailable';
+    return otWarmMirrorController.readOtBridgeStatus(response);
   }
 
   function ensureOtWarmMirrorStateProject(projectId) {
@@ -361,6 +379,7 @@
     }
     clearOtEventPolling({ clearPatchQueue: true });
     otWarmMirrorState.projectId = projectId;
+    otStartRetryCount = 0;
     otWarmMirrorState.lastPatchAt = 0;
     otWarmMirrorState.lastErrorCode = '';
     otWarmMirrorState.failureActive = false;
@@ -438,6 +457,7 @@
         return statusResponse;
       }
       const status = readOtBridgeStatus(statusResponse);
+      if (status === 'observing' && otWarmMirrorState.lastFailure?.phase === 'start') Object.assign(otWarmMirrorState, { failureActive: false, lastErrorCode: '', lastFailure: null });
       if (['unavailable', 'inconsistent'].includes(status)) recordOtFailure(readOtBridgeErrorCode(statusResponse, 'ot_observer_unavailable'), 'observe');
       if (status) {
         updateOtStatusDisplay(status);
@@ -470,27 +490,11 @@
   }
 
   function readOtBridgeEvents(response) {
-    if (Array.isArray(response)) {
-      return response;
-    }
-    if (Array.isArray(response?.events)) {
-      return response.events;
-    }
-    if (Array.isArray(response?.result?.events)) {
-      return response.result.events;
-    }
-    return [];
+    return otWarmMirrorController.readOtBridgeEvents(response);
   }
-
   function readOtBridgeErrorCode(response, fallback) {
-    const value = response?.lastErrorCode
-      || response?.reason
-      || response?.error?.code
-      || response?.error
-      || fallback;
-    return typeof value === 'string' ? value : fallback;
+    return otWarmMirrorController.readOtBridgeErrorCode(response, fallback);
   }
-
   function recordOtFailure(code, phase) {
     code = otWarmMirrorController.normalizeFailureCode(code);
     otWarmMirrorState.lastErrorCode = code;

package/extension/src/content/otWarmMirrorController.js

@@ -174,6 +174,23 @@
     return { ok: true };
   }
 
+  function readOtBridgeStatus(response) {
+    if (!response || response.ok === false) return 'unavailable';
+    return response.state || response.status || response.result?.state || response.result?.status || 'unavailable';
+  }
+
+  function readOtBridgeEvents(response) {
+    if (Array.isArray(response)) return response;
+    if (Array.isArray(response?.events)) return response.events;
+    if (Array.isArray(response?.result?.events)) return response.result.events;
+    return [];
+  }
+
+  function readOtBridgeErrorCode(response, fallback) {
+    const value = response?.lastErrorCode || response?.reason || response?.error?.code || response?.error || fallback;
+    return typeof value === 'string' ? value : fallback;
+  }
+
   function normalizeFailureCode(value, fallback = 'ot_error') {
     const code = typeof value === 'string' ? value : value?.code;
     if (/^[a-z][a-z0-9_]{0,79}$/.test(code || '')) return code;
@@ -265,6 +282,9 @@
     takePatchBatch,
     validatePatchReceipt,
     normalizeFailureCode,
+    readOtBridgeStatus,
+    readOtBridgeEvents,
+    readOtBridgeErrorCode,
     getFailureMessageKey,
     buildPatchFilesRequest,
     canUseOtWarmStart,

package/extension/src/content/pageBridgeClient.js

@@ -21,9 +21,11 @@
     ['src/page/overleafProjectSnapshot.js', 'codex-overleaf-project-snapshot-script'],
     ['src/page/pageBridgeCapability.js', 'codex-overleaf-page-bridge-capability-script'],
     ['src/page/treeOperations.js', 'codex-overleaf-tree-operations-script', true],
+    ['src/page/textFileCreator.js', 'codex-overleaf-text-file-creator-script', true],
     ['src/page/binaryAssetUploader.js', 'codex-overleaf-binary-asset-uploader-script', true],
     ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
     ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
+    ['src/page/trackedChangeCapture.js', 'codex-overleaf-tracked-change-capture-script', true],
     ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],
     ['src/page/writebackRouter.js', 'codex-overleaf-writeback-router-script', true],
     ['src/pageBridge.js', 'codex-overleaf-page-bridge-script', true]

package/extension/src/content/panelMaintenance.js

@@ -137,15 +137,19 @@
     }
     const requestId = ++storageUsageRequestId;
     const projectId = getCurrentProjectId?.();
+    const settingsScope = getPanel?.()?.dataset?.settingsScope;
     const isCurrent = () => requestId === storageUsageRequestId && projectId === getCurrentProjectId?.()
+      && settingsScope === getPanel?.()?.dataset?.settingsScope
       && getSettingsPanelInstance()?.container?.querySelector('[data-storage-usage]') === node;
     const current = getState();
     const sessionCount = Array.isArray(current?.sessions) ? current.sessions.length : 0;
     const runCount = Array.isArray(current?.runs) ? current.runs.length : 0;
-    const counts = tx(
-      `${sessionCount} loaded session(s) in this project · ${runCount} run(s) in the active session`,
-      `当前项目已加载 ${sessionCount} 个会话 · 当前会话 ${runCount} 轮运行`
-    );
+    const counts = settingsScope === 'account'
+      ? tx('All projects in this browser', '当前浏览器中的所有项目')
+      : tx(
+        `${sessionCount} loaded session(s) in this project · ${runCount} run(s) in the active session`,
+        `当前项目已加载 ${sessionCount} 个会话 · 当前会话 ${runCount} 轮运行`
+      );
     // Dynamic text belongs to this renderer, not the loading-label translator.
     node.removeAttribute?.('data-i18n');
     node.textContent = counts;