codex-overleaf-link 2.1.5 → 2.2.1

package/extension/src/content/markdownText.js

@@ -463,13 +463,56 @@
     return '#';
   }
 
-  function renderMarkdownBlockText(target, value) {
-    const source = normalizeInlineOrderedLists(String(value || '').trim());
-    target.replaceChildren();
-    if (!source) {
+  const renderingDiagnosticKeys = new Set();
+
+  function renderMarkdownBlockText(target, value, renderOptions = {}) {
+    const rawSource = String(value || '').trim();
+    if (!rawSource) {
+      target.replaceChildren();
       return;
     }
 
+    if (!renderOptions.streaming) {
+      const runtimeRoot = typeof window !== 'undefined' ? window : globalThis;
+      const domRenderer = runtimeRoot.CodexOverleafMarkdownDomRenderer;
+      try {
+        if (!domRenderer?.renderMarkdown || typeof runtimeRoot.markdownit !== 'function') {
+          const dependencyError = new Error('The vendored Markdown DOM renderer is unavailable.');
+          dependencyError.code = 'markdown_dom_dependency_missing';
+          throw dependencyError;
+        }
+        domRenderer.renderMarkdown(target, rawSource, {
+          document,
+          markdownIt: runtimeRoot.markdownit,
+          mathText: runtimeRoot.CodexOverleafMathText,
+          renderTextNodes: text => buildMarkdownInlineNodes(text),
+          renderLinkNodes: (label, href) => {
+            const safeLabel = String(label || '');
+            const target = String(href || '').trim();
+            if (!/^https?:\/\//i.test(target) && !resolveMarkdownLineReference(safeLabel, target)) return buildMarkdownInlineNodes(safeLabel);
+            return buildMarkdownInlineNodes(
+              `[${safeLabel.replace(/]/g, '\\]')}](${target.replace(/\)/g, '\\)')})`
+            );
+          },
+          renderCodeNodes: text => buildMarkdownInlineNodes(`\`${String(text || '').replace(/`/g, '\\`')}\``),
+          sanitizeText: sanitizeAssistantVisibleText,
+          createMathNode: segment => runtimeRoot.CodexOverleafMathText.createMathNode(segment, {
+            document, katex: runtimeRoot.katex,
+            renderText: text => buildMarkdownInlineNodes(text)
+          }),
+          recordDiagnostic: recordRenderingDiagnostic
+        });
+        return;
+      } catch (error) {
+        recordRenderingDiagnostic({
+          code: error?.code || 'markdown_dom_fallback',
+          detail: String(error?.message || 'Markdown DOM rendering failed.')
+        });
+      }
+    }
+
+    const source = normalizeInlineOrderedLists(rawSource);
+    target.replaceChildren();
     const lines = source.split(/\r?\n/);
     let index = 0;
 
@@ -533,10 +576,46 @@
         index++;
       }
 
-      const paragraph = document.createElement('p');
-      paragraph.append(...buildMarkdownInlineNodes(paragraphLines.join(' ')));
-      target.append(paragraph);
+      appendMarkdownParagraphFlow(target, paragraphLines.join(' '));
+    }
+  }
+
+  function recordRenderingDiagnostic(diagnostic = {}) {
+    const code = String(diagnostic.code || 'markdown_rendering_diagnostic');
+    const detail = String(diagnostic.detail || '').slice(0, 240);
+    const key = `${code}:${detail}`;
+    if (renderingDiagnosticKeys.has(key)) {
+      return;
+    }
+    renderingDiagnosticKeys.add(key);
+    if (typeof options.recordRenderingDiagnostic === 'function') options.recordRenderingDiagnostic({ code, detail });
+  }
+
+  function appendMarkdownParagraphFlow(target, value) {
+    const nodes = buildMarkdownInlineNodes(value);
+    let paragraph = null;
+    let paragraphHasContent = false;
+    const flushParagraph = () => {
+      if (paragraph && paragraphHasContent) {
+        target.append(paragraph);
+      }
+      paragraph = null;
+      paragraphHasContent = false;
+    };
+
+    for (const node of nodes) {
+      if (node?.dataset?.mathDisplay === 'block') {
+        flushParagraph();
+        target.append(node);
+        continue;
+      }
+      if (!paragraph) {
+        paragraph = document.createElement('p');
+      }
+      paragraph.append(node);
+      paragraphHasContent = true;
     }
+    flushParagraph();
   }
 
   function isMarkdownFenceLine(line) {

package/extension/src/content/mathText.js

@@ -7,6 +7,8 @@
     Object.freeze({ open: '\\(', close: '\\)', display: false, singleDollar: false }),
     Object.freeze({ open: '$', close: '$', display: false, singleDollar: true })
   ]);
