codex-overleaf-link 2.3.1 → 2.3.2

package/extension/styles/panel.css

@@ -2359,6 +2359,67 @@
   margin-left: auto;
 }
 
+#codex-overleaf-panel .run-result-actions {
+  display: flex;
+  justify-content: flex-start;
+  align-items: center;
+  gap: 2px;
+  min-height: 30px;
+  margin: 10px 0 0;
+}
+
+#codex-overleaf-panel .run-result-actions[hidden] { display: none; }
+
+#codex-overleaf-panel .run-copy-action,
+#codex-overleaf-panel .run-fork-action {
+  display: inline-grid;
+  place-items: center;
+  width: 30px;
+  height: 30px;
+  border: 0;
+  border-radius: 999px;
+  background: transparent;
+  color: var(--tl-fg-4);
+  opacity: 1;
+  transition: color 120ms ease, background 120ms ease, opacity 120ms ease;
+}
+
+#codex-overleaf-panel .run-copy-action:hover:not(:disabled),
+#codex-overleaf-panel .run-fork-action:hover:not(:disabled) {
+  background: var(--tl-hover);
+  color: var(--tl-accent);
+}
+
+#codex-overleaf-panel .run-copy-action:disabled,
+#codex-overleaf-panel .run-fork-action:disabled {
+  cursor: not-allowed;
+  opacity: 0.38;
+}
+
+#codex-overleaf-panel .run-copy-action svg,
+#codex-overleaf-panel .run-fork-action svg {
+  width: 16px;
+  height: 16px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.7;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+#codex-overleaf-panel .run-copy-action[hidden],
+#codex-overleaf-panel .run-fork-action[hidden] { display: none; }
+
+#codex-overleaf-panel .run-completed-time {
+  margin-left: 5px;
+  color: var(--tl-fg-4);
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+  line-height: 30px;
+}
+
+#codex-overleaf-panel .run-completed-time[hidden] { display: none; }
+
 /* When Accept All is hidden, the Undo button takes the right-aligned slot. */
 #codex-overleaf-panel .run-turn-meta [data-run-accept][hidden] + [data-run-undo] {
   margin-left: auto;

package/native-host/src/codexModels.js

