codex-overleaf-link 2.3.1 → 2.3.2

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

@@ -2,13 +2,14 @@
   "schemaVersion": 1,
   "entry": "extension/entries/content-entry.mjs",
   "output": "extension/src/content/generated/content.bundle.js",
-  "sourceDigest": "ddbc07ac8d34d864aa3648c53211c5858e0312a73df815a0392bc52ec5eac1cc",
-  "outputDigest": "42051c8624bdfca3094c8bef2430094e55b7e1ec49d475ac27f6df14629bf313",
-  "byteLength": 2285557,
+  "sourceDigest": "d2167fca49721d0ef5e477dc76b11a0cedb33c9f51b920b55ea666ab4668dc4c",
+  "outputDigest": "87cbcf7d9877860b7c1d047cd3fa6e985e28812c8df81c9105ec9312a5e45ea6",
+  "byteLength": 2309285,
   "inputs": [
     "extension/entries/content-entry.mjs",
     "extension/src/content/activeTurnControl.js",
     "extension/src/content/applyResultFormatters.js",
+    "extension/src/content/assetTransferBroker.js",
     "extension/src/content/composerAttachments.js",
     "extension/src/content/composerPanel.js",
     "extension/src/content/contentRuntime.js",
@@ -45,11 +46,13 @@
     "extension/src/content/runGuidanceController.js",
     "extension/src/content/runGuidanceView.js",
     "extension/src/content/runQueueScheduler.js",
+    "extension/src/content/runResultActions.js",
     "extension/src/content/runSettlementPersistence.js",
     "extension/src/content/runTimelineView.js",
     "extension/src/content/scopedPersistenceCoordinator.js",
     "extension/src/content/scopedPersistenceDetachedCommit.js",
     "extension/src/content/scopedPersistencePanelState.js",
+    "extension/src/content/sessionForkController.js",
     "extension/src/content/sessionManager.js",
     "extension/src/content/sessionMenuView.js",
     "extension/src/content/sessionPanel.js",

package/extension/src/content/legacyGlobalRegistry.js

@@ -15,6 +15,7 @@
     'ActiveTurnControl',
     'AgentTranscript',
     'ApplyResultFormatters',
+    'AssetTransferBroker',
     'AuditRecords',
     'Compatibility',
     'ComposerAttachments',
@@ -53,12 +54,14 @@
     'RunGuidanceController',
     'RunInputQueue',
     'RunQueueScheduler',
+    'RunResultActions',
     'RunSettlementPersistence',
     'RunTimelineView',
     'ScopedPersistenceCoordinator',
     'ScopedPersistenceTransaction',
     'SensitiveScan',
     'SessionManager',
+    'SessionForkController',
     'SessionPanel',
     'SessionPersistence',
     'SessionState',

package/extension/src/content/modelPicker.js

@@ -452,8 +452,8 @@
       if (effort === 'xhigh') return 'Max';
     }
     const labels = getLocale() === 'zh'
-      ? { none: '关闭', minimal: '最小', low: '低', medium: '中', high: '高', xhigh: '超高' }
-      : { none: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'XHigh' };
+      ? { none: '关闭', minimal: '最小', low: '低', medium: '中', high: '高', xhigh: '超高', max: '最大', ultra: '极限' }
+      : { none: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'XHigh', max: 'Max', ultra: 'Ultra' };
     return labels[effort] || effort || '';
   }
 

package/extension/src/content/modelPickerSupport.js