+  const LONG_INLINE_MATH_CHARS = 120;
+  const COMPLEX_INLINE_MATH_CHARS = 80;
 
   function parseMathSegments(value) {
     const source = String(value || '');
@@ -186,14 +188,19 @@
   function createMathNode(segment, options = {}) {
     const documentRef = options.document || root.document;
     const node = documentRef.createElement('span');
-    node.className = `run-math ${segment.display ? 'run-math--display' : 'run-math--inline'}`;
-    node.dataset.mathDisplay = segment.display ? 'block' : 'inline';
+    const source = normalizeMathForRendering(segment.value);
+    const display = segment.display || shouldPromoteInlineMath(source);
+    node.className = `run-math ${display ? 'run-math--display' : 'run-math--inline'}`;
+    node.dataset.mathDisplay = display ? 'block' : 'inline';
+    if (display && !segment.display) {
+      node.classList.add('run-math--promoted');
+    }
     try {
       if (typeof options.katex?.render !== 'function') {
         throw new Error('KaTeX is unavailable');
       }
-      options.katex.render(segment.value, node, {
-        displayMode: segment.display,
+      options.katex.render(source, node, {
+        displayMode: display,
         throwOnError: true,
         trust: false,
         strict: 'warn',
@@ -211,6 +218,23 @@
     }
   }
 
+  function normalizeMathForRendering(value) {
+    return String(value || '')
+      .replace(/\r\n?/g, '\n')
+      .replace(/(\S)\s+\|\s+(\S)/g, '$1 \\mid $2');
+  }
+
+  function shouldPromoteInlineMath(value) {
+    const source = String(value || '').trim();
+    if (source.length >= LONG_INLINE_MATH_CHARS) {
+      return true;
+    }
+    if (source.length < COMPLEX_INLINE_MATH_CHARS) {
+      return false;
+    }
+    return /(?:=|\\(?:le|ge|approx|sim|to|Rightarrow|Longrightarrow)\b|\\begin\{(?:aligned|gathered|split|array)\}|\\\\)/.test(source);
+  }
+
   function toNodeArray(value) {
     if (Array.isArray(value)) {
       return value;
@@ -221,9 +245,30 @@
     return [value];
   }
 
+  function matchMathAt(value, index = 0) {
+    const source = String(value || '');
+    const start = Number.isSafeInteger(index) ? index : 0;
+    if (start < 0 || start >= source.length || (source[start] !== '$' && source[start] !== '\\')) {
+      return null;
+    }
+    const segment = parseMathSegments(source.slice(start))[0];
+    if (!segment || segment.type !== 'math' || !segment.raw) {
+      return null;
+    }
+    return {
+      start,
+      end: start + segment.raw.length,
+      raw: segment.raw,
+      value: segment.value,
+      display: Boolean(segment.display)
+    };
+  }
+
   const api = {
     buildMathNodes,
     createMathNode,
+    matchMathAt,
+    normalizeMathForRendering,
     parseMathSegments
   };
   root.CodexOverleafMathText = api;

package/extension/src/content/modelPicker.js

@@ -102,7 +102,7 @@
     updateModelDisplay();
     await persistPanelInputs(changedInput ? { type: 'change', target: changedInput } : undefined);
   }
-  async function loadModelOptions(providerSelection) {
+  async function loadModelOptions(providerSelection, options = {}) {
     const generation = ++modelLoadGeneration;
     const selection = providerSelection || getProviderSelection?.() || null;
     const selectedModel = resolveSelectedModel();
@@ -131,14 +131,17 @@
         && response.result.models.length > 0;
       if (!hasDiscoveredModels && !Support.shouldUseBuiltInFallback(response)) {
         applyUnavailableModelOptions(response?.error);
-        return;
+        return { stale: false, error: response?.error || { code: 'provider_models_unavailable' } };
       }
       const sourceModels = hasDiscoveredModels ? response.result.models : fallbackModels;
       const retainedSelectedModel = retainSelectedModel(sourceModels, currentSelectedModel);
       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.' });
-        return;
+        return {
+          stale: false,
+          error: { code: 'provider_model_catalog_invalid', message: 'The active provider returned no usable models.' }
+        };
       }
       renderModelOptions(normalized.models, retainedSelectedModel, { allowUnknownSelected: false });
       modelDiscovery = {
@@ -151,8 +154,14 @@
         providerRevision: Number(response?.result?.providerRevision || selection?.providerRevision || 0)
       };
       updateModelDisplay();
-      await persistPanelInputs();
-      return { stale: false, providerId: modelDiscovery.providerId };
+      if (options.persist !== false) {
+        await persistPanelInputs();
+      }
+      return {
+        stale: false,
+        providerId: modelDiscovery.providerId,
+        selectedModel: resolveSelectedModel()
+      };
     } catch (error) {
       if (generation !== modelLoadGeneration) {
         return { stale: true };

package/extension/src/content/nativeChannel.js

@@ -14,15 +14,20 @@
     const backgroundEventHandlers = new Map();
 
     function sendNative(payload) {
+      return sendNativeTracked(payload).promise;
+    }
+
+    function sendNativeTracked(payload) {
       const id = cryptoImpl.randomUUID();
       activeRequestId = id;
-      return runtime.sendMessage({
+      const promise = runtime.sendMessage({
         type: 'codex-overleaf/native-request',
         payload: {
           id,
           ...payload
         }
       });
+      return { id, promise };
     }
 
     function sendBackgroundNative(payload, onEvent) {
@@ -71,6 +76,7 @@
       handleBackgroundNativeEvent,
       sendBackgroundNative,
       sendNative,
+      sendNativeTracked,
       shouldHandleNativeEvent
     };
   }

package/extension/src/content/panelRenderer.js

@@ -51,18 +51,6 @@
         <div data-session-slot></div>
         <div class="codex-toast-region" data-toast-region aria-live="polite" aria-atomic="false"></div>
         <section class="codex-thread-section">
-          <div class="codex-thread-title" data-session-label>
-            <button type="button" class="codex-thread-title-trigger" data-session-menu-trigger aria-haspopup="menu" aria-expanded="false">
-              <span class="codex-thread-title-text" data-session-label-text></span>
-              <span class="codex-thread-title-chevron" aria-hidden="true">▾</span>
-            </button>
-            <input type="text" class="codex-thread-title-input" data-session-rename-input maxlength="80" hidden>
-            <div class="codex-thread-title-actions">
-              <button type="button" class="codex-thread-title-action" data-session-rename title="Rename session" aria-label="Rename session">✎</button>
-              <button type="button" class="codex-thread-title-action codex-thread-title-action--delete" data-session-delete title="Delete session" aria-label="Delete session">×</button>
-            </div>
-            <div class="codex-session-menu" data-session-menu hidden></div>
-          </div>
           <div class="col-log" data-log></div>
         </section>
       </div>
@@ -236,6 +224,117 @@
     actions.prepend(button);
   }
 
+  function createConfirmController(options = {}) {
+    let activeResolve = null;
+
+    function isOpen() {
+      return Boolean(activeResolve);
+    }
+
+    function dismiss(value = false) {
+      activeResolve?.(value);
+    }
+
+    function show(config = {}) {
+      if (!options.getPanel?.()) {
+        options.ensurePanelOpen?.();
+      }
+      const panel = options.getPanel?.();
+      if (!panel) {
+        return Promise.resolve(false);
+      }
+      dismiss(false);
+      const tr = options.tr || (key => key);
+      const title = config.title || tr('confirmDefaultTitle');
+      const message = config.message || '';
+      const confirmLabel = config.confirmLabel || tr('confirmDefaultConfirm');
+      const cancelLabel = config.cancelLabel || tr('confirmDefaultCancel');
+      const destructive = config.destructive === true;
+      const doc = panel.ownerDocument || document;
+
+      return new Promise(resolve => {
+        let settled = false;
+        const overlay = doc.createElement('div');
+        overlay.className = 'codex-plugin-confirm';
+        overlay.setAttribute('data-plugin-confirm', 'true');
+        overlay.setAttribute('role', 'dialog');
+        overlay.setAttribute('aria-modal', 'true');
+        overlay.setAttribute('aria-label', title);
+
+        const card = doc.createElement('section');
+        card.className = 'codex-plugin-confirm-card';
+        const head = doc.createElement('div');
+        head.className = 'codex-plugin-confirm-head';
+        const icon = doc.createElement('img');
+        icon.className = 'codex-plugin-confirm-icon';
+        icon.alt = '';
+        icon.setAttribute('aria-hidden', 'true');
+        icon.src = options.getIconUrl?.() || '';
+        const titleWrap = doc.createElement('div');
+        const brand = doc.createElement('div');
+        brand.className = 'codex-plugin-confirm-brand';
+        brand.textContent = tr('confirmBrand');
+        const titleEl = doc.createElement('div');
+        titleEl.className = 'codex-plugin-confirm-title';
+        titleEl.textContent = title;
+        titleWrap.append(brand, titleEl);
+        head.append(icon, titleWrap);
+
+        const body = doc.createElement('div');
+        body.className = 'codex-plugin-confirm-body';
+        body.textContent = String(message);
+        const actions = doc.createElement('div');
+        actions.className = 'codex-plugin-confirm-actions';
+        const cancel = doc.createElement('button');
+        cancel.type = 'button';
+        cancel.className = 'codex-plugin-confirm-cancel';
+        cancel.textContent = cancelLabel;
+        const confirm = doc.createElement('button');
+        confirm.type = 'button';
+        confirm.className = 'codex-plugin-confirm-confirm';
+        if (destructive) confirm.dataset.destructive = 'true';
+        confirm.textContent = confirmLabel;
+        actions.append(cancel, confirm);
+        card.append(head, body, actions);
+        overlay.append(card);
+        panel.append(overlay);
+
+        const cleanup = value => {
+          if (settled) return;
+          settled = true;
+          activeResolve = null;
+          doc.removeEventListener('keydown', onKeydown, true);
+          overlay.remove();
+          resolve(value);
+        };
+        activeResolve = cleanup;
+        const onKeydown = event => {
+          if (event.key === 'Escape') {
+            event.preventDefault();
+            cleanup(false);
+          } else if (event.key === 'Enter') {
+            event.preventDefault();
+            if (!destructive && event.target !== cancel) cleanup(true);
+            else if (event.target === cancel) cleanup(false);
+            else if (event.target === confirm) cleanup(true);
+          } else if (event.key === 'Tab') {
+            event.preventDefault();
+            (event.target === cancel ? confirm : cancel).focus();
+          }
+        };
+        overlay.addEventListener('click', event => {
+          if (event.target === overlay) cleanup(false);
+        });
+        cancel.addEventListener('click', () => cleanup(false));
+        confirm.addEventListener('click', () => cleanup(true));
+        doc.addEventListener('keydown', onKeydown, true);
+        (destructive ? cancel : confirm).focus();
+      });
+    }
+
+    return { dismiss, isOpen, show };
+  }
+
   function destroy(instance) {
     for (const { target, type, listener, options } of instance.listeners.splice(0)) {
       target.removeEventListener?.(type, listener, options);
@@ -246,6 +345,7 @@
 
   window.CodexOverleafPanelRenderer = {
     create,
+    createConfirmController,
     setVisible,
     setBadge,
     setWidth

package/extension/src/content/pendingInputView.js

@@ -0,0 +1,106 @@
+(function initCodexOverleafPendingInputView(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafPendingInputView = factory();
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function pendingInputViewFactory() {
+  'use strict';
+
+  function create(options = {}) {
+    const container = options.container;
+
+    function render(items = [], state = {}) {
+      if (!container) {
+        return;
+      }
+      container.replaceChildren();
+      container.hidden = !items.length;
+      for (const item of items) {
+        const row = document.createElement('article');
+        row.className = 'codex-pending-input';
+        row.dataset.status = item.status || 'queued';
+        const copy = document.createElement('div');
+        copy.className = 'codex-pending-input-copy';
+        const status = document.createElement('span');
+        status.className = 'codex-pending-input-status';
+        status.textContent = item.status === 'paused'
+          ? options.tr?.('queuedInputPaused')
+          : item.status === 'steering'
+            ? options.tr?.('queuedInputGuiding')
+            : item.status === 'executing'
+              ? options.tr?.('queuedInputExecuting')
+            : options.tr?.('queuedInputQueued');
+        const text = document.createElement('span');
+        text.className = 'codex-pending-input-text';
+        text.textContent = item.text;
+        copy.append(status, text);
+        const actions = document.createElement('div');
+        actions.className = 'codex-pending-input-actions';
+        if (item.status === 'paused') {
+          actions.append(createButton(options.tr?.('queuedInputResume'), () => options.onResume?.()));
+        } else if (state.running && item.status === 'queued') {
+          const guide = createIconButton(
+            options.tr?.('queuedInputGuide'),
+            'guide',
+            () => options.onGuide?.(item.id)
+          );
+          guide.disabled = !state.canGuide;
+          guide.title = state.canGuide
+            ? options.tr?.('queuedInputGuideTitle')
+            : options.tr?.('queuedInputGuideUnavailable');
+          actions.append(guide);
+        }
+        const remove = createIconButton(
+          options.tr?.('queuedInputRemove'),
+          'remove',
+          () => options.onRemove?.(item.id)
+        );
+        remove.classList.add('codex-pending-input-remove');
+        remove.disabled = item.status === 'steering' || item.status === 'executing';
+        text.title = item.text;
+        actions.append(remove);
+        row.append(copy, actions);
+        container.append(row);
+      }
+    }
+
+    return { render };
+  }
+
+  function createButton(label, onClick) {
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.textContent = label || '';
+    button.addEventListener('click', onClick);
+    return button;
+  }
+
+  function createIconButton(label, icon, onClick) {
+    const button = createButton('', onClick);
+    button.className = 'codex-pending-input-icon';
+    button.dataset.action = icon;
+    button.title = label || '';
+    button.setAttribute('aria-label', label || '');
+    button.append(createIcon(icon));
+    return button;
+  }
+
+  function createIcon(icon) {
+    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    svg.setAttribute('viewBox', '0 0 20 20');
+    svg.setAttribute('aria-hidden', 'true');
+    svg.setAttribute('focusable', 'false');
+    const paths = icon === 'guide'
+      ? ['M4 4.5v4a4 4 0 0 0 4 4h7', 'm12 9 3.5 3.5L12 16']
+      : ['M6 6h8', 'M8 6V4.5h4V6', 'm7.2 8 0.6 7.5h4.4l.6-7.5'];
+    for (const value of paths) {
+      const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+      path.setAttribute('d', value);
+      svg.append(path);
+    }
+    return svg;
+  }
+
+  return { create };
+});

package/extension/src/content/projectProviderSelection.js

@@ -0,0 +1,68 @@
+(function initCodexOverleafProjectProviderSelection() {
+  'use strict';
+
+  function create(deps = {}) {
+    async function confirmSwitch({ providerName } = {}) {
+      if ((deps.getRunningSessionIds?.() || []).length) {
+        deps.showToast?.(deps.tx(
+          'Wait for the running task to finish before switching providers.',
+          '请等待正在运行的任务结束后再切换模型服务。'
+        ), { status: 'warning' });
+        return false;
+      }
+      return deps.showConfirm?.({
+        title: deps.tx('Switch provider for this project?', '切换当前项目的模型服务？'),
+        message: deps.tx(
+          `All sessions in this project will use ${providerName || 'the selected provider'}. The model, reasoning, and speed choices may change; existing run history stays unchanged, while future turns start fresh provider threads and may behave differently.`,
+          `当前项目的所有会话都将使用 ${providerName || '所选模型服务'}。模型、推理强度和速度选项可能变化；已有运行历史保持不变，后续轮次会创建新的服务线程，输出效果也可能变化。`
+        ),
+        confirmLabel: deps.tx('Switch provider', '切换模型服务'),
+        cancelLabel: deps.tr('confirmDefaultCancel')
+      });
+    }
+
+    function commit(providerId, model) {
+      const state = deps.getState?.() || {};
+      const nextProviderId = providerId || 'builtin';
+      const providerChanged = nextProviderId !== (state.providerId || 'builtin');
+      const nextModel = model || deps.readSelectedModel?.() || state.model || '';
+      const nextReasoningEffort = deps.getPanel?.()?.querySelector('[data-reasoning]')?.value || state.reasoningEffort;
+      const nextSpeedTier = deps.readSelectedSpeed?.() || state.speedTier;
+      const runSelection = deps.getRunSelection?.(nextProviderId);
+      const nextProviderRevision = Number(runSelection?.providerRevision || 0);
+      const sessions = (state.sessions || []).map(session => ({
+        ...session,
+        providerId: nextProviderId,
+        model: nextModel,
+        reasoningEffort: nextReasoningEffort,
+        speedTier: nextSpeedTier,
+        codexThreadId: providerChanged ? '' : session.codexThreadId,
+        pendingInputs: (session.pendingInputs || []).map(item => ({
+          ...item,
+          payload: {
+            ...(item.payload || {}),
+            providerId: nextProviderId,
+            providerRevision: nextProviderRevision,
+            model: nextModel,
+            reasoningEffort: nextReasoningEffort,
+            speedTier: nextSpeedTier
+          }
+        }))
+      }));
+      deps.setState?.(deps.normalizeState({
+        ...state,
+        providerId: nextProviderId,
+        providerRevision: nextProviderRevision,
+        model: nextModel,
+        reasoningEffort: nextReasoningEffort,
+        speedTier: nextSpeedTier,
+        sessions
+      }));
+      deps.applyStateToPanel?.();
+    }
+
+    return { confirmSwitch, commit };
+  }
+
+  window.CodexOverleafProjectProviderSelection = { create };
+})();

package/extension/src/content/projectSessionCleanup.js

@@ -49,6 +49,10 @@
       if (!approved) {
         return;
       }
+      const Migration = window.CodexOverleafStorageMigration;
+      if (Migration?.addSessionTombstones) {
+        await Migration.addSessionTombstones(projectId, records.map(record => record.id));
+      }
       try {
         await mutateProjectPanelState(projectId, state => records.reduce(
           (nextState, record) => SessionState.deleteSession(nextState, record.id),