@@ -181,7 +181,7 @@ function buildModelEntry({
   defaultSpeedTier = 'standard'
 }) {
   const normalizedEfforts = normalizeReasoningEfforts(reasoningEfforts);
-  const normalizedDefault = getString(defaultReasoningEffort) || 'medium';
+  const normalizedDefault = normalizeReasoningEffort(defaultReasoningEffort) || 'medium';
   const normalizedSpeedTiers = normalizeSpeedTiers(speedTiers);
   const normalizedDefaultSpeedTier = getString(defaultSpeedTier) || 'standard';
   return {
@@ -202,7 +202,7 @@ function normalizeReasoningEfforts(rawEfforts) {
   const seen = new Set();
   const result = [];
   for (const rawEffort of rawEfforts) {
-    const effort = getString(typeof rawEffort === 'string' ? rawEffort : rawEffort?.effort);
+    const effort = normalizeReasoningEffort(typeof rawEffort === 'string' ? rawEffort : rawEffort?.effort);
     if (!effort || seen.has(effort)) {
       continue;
     }
@@ -212,6 +212,10 @@ function normalizeReasoningEfforts(rawEfforts) {
   return result;
 }
 
+function normalizeReasoningEffort(rawEffort) {
+  return getString(rawEffort);
+}
+
 function normalizeSpeedTiers(rawTiers) {
   const tiers = ['standard'];
   if (!Array.isArray(rawTiers)) {

package/native-host/src/codexSessionRunner.js

@@ -22,6 +22,7 @@ const {
   loadSelectedProjectSkills
 } = require('./localSkills');
 const { createSubagentBroker } = require('./subagentBroker');
+const { prepareBinaryAssetChanges } = require('./nativeAssetTransfer');
 const { resolveCodexCommand, shouldUseShellForCommand } = require('./codexCommand');
 const { applyProviderEnvironment, buildProviderConfigArgs, prepareProviderLaunch } = require('./codexProviderLaunch');
 const { buildReadProgressRules, createReadProgressController } = require('./readProgressGuard');
@@ -259,6 +260,9 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
     });
   }
 
+  const preparedAssets = prepareBinaryAssetChanges({ projectId, rootDir, changes: rawSyncChanges });
+  rawSyncChanges = preparedAssets.changes;
+  unsupportedChanges.push(...preparedAssets.unsupportedChanges);
   const syncChanges = rawSyncChanges.map(change => {
     if (change.type === 'write' && typeof change.previousContent === 'string') {
       return {
@@ -1461,7 +1465,7 @@ function extractCodexAppServerErrorMessage(params = {}) {
 }
 
 function normalizeReasoningEffort(value) {
-  return ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'].includes(value) ? value : null;
+  return ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(value) ? value : null;
 }
 
 function normalizeSpeedTier(value) {

package/native-host/src/codexThreadFork.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const { version: PACKAGE_VERSION } = require('../../package.json');
+const { buildCodexHomeEnv } = require('./codexHome');
+const { resolveCodexCommand, shouldUseShellForCommand } = require('./codexCommand');
+const { buildCodexAppServerArgs } = require('./codexSessionRunner');
+
+function forkCodexThread(params = {}, env = process.env) {
+  const threadId = cleanId(params.threadId, 'threadId');
+  const lastTurnId = cleanId(params.lastTurnId, 'lastTurnId');
+  const childEnv = buildCodexHomeEnv(env, {
+    loadCodexLocalSkills: params.loadCodexLocalSkills !== false,
+    loadCodexOverleafSkills: params.loadCodexOverleafSkills !== false
+  });
+  const command = resolveCodexCommand(childEnv);
+  if (!command) return Promise.reject(codedError('codex_not_found', 'Codex CLI was not found.'));
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, buildCodexAppServerArgs({
+      speedTier: params.speedTier || 'standard',
+      loadCodexLocalSkills: params.loadCodexLocalSkills !== false
+    }), {
+      env: childEnv,
+      shell: shouldUseShellForCommand(command, childEnv),
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const pending = new Map();
+    let nextId = 1;
+    let buffer = '';
+    let stderr = '';
+    let settled = false;
+    const timeout = setTimeout(() => finish(codedError('codex_thread_fork_timeout', 'Codex thread fork timed out.')), 30000);
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => {
+      buffer += chunk;
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || '';
+      for (const line of lines) if (line.trim()) handleMessage(line);
+    });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('error', finish);
+    child.on('close', code => {
+      if (!settled) finish(codedError('codex_thread_fork_failed', stderr || `Codex app-server exited with code ${code}.`));
+    });
+
+    (async () => {
+      await request('initialize', {
+        clientInfo: { name: 'codex-overleaf-link', version: PACKAGE_VERSION },
+        capabilities: null
+      });
+      notify('initialized');
+      const result = await request('thread/fork', { threadId, lastTurnId });
+      const forkedThreadId = result?.thread?.id || result?.threadId || '';
+      if (!forkedThreadId || forkedThreadId === threadId) {
+        throw codedError('codex_thread_fork_invalid_response', 'Codex app-server did not return a new thread id.');
+      }
+      finish(null, { threadId: forkedThreadId, sourceThreadId: threadId, lastTurnId });
+    })().catch(finish);
+
+    function request(method, requestParams) {
+      const id = nextId++;
+      child.stdin.write(`${JSON.stringify({ id, method, params: requestParams })}\n`);
+      return new Promise((resolveRequest, rejectRequest) => pending.set(id, { resolve: resolveRequest, reject: rejectRequest }));
+    }
+    function notify(method, requestParams) {
+      child.stdin.write(`${JSON.stringify({ method, params: requestParams })}\n`);
+    }
+    function handleMessage(line) {
+      let message;
+      try { message = JSON.parse(line); } catch (_error) { return; }
+      if (Object.prototype.hasOwnProperty.call(message, 'id') && (message.result !== undefined || message.error)) {
+        const waiter = pending.get(message.id);
+        if (!waiter) return;
+        pending.delete(message.id);
+        if (message.error) waiter.reject(codedError('codex_thread_fork_failed', message.error.message || JSON.stringify(message.error)));
+        else waiter.resolve(message.result);
+      } else if (Object.prototype.hasOwnProperty.call(message, 'id') && message.method) {
+        child.stdin.write(`${JSON.stringify({ id: message.id, error: { code: -32601, message: 'Unsupported during thread fork' } })}\n`);
+      }
+    }
+    function finish(error, result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      for (const waiter of pending.values()) waiter.reject(error || codedError('codex_thread_fork_closed', 'Fork process closed.'));
+      pending.clear();
+      try { child.stdin.end(); } catch (_error) { /* best effort */ }
+      try { child.kill(); } catch (_error) { /* best effort */ }
+      if (error) reject(error); else resolve(result);
+    }
+  });
+}
+
+function cleanId(value, field) {
+  const id = String(value || '').trim();
+  if (!id || id.length > 160) throw codedError('codex_thread_fork_invalid', `${field} is required.`);
+  return id;
+}
+function codedError(code, message) { const error = new Error(message); error.code = code; return error; }
+module.exports = { forkCodexThread };

package/native-host/src/mirrorWorkspace.js

@@ -152,34 +152,19 @@ async function collectMirrorChangesDetailed({ projectId, rootDir }) {
         if (hashBytes(bytes) === previous.hash) {
           continue;
         }
-        if (stat.size > SAFE_INLINE_BINARY_CHANGE_BYTES) {
-          unsupportedChanges.push(buildOversizedBinaryPayloadChange({
-            filePath,
-            size: stat.size,
-            previous
-          }));
-          continue;
-        }
         currentByPath.set(filePath, {
           binary: true,
-          bytes,
+          sha256: hashBytes(bytes),
           size: stat.size,
           previous
         });
         continue;
       }
       if (!previous) {
-        if (stat.size > SAFE_INLINE_BINARY_CHANGE_BYTES) {
-          unsupportedChanges.push(buildOversizedBinaryPayloadChange({
-            filePath,
-            size: stat.size,
-            previous
-          }));
-          continue;
-        }
+        const bytes = fs.readFileSync(target);
         currentByPath.set(filePath, {
           binary: true,
-          bytes: fs.readFileSync(target),
+          sha256: hashBytes(bytes),
           size: stat.size,
           previous
         });
@@ -218,7 +203,8 @@ async function collectMirrorChangesDetailed({ projectId, rootDir }) {
       changes.push({
         type: previous ? 'overwrite-binary' : 'binary-create',
         path: filePath,
-        contentBase64: contentOrBinary.bytes.toString('base64'),
+        assetSourcePath: filePath,
+        sha256: contentOrBinary.sha256,
         previousExists: Boolean(previous),
         previousKind: previous?.kind || '',
         previousSize: previous?.size,

package/native-host/src/nativeAssetTransfer.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { getProjectMirror } = require('./mirrorWorkspace');
+
+const MAX_ASSET_BYTES = 10 * 1024 * 1024;
+const ASSET_CHUNK_BYTES = 192 * 1024;
+const ASSET_TOKEN_TTL_MS = 15 * 60 * 1000;
+const transfers = new Map();
+
+function prepareBinaryAssetChanges({ projectId, rootDir, changes = [] } = {}) {
+  const prepared = [];
+  const unsupportedChanges = [];
+  for (const change of changes) {
+    if (change?.type !== 'binary-create' && change?.type !== 'overwrite-binary') {
+      prepared.push(change);
+      continue;
+    }
+    try {
+      prepared.push(registerAssetChange({ projectId, rootDir, change }));
+    } catch (error) {
+      unsupportedChanges.push({
+        type: 'unsupported-local-file',
+        path: change?.path || '',
+        reason: error.code || 'binary_asset_registration_failed',
+        size: change?.size,
+        attemptedChangeType: change?.type || 'binary-create'
+      });
+    }
+  }
+  return { changes: prepared, unsupportedChanges };
+}
+
+function registerAssetChange({ projectId, rootDir, change }) {
+  cleanupExpiredTransfers();
+  const mirror = getProjectMirror(projectId, { rootDir });
+  const relativePath = normalizeProjectPath(change.assetSourcePath || change.path);
+  const target = resolveSafeWorkspaceFile(mirror.workspacePath, relativePath);
+  const stat = fs.statSync(target);
+  if (!stat.isFile()) throw codedError('binary_asset_source_invalid', 'Asset source is not a file.');
+  if (stat.size > MAX_ASSET_BYTES) throw codedError('binary_file_too_large', 'Asset exceeds the 10 MiB writeback limit.');
+  const sha256 = hashFile(target);
+  if (change.sha256 && change.sha256 !== sha256) {
+    throw codedError('binary_asset_source_changed', 'Asset changed before transfer registration.');
+  }
+  const token = crypto.randomUUID();
+  const expiresAtMs = Date.now() + ASSET_TOKEN_TTL_MS;
+  transfers.set(token, {
+    token,
+    path: relativePath,
+    target,
+    size: stat.size,
+    sha256,
+    expiresAtMs
+  });
+  const { contentBase64, assetSourcePath, ...safeChange } = change;
+  return {
+    ...safeChange,
+    size: stat.size,
+    assetRef: {
+      token,
+      path: relativePath,
+      size: stat.size,
+      sha256,
+      mimeType: inferMimeType(relativePath),
+      chunkSize: ASSET_CHUNK_BYTES,
+      expiresAt: new Date(expiresAtMs).toISOString()
+    }
+  };
+}
+
+function readAssetChunk(params = {}) {
+  cleanupExpiredTransfers();
+  const transfer = getTransfer(params.token);
+  const offset = Number(params.offset || 0);
+  const requestedLength = Number(params.length || ASSET_CHUNK_BYTES);
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset > transfer.size) {
+    throw codedError('asset_chunk_offset_invalid', 'Asset chunk offset is invalid.');
+  }
+  const length = Math.min(
+    ASSET_CHUNK_BYTES,
+    Number.isSafeInteger(requestedLength) && requestedLength > 0 ? requestedLength : ASSET_CHUNK_BYTES,
+    transfer.size - offset
+  );
+  assertSourceStable(transfer);
+  const handle = fs.openSync(transfer.target, 'r');
+  try {
+    const buffer = Buffer.alloc(length);
+    const bytesRead = length ? fs.readSync(handle, buffer, 0, length, offset) : 0;
+    const nextOffset = offset + bytesRead;
+    return {
+      token: transfer.token,
+      path: transfer.path,
+      offset,
+      nextOffset,
+      size: transfer.size,
+      sha256: transfer.sha256,
+      contentBase64: buffer.subarray(0, bytesRead).toString('base64'),
+      eof: nextOffset >= transfer.size
+    };
+  } finally {
+    fs.closeSync(handle);
+  }
+}
+
+function releaseAsset(params = {}) {
+  return { released: transfers.delete(String(params.token || '')) };
+}
+
+function getTransfer(tokenValue) {
+  const token = String(tokenValue || '');
+  const transfer = transfers.get(token);
+  if (!transfer) throw codedError('asset_token_invalid', 'Asset transfer token is invalid or expired.');
+  if (transfer.expiresAtMs <= Date.now()) {
+    transfers.delete(token);
+    throw codedError('asset_token_expired', 'Asset transfer token expired.');
+  }
+  return transfer;
+}
+
+function assertSourceStable(transfer) {
+  let stat;
+  try { stat = fs.statSync(transfer.target); } catch (_error) {
+    throw codedError('binary_asset_source_missing', 'Asset source disappeared during transfer.');
+  }
+  if (!stat.isFile() || stat.size !== transfer.size) {
+    throw codedError('binary_asset_source_changed', 'Asset source changed during transfer.');
+  }
+}
+
+function resolveSafeWorkspaceFile(workspacePath, relativePath) {
+  const root = path.resolve(workspacePath);
+  const target = path.resolve(root, relativePath);
+  if (target === root || !target.startsWith(`${root}${path.sep}`)) {
+    throw codedError('binary_asset_path_unsafe', 'Asset path escapes the project workspace.');
+  }
+  if (fs.lstatSync(target).isSymbolicLink()) {
+    throw codedError('binary_asset_path_unsafe', 'Symbolic-link assets cannot be transferred.');
+  }
+  return target;
+}
+
+function normalizeProjectPath(value) {
+  const normalized = String(value || '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+  if (!normalized || normalized.split('/').some(part => !part || part === '.' || part === '..')) {
+    throw codedError('binary_asset_path_invalid', 'Asset path is not a safe project-relative path.');
+  }
+  return normalized;
+}
+
+function hashFile(target) {
+  return crypto.createHash('sha256').update(fs.readFileSync(target)).digest('hex');
+}
+
+function inferMimeType(filePath) {
+  return {
+    '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.svg': 'image/svg+xml',
+    '.webp': 'image/webp', '.eps': 'application/postscript'
+  }[path.extname(filePath).toLowerCase()] || 'application/octet-stream';
+}
+
+function cleanupExpiredTransfers() {
+  const now = Date.now();
+  for (const [token, transfer] of transfers) if (transfer.expiresAtMs <= now) transfers.delete(token);
+}
+
+function codedError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+module.exports = {
+  ASSET_CHUNK_BYTES,
+  ASSET_TOKEN_TTL_MS,
+  MAX_ASSET_BYTES,
+  prepareBinaryAssetChanges,
+  readAssetChunk,
+  releaseAsset
+};

package/native-host/src/taskRunnerRuntime.js

@@ -19,6 +19,8 @@ const {
   resolveRunProviderForRun
 } = require('./providerRuntime');
 const { clearPluginCodexHistory } = require('./codexHome');
+const { forkCodexThread } = require('./codexThreadFork');
+const { readAssetChunk, releaseAsset } = require('./nativeAssetTransfer');
 const { logDebug, truncateText } = require('./debugLog');
 const { HOST_NAME } = require('./manifest');
 const { getNativeRuntimePlatform, summarizeNativeEnvironment } = require('./nativeEnvironment');
@@ -116,6 +118,26 @@ async function handleRequest(request, env = process.env, emit = () => {}) {
     return handleCodexHistoryClear(request, env);
   }
 
+  if (request.method === 'codex.thread.fork') {
+    try {
+      return okResponse(request.id, await forkCodexThread(request.params || {}, env));
+    } catch (error) {
+      return errorResponse(request.id, error.code || 'codex_thread_fork_failed', error.message);
+    }
+  }
+
+  if (request.method === 'asset.readChunk') {
+    try {
+      return okResponse(request.id, readAssetChunk(request.params || {}));
+    } catch (error) {
+      return errorResponse(request.id, error.code || 'asset_chunk_read_failed', error.message);
+    }
+  }
+
+  if (request.method === 'asset.release') {
+    return okResponse(request.id, releaseAsset(request.params || {}));
+  }
+
   if (request.method === 'skills.list') {
     return handleSkillsList(request, env);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",