@@ -19,7 +19,7 @@
   }
 
   function normalizeReasoningEffortsForSelect(efforts) {
-    const allowed = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
+    const allowed = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
     return Array.from(new Set((Array.isArray(efforts) ? efforts : [])
       .map(effort => normalizeModelOptionId(effort))
       .filter(effort => allowed.has(effort))));
@@ -92,12 +92,12 @@
       const normalized = {
         id,
         label: typeof model?.label === 'string' && model.label.length > 0 ? model.label : id,
-        reasoningEfforts: Array.isArray(model?.reasoningEfforts) ? model.reasoningEfforts.slice() : [],
+        reasoningEfforts: normalizeReasoningEffortsForSelect(model?.reasoningEfforts),
         reasoningPresentation: typeof model?.reasoningPresentation === 'string' ? model.reasoningPresentation : '',
         speedTiers: normalizeSpeedTiersForSelect(model?.speedTiers)
       };
       if (Object.prototype.hasOwnProperty.call(Object(model), 'defaultReasoningEffort')) {
-        normalized.defaultReasoningEffort = model.defaultReasoningEffort;
+        normalized.defaultReasoningEffort = normalizeModelOptionId(model.defaultReasoningEffort);
       }
       if (Object.prototype.hasOwnProperty.call(Object(model), 'defaultSpeedTier')) {
         normalized.defaultSpeedTier = model.defaultSpeedTier;

package/extension/src/content/pageBridgeClient.js

@@ -21,6 +21,7 @@
     ['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/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/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],

package/extension/src/content/runResultActions.js

@@ -0,0 +1,114 @@
+(function initCodexOverleafRunResultActions(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafRunResultActions = api;
+})(typeof window !== 'undefined' ? window : globalThis, function runResultActionsFactory() {
+  'use strict';
+
+  function create(deps = {}) {
+    const {
+      tr,
+      getLocale,
+      forkRunFromNode,
+      document: documentRef = globalThis.document,
+      navigator: navigatorRef = globalThis.navigator
+    } = deps;
+
+    function configureResultActions(root, run) {
+      const actions = root.querySelector('.run-result-actions');
+      const reports = root.querySelectorAll('.run-completion-report');
+      const report = reports[reports.length - 1];
+      if (!actions || !report) return;
+      report.append(actions);
+      actions.hidden = false;
+      configureCopyButton(root);
+      configureForkButton(root, run);
+      configureCompletedTime(actions, run);
+    }
+
+    function configureForkButton(root, run) {
+      const existing = root.querySelector('[data-run-fork]');
+      const button = existing.cloneNode(true);
+      existing.replaceWith(button);
+      const available = run.forkSnapshot !== true
+        && run.status !== 'running'
+        && Boolean(run.codexTurnId)
+        && typeof forkRunFromNode === 'function';
+      button.hidden = false;
+      button.disabled = !available;
+      button.title = tr(available ? 'forkRunTitle' : 'forkRunUnavailable');
+      button.setAttribute('aria-label', button.title);
+      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><path d="M3 10h3.5c3.5 0 4.2-4 7.5-4h2m-2.5-2.5L16 6l-2.5 2.5M6.5 10c3.5 0 4.2 4 7.5 4h2m-2.5-2.5L16 14l-2.5 2.5"/></svg>';
+      if (!available) return;
+      button.addEventListener('click', async event => {
+        event.stopPropagation();
+        button.disabled = true;
+        button.classList.add('is-running');
+        try {
+          await forkRunFromNode(run.id);
+        } catch (_error) {
+          button.disabled = false;
+          button.classList.remove('is-running');
+        }
+      });
+    }
+
+    function configureCompletedTime(actions, run) {
+      const target = actions.querySelector('[data-run-completed-time]');
+      const finishedAt = String(run.finishedAt || '').trim();
+      const date = finishedAt ? new Date(finishedAt) : null;
+      if (!target || !date || !Number.isFinite(date.getTime())) return;
+      target.hidden = false;
+      target.textContent = new Intl.DateTimeFormat(getLocale(), {
+        hour: '2-digit',
+        minute: '2-digit'
+      }).format(date);
+      target.title = date.toLocaleString(getLocale());
+    }
+
+    function configureCopyButton(root) {
+      const existing = root.querySelector('[data-run-copy]');
+      const button = existing.cloneNode(true);
+      existing.replaceWith(button);
+      const finalAnswer = root.querySelector('.run-completion-report .run-final-answer');
+      const copyText = String(finalAnswer?.innerText || finalAnswer?.textContent || '').trim();
+      button.hidden = false;
+      button.disabled = !copyText;
+      button.title = tr('copyConclusionTitle');
+      button.setAttribute('aria-label', button.title);
+      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><rect x="6.5" y="6.5" width="9" height="9" rx="2"/><path d="M13.5 6.5V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6.5a2 2 0 0 0 2 2h1.5"/></svg>';
+      if (!copyText) return;
+      button.addEventListener('click', async event => {
+        event.stopPropagation();
+        try {
+          await writeClipboardText(copyText);
+          button.title = tr('copyConclusionDone');
+        } catch (_error) {
+          button.title = tr('copyConclusionFailed');
+        }
+        button.setAttribute('aria-label', button.title);
+      });
+    }
+
+    async function writeClipboardText(text) {
+      if (navigatorRef?.clipboard?.writeText) {
+        await navigatorRef.clipboard.writeText(text);
+        return;
+      }
+      const textarea = documentRef.createElement('textarea');
+      textarea.value = text;
+      textarea.setAttribute('readonly', '');
+      textarea.style.position = 'fixed';
+      textarea.style.opacity = '0';
+      documentRef.body.append(textarea);
+      textarea.select();
+      const copied = documentRef.execCommand('copy');
+      textarea.remove();
+      if (!copied) throw new Error('clipboard_copy_failed');
+    }
+
+    return Object.freeze({ configureResultActions });
+  }
+
+  return Object.freeze({ create });
+});

package/extension/src/content/runTimelineView.js

@@ -13,6 +13,7 @@
   function create(deps = {}) {
     const {
       RunGuidanceView,
+      RunResultActions,
       tr,
       tx,
       getLocale,
@@ -346,6 +347,11 @@
           </summary>
         </details>
         <div class="run-activity-list" data-run-events></div>
+        <div class="run-result-actions" hidden>
+          <button type="button" class="run-copy-action" data-run-copy hidden></button>
+          <button type="button" class="run-fork-action" data-run-fork hidden></button>
+          <span class="run-completed-time" data-run-completed-time hidden></span>
+        </div>
         <div class="run-report" data-run-report aria-live="polite" hidden></div>
       </div>
     `;
@@ -399,6 +405,7 @@
       }
     }
 
+    RunResultActions.configureResultActions(root, run);
     configureAcceptButton(root, run);
     configureUndoButton(root, run);
     return root;
@@ -886,6 +893,11 @@
     const button = existing.cloneNode(true);
     existing.replaceWith(button);
 
+    if (run.forkSnapshot === true) {
+      button.hidden = true;
+      return;
+    }
+
     if (isTrackedChangeLifecycleRun(run)) {
       configureLifecycleUndoButton(button, run);
       return;
@@ -982,6 +994,11 @@
     const button = existing.cloneNode(true);
     existing.replaceWith(button);
 
+    if (run.forkSnapshot === true) {
+      button.hidden = true;
+      return;
+    }
+
     if (!isTrackedChangeLifecycleRun(run)) {
       button.hidden = true;
       return;

package/extension/src/content/sessionForkController.js

@@ -0,0 +1,120 @@
+(function initCodexOverleafSessionForkController(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafSessionForkController = api;
+})(typeof window !== 'undefined' ? window : globalThis, function sessionForkControllerFactory() {
+  'use strict';
+
+  function create(deps = {}) {
+    const {
+      SessionState, getState, setState, sendBackgroundNative, saveState,
+      applyStateToPanel, showPluginToast, tr
+    } = deps;
+
+    async function forkRunFromNode(runId) {
+      const previousState = getState();
+      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) {
+        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
+        }
+      });
+      if (!response?.ok || !response.result?.threadId) {
+        return failFork(response?.error?.code || 'session_fork_failed', response?.error?.message || tr('forkRunFailed'));
+      }
+      const copiedRuns = session.runs.slice(0, runIndex + 1).map(copyRunSnapshot);
+      const titleBase = String(session.title || copiedRuns[0]?.task || tr('newSessionFallback')).trim();
+      const forkTitle = buildUniqueForkTitle(previousState.sessions, titleBase);
+      const forked = SessionState.createSession({
+        title: forkTitle,
+        titleSource: 'manual',
+        runs: copiedRuns,
+        task: '',
+        mode: session.mode,
+        providerId: session.providerId,
+        model: session.model,
+        reasoningEffort: session.reasoningEffort,
+        speedTier: session.speedTier,
+        requireReviewing: session.requireReviewing,
+        focusFiles: session.focusFiles,
+        projectReferenceFiles: session.projectReferenceFiles,
+        codexThreadId: response.result.threadId,
+        pendingInputs: [],
+        forkedFromSessionId: session.id,
+        forkedFromRunId: run.id
+      });
+      setState(SessionState.normalizePanelState({
+        ...previousState,
+        sessions: [...(previousState.sessions || []), forked],
+        activeSessionId: forked.id
+      }));
+      try {
+        await saveState();
+      } catch (error) {
+        setState(previousState);
+        await sendBackgroundNative({
+          method: 'codex.history.clearPlugin',
+          params: { sessionId: forked.id, threadId: response.result.threadId }
+        }).catch(() => null);
+        showPluginToast(error.message || tr('forkRunFailed'), { status: 'failed', sticky: true });
+        throw error;
+      }
+      applyStateToPanel();
+      showPluginToast(tr('forkRunDone'), { status: 'completed' });
+      return forked;
+    }
+
+    function failFork(code, message) {
+      showPluginToast(message, { status: 'failed', sticky: true });
+      throw codedError(code, message);
+    }
+
+    return { forkRunFromNode };
+  }
+
+  function buildUniqueForkTitle(sessions = [], sourceTitle = '') {
+    const fallback = String(sourceTitle || 'New Session').trim() || 'New Session';
+    const baseTitle = fallback
+      .replace(/\s+\(fork\)$/i, '')
+      .replace(/\s+\(\d+\)$/, '')
+      .trim() || fallback;
+    const usedTitles = new Set((sessions || []).map(session => String(session?.title || '').trim()));
+    let index = 1;
+    while (usedTitles.has(`${baseTitle} (${index})`)) index += 1;
+    return `${baseTitle} (${index})`;
+  }
+
+  function findSource(state, runId) {
+    for (const session of state?.sessions || []) {
+      const runIndex = (session.runs || []).findIndex(run => run.id === runId);
+      if (runIndex >= 0) return { session, run: session.runs[runIndex], runIndex };
+    }
+    return null;
+  }
+
+  function copyRunSnapshot(run) {
+    const copy = JSON.parse(JSON.stringify(run || {}));
+    return {
+      ...copy,
+      id: `fork_${String(copy.id || 'run')}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`,
+      forkSnapshot: true,
+      forkSourceRunId: String(copy.id || ''),
+      attachments: [], appliedOperations: [], undoOperations: [], undoBaseFiles: [],
+      undoTrackedChanges: [], undoExpectedFiles: [], undoStatus: '',
+      trackedChangeStatus: '', nativeRequestId: '', queueItemId: '', interruptedDraft: undefined
+    };
+  }
+
+  function codedError(code, message) { const error = new Error(message); error.code = code; return error; }
+  return { copyRunSnapshot, create };
+});

package/extension/src/content/writebackController.js

@@ -15,6 +15,9 @@
           type: change.type,
           path: change.path,
           contentBase64: change.contentBase64 || '',
+          assetRef: change.assetRef && typeof change.assetRef === 'object' ? { ...change.assetRef } : undefined,
+          sha256: change.sha256 || change.assetRef?.sha256 || '',
+          mimeType: change.mimeType || change.assetRef?.mimeType || '',
           size: Number.isFinite(Number(change.size)) ? Number(change.size) : undefined,
           previousExists: change.previousExists === true,
           previousKind: change.previousKind || '',

package/extension/src/content/writebackOrchestrator.js

@@ -61,6 +61,7 @@
   let onMirrorRefreshSettled;
   let writebackSettlement;
   let injectedWritebackSettlement;
+  let assetTransferBroker;
 
   function buildSettlement(input = {}) {
     return writebackSettlement?.settle instanceof Function
@@ -283,7 +284,7 @@
       };
     }
     const applied = operations.length
-      ? mergeApplyResultSkipped(await callPageBridge('applyOperations', {
+      ? mergeApplyResultSkipped(await assetTransferBroker.applyOperations({
         operations,
         baseFiles: project?.files || [],
         requireReviewing: runRequireReviewing,
@@ -859,6 +860,7 @@
       getState,
       getCurrentRunView,
     } = deps);
+    assetTransferBroker = deps.assetTransferBroker;
     onMirrorRefreshSettled = deps.onMirrorRefreshSettled;
     writebackSettlement = deps.writebackSettlement;
     compileAdapter = deps.compileAdapter;