codex-overleaf-link 2.1.5 → 2.2.0

package/native-host/src/codexSessionRunner.js

@@ -22,6 +22,13 @@ const { createSubagentBroker } = require('./subagentBroker');
 const { resolveCodexCommand, shouldUseShellForCommand } = require('./codexCommand');
 const { applyProviderEnvironment, buildProviderConfigArgs, prepareProviderLaunch } = require('./codexProviderLaunch');
 const { buildReadProgressRules, createReadProgressController } = require('./readProgressGuard');
+const {
+  createCodexIdleWatchdog,
+  createOptionalTimeout,
+  getAbortReason,
+  parseOptionalPositiveInteger,
+  throwIfAborted
+} = require('./codexSessionTiming');
 
 const PARALLEL_SUBAGENTS_SKILL_ID = 'parallel-subagents';
 
@@ -30,7 +37,7 @@ const MAX_TURN_ATTACHMENT_BYTES = 12 * 1024 * 1024;
 const MAX_TURN_ATTACHMENTS = 8;
 const MAX_TURN_ATTACHMENT_TOTAL_BYTES = MAX_TURN_ATTACHMENT_BYTES * MAX_TURN_ATTACHMENTS;
 
-async function runCodexSession({ params = {}, env = process.env, emit = () => {}, rootDir, executeCodex, providerLaunch, signal } = {}) {
+async function runCodexSession({ params = {}, env = process.env, emit = () => {}, rootDir, executeCodex, providerLaunch, signal, onControlReady } = {}) {
   throwIfAborted(signal);
   const projectId = params.projectId || params.project?.projectId || params.project?.id || params.project?.url || 'overleaf-project';
   const skillInvocation = normalizeSkillInvocation(params.skillInvocation);
@@ -162,6 +169,7 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
       // While subagent workers are active, the parent idle watchdog resets
       // instead of failing the run (spec P2-7 fix).
       hasExternalActivity: subagentBroker ? () => subagentBroker.hasActiveWorkers() : undefined,
+      onControlReady,
       signal
     });
   } catch (error) {
@@ -808,6 +816,7 @@ function runCodexAppServerProcess(input) {
     let stderr = '';
     let activeThreadId = '';
     let activeTurnId = '';
+    let controlPublished = false;
     const assistantMessages = new Map();
     const assistantMessageOrder = [];
     const readProgressController = createReadProgressController({
@@ -841,7 +850,15 @@ function runCodexAppServerProcess(input) {
       fail(new Error(`Codex app-server produced no events for ${ms}ms (idle watchdog); the run was aborted to release the project lock.`));
     });
     const onAbort = () => {
-      fail(getAbortReason(input.signal));
+      const reason = getAbortReason(input.signal);
+      if (!activeThreadId || !activeTurnId) {
+        fail(reason);
+        return;
+      }
+      Promise.race([
+        interruptActiveTurn().catch(() => null),
+        new Promise(resolveDelay => setTimeout(resolveDelay, 1500))
+      ]).finally(() => fail(reason));
     };
     input.signal?.addEventListener('abort', onAbort, { once: true });
 
@@ -910,6 +927,7 @@ function runCodexAppServerProcess(input) {
 
       const turnResponse = await startTurnWithSummaryFallback(activeThreadId);
       activeTurnId = turnResponse?.turn?.id || '';
+      publishActiveTurnControl();
       readProgressController.flush();
     }
 
@@ -935,6 +953,7 @@ function runCodexAppServerProcess(input) {
     }
 
     function request(method, params) {
+      idleWatchdog.reset();
       const id = nextId++;
       const message = { id, method, params };
       child.stdin.write(`${JSON.stringify(message)}\n`);
@@ -986,6 +1005,11 @@ function runCodexAppServerProcess(input) {
       }
 
       if (message.method) {
+        if (message.method === 'turn/started') {
+          activeThreadId = message.params?.thread?.id || message.params?.threadId || activeThreadId;
+          activeTurnId = message.params?.turn?.id || message.params?.turnId || activeTurnId;
+          publishActiveTurnControl();
+        }
         recordAssistantMessage(message);
         // For `error` events surface the actual error text as the visible
         // title so the run timeline reads "Reconnecting... 2/5" instead of
@@ -1061,11 +1085,50 @@ function runCodexAppServerProcess(input) {
       assistantMessages.set(itemId, text);
     }
 
+    function publishActiveTurnControl() {
+      if (controlPublished || !activeThreadId || !activeTurnId) {
+        return;
+      }
+      controlPublished = true;
+      const control = Object.freeze({
+        threadId: activeThreadId,
+        turnId: activeTurnId,
+        steer: ({ input: steerInput, clientUserMessageId } = {}) => request('turn/steer', {
+          threadId: activeThreadId,
+          expectedTurnId: activeTurnId,
+          input: Array.isArray(steerInput) ? steerInput : [],
+          clientUserMessageId: clientUserMessageId || undefined
+        }),
+        interrupt: () => interruptActiveTurn()
+      });
+      input.onControlReady?.(control);
+      emitCodexEvent(input.emit, 'codex.turn.bound', 'Codex turn is ready for follow-up guidance', {
+        threadId: activeThreadId,
+        turnId: activeTurnId
+      }, 'running');
+    }
+
+    function interruptActiveTurn() {
+      if (!activeThreadId || !activeTurnId || settled) {
+        return Promise.resolve({ interrupted: false });
+      }
+      return request('turn/interrupt', {
+        threadId: activeThreadId,
+        turnId: activeTurnId
+      });
+    }
+
     function succeed() {
       if (settled) {
         return;
       }
       settled = true;
+      const turnEndedError = new Error('Codex turn ended before the pending app-server request completed.');
+      turnEndedError.code = 'codex_turn_ended';
+      for (const pendingRequest of pending.values()) {
+        pendingRequest.reject(turnEndedError);
+      }
+      pending.clear();
       cleanup();
       child.kill('SIGTERM');
       resolve({
@@ -1338,69 +1401,6 @@ function tokenizeShellCommand(command) {
   return tokens;
 }
 
-function createOptionalTimeout(value, onTimeout) {
-  const timeoutMs = parseOptionalPositiveInteger(value);
-  if (!timeoutMs) {
-    return {
-      cancel() {}
-    };
-  }
-  const timer = setTimeout(() => onTimeout(timeoutMs), timeoutMs);
-  return {
-    cancel() {
-      clearTimeout(timer);
-    }
-  };
-}
-
-// Idle-style watchdog: fires only after the app-server has been silent for
-// `idleMs`. Callers must invoke .reset() on every signal of liveness
-// (incoming line, outgoing request). cancel() stops the timer on settle.
-// Returns no-op when idleMs is non-positive (defensive guard against bad env
-// var values).
-function createCodexIdleWatchdog(idleMs, onIdle) {
-  if (!(idleMs > 0)) {
-    return {
-      reset() {},
-      cancel() {}
-    };
-  }
-  let timer = setTimeout(() => onIdle(idleMs), idleMs);
-  return {
-    reset() {
-      clearTimeout(timer);
-      timer = setTimeout(() => onIdle(idleMs), idleMs);
-    },
-    cancel() {
-      clearTimeout(timer);
-    }
-  };
-}
-
-function parseOptionalPositiveInteger(value) {
-  if (value === undefined || value === null || value === '') {
-    return 0;
-  }
-  const number = Number(value);
-  return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0;
-}
-
-function throwIfAborted(signal) {
-  if (!signal?.aborted) {
-    return;
-  }
-  throw getAbortReason(signal);
-}
-
-function getAbortReason(signal) {
-  if (signal?.reason instanceof Error) {
-    return signal.reason;
-  }
-  const error = new Error('Codex run was cancelled by the user');
-  error.code = 'codex_cancelled';
-  return error;
-}
-
 function buildFinalAssistantMessage(messages = new Map(), order = []) {
   const values = [];
   const seenIds = new Set();

package/native-host/src/codexSessionTiming.js

@@ -0,0 +1,45 @@
+'use strict';
+
+function createOptionalTimeout(value, onTimeout) {
+  const timeoutMs = parseOptionalPositiveInteger(value);
+  if (!timeoutMs) return { cancel() {} };
+  const timer = setTimeout(() => onTimeout(timeoutMs), timeoutMs);
+  return { cancel: () => clearTimeout(timer) };
+}
+
+function createCodexIdleWatchdog(idleMs, onIdle) {
+  if (!(idleMs > 0)) return { reset() {}, cancel() {} };
+  let timer = setTimeout(() => onIdle(idleMs), idleMs);
+  return {
+    reset() {
+      clearTimeout(timer);
+      timer = setTimeout(() => onIdle(idleMs), idleMs);
+    },
+    cancel: () => clearTimeout(timer)
+  };
+}
+
+function parseOptionalPositiveInteger(value) {
+  if (value === undefined || value === null || value === '') return 0;
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0;
+}
+
+function getAbortReason(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error('Codex run was cancelled by the user');
+  error.code = 'codex_cancelled';
+  return error;
+}
+
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw getAbortReason(signal);
+}
+
+module.exports = {
+  createCodexIdleWatchdog,
+  createOptionalTimeout,
+  getAbortReason,
+  parseOptionalPositiveInteger,
+  throwIfAborted
+};

package/native-host/src/index.js

@@ -4,11 +4,13 @@
 const { decodeFrames, encodeMessage } = require('./nativeMessaging');
 const { logDebug } = require('./debugLog');
 const { handleRequest } = require('./taskRunner');
-const { getActiveNativeWorkState } = require('./taskRunnerRuntime');
+const { abortAllActiveOperations, getActiveNativeWorkState } = require('./taskRunnerRuntime');
 const { handleUpdateRequest, isUpdateMethod } = require('./updateManager');
 const { buildNativeRuntimeEnv, summarizeNativeEnvironment } = require('./nativeEnvironment');
 
 let buffered = Buffer.alloc(0);
+let stdoutUnavailable = false;
+let nativeDisconnectHandled = false;
 const runtimeEnv = buildNativeRuntimeEnv(process.env);
 Object.assign(process.env, runtimeEnv);
 logDebug('environment.ready', summarizeNativeEnvironment(runtimeEnv));
@@ -71,10 +73,24 @@ async function handleDecodedMessage(message) {
 
 process.stdin.on('error', error => {
   logDebug('stdin.error', { message: error.message });
-  console.error(`stdin error: ${error.message}`);
+  handleNativeDisconnect('stdin_error', error);
+});
+process.stdin.on('end', () => handleNativeDisconnect('stdin_end'));
+process.stdin.on('close', () => handleNativeDisconnect('stdin_close'));
+
+process.stdout.on('error', error => {
+  if (isExpectedNativeDisconnect(error)) {
+    handleNativeDisconnect('stdout_disconnected', error);
+    return;
+  }
+  logDebug('stdout.error', { code: error.code, message: error.message, stack: error.stack });
 });
 
 process.on('uncaughtException', error => {
+  if (isExpectedNativeDisconnect(error)) {
+    handleNativeDisconnect('uncaught_native_disconnect', error);
+    return;
+  }
   logDebug('process.uncaught_exception', {
     message: error.message,
     stack: error.stack
@@ -91,6 +107,10 @@ process.on('unhandledRejection', reason => {
 });
 
 function writeResponse(response) {
+  if (stdoutUnavailable || process.stdout.destroyed || process.stdout.writableEnded) {
+    logDebug('stdout.write_skipped', { ok: response?.ok, code: response?.error?.code });
+    return false;
+  }
   let frame;
   try {
     frame = encodeMessage(response);
@@ -110,7 +130,42 @@ function writeResponse(response) {
     }
   }
   logDebug('stdout.write', { bytes: frame.length, ok: response?.ok, code: response?.error?.code });
-  process.stdout.write(frame);
+  try {
+    process.stdout.write(frame, error => {
+      if (!error) return;
+      if (isExpectedNativeDisconnect(error)) {
+        handleNativeDisconnect('stdout_write_disconnected', error);
+        return;
+      }
+      logDebug('stdout.write_failed', { code: error.code, message: error.message });
+    });
+    return true;
+  } catch (error) {
+    if (isExpectedNativeDisconnect(error)) {
+      handleNativeDisconnect('stdout_write_disconnected', error);
+      return false;
+    }
+    throw error;
+  }
+}
+
+function isExpectedNativeDisconnect(error) {
+  return ['EPIPE', 'ERR_STREAM_DESTROYED', 'ERR_STREAM_WRITE_AFTER_END'].includes(String(error?.code || ''));
+}
+
+function handleNativeDisconnect(source, error) {
+  if (nativeDisconnectHandled) return;
+  nativeDisconnectHandled = true;
+  stdoutUnavailable = true;
+  logDebug('native_transport.disconnected', {
+    source,
+    code: error?.code,
+    message: error?.message
+  });
+  abortAllActiveOperations('Native messaging transport disconnected.');
+  process.exitCode = 0;
+  const exitTimer = setTimeout(() => process.exit(0), 1500);
+  exitTimer.unref?.();
 }
 
 function buildOversizeResponseFallback(response, error) {

package/native-host/src/managedInstall.js

@@ -32,6 +32,8 @@ function installManagedDistribution(options = {}) {
   if (!parseSemver(version)) {
     throw updateError('managed_version_invalid', 'Managed installation requires a stable semantic version.');
   }
+  const releaseRef = String(options.releaseRef || process.env.CODEX_OVERLEAF_RELEASE_REF || process.env.CODEX_OVERLEAF_REF || `v${version}`);
+  const releaseChannel = options.releaseChannel || (releaseRef === `v${version}` ? 'stable' : 'prerelease');
   const platform = options.platform || process.platform;
   const browser = options.browser || 'chrome';
   const env = options.env || process.env;
@@ -52,7 +54,14 @@ function installManagedDistribution(options = {}) {
   const unique = process.pid + '-' + Date.now() + '-' + Math.random().toString(16).slice(2);
   const extensionStage = path.join(parent, '.extension.staging-' + unique);
   const extensionRollback = path.join(parent, '.extension.rollback-' + unique);
-  buildManagedExtensionTree({ packageRoot, targetRoot: extensionStage, version, allowedFiles: options.allowedFiles });
+  buildManagedExtensionTree({
+    packageRoot,
+    targetRoot: extensionStage,
+    version,
+    releaseRef,
+    releaseChannel,
+    allowedFiles: options.allowedFiles
+  });
 
   const previousExtensionMarker = readManagedMarker(extensionRoot, EXTENSION_MARKER);
   if (fs.existsSync(extensionRoot) && !isManagedMarker(previousExtensionMarker, 'extension')) {
@@ -75,7 +84,7 @@ function installManagedDistribution(options = {}) {
   }
 
   try {
-    installManagedNativeVersion({ packageRoot, nativeRoot, version });
+    installManagedNativeVersion({ packageRoot, nativeRoot, version, releaseRef, releaseChannel });
     installManagedNativeRegistration({
       browser,
       env,
@@ -111,6 +120,8 @@ function buildManagedExtensionTree(options = {}) {
   const packageRoot = path.resolve(options.packageRoot || path.resolve(__dirname, '../..'));
   const targetRoot = path.resolve(String(options.targetRoot || ''));
   const version = String(options.version || readJson(path.join(packageRoot, 'package.json')).version || '');
+  const releaseRef = String(options.releaseRef || `v${version}`);
+  const releaseChannel = options.releaseChannel || (releaseRef === `v${version}` ? 'stable' : 'prerelease');
   if (!parseSemver(version)) {
     throw new Error('Managed extension version is invalid.');
   }
@@ -133,17 +144,20 @@ function buildManagedExtensionTree(options = {}) {
   copyPackageTree(packageRoot, 'extension/styles', targetRoot, 'runtime/styles', { allowedFiles });
   copyPackageTree(packageRoot, 'extension/vendor', targetRoot, 'runtime/vendor', { allowedFiles });
   copyPackageFile(packageRoot, 'extension/runtime-manifest.json', targetRoot, 'runtime/runtime-manifest.json', allowedFiles);
+  rewriteManagedRuntimeAssetPaths(targetRoot);
   fs.writeFileSync(path.join(targetRoot, EXTENSION_MARKER), JSON.stringify({
     managedBy: MANAGED_BY,
     kind: 'extension',
-    bootstrapProtocol: 1,
+    bootstrapProtocol: 2,
     version,
+    releaseRef,
+    releaseChannel,
     installedAt: new Date().toISOString()
   }, null, 2) + '\n', 'utf8');
   return { targetRoot, version };
 }
 
-function installManagedNativeVersion({ packageRoot, nativeRoot, version }) {
+function installManagedNativeVersion({ packageRoot, nativeRoot, version, releaseRef = `v${version}`, releaseChannel = 'stable' }) {
   const marker = readManagedMarker(nativeRoot, NATIVE_MARKER);
   if (fs.existsSync(nativeRoot) && !isManagedMarker(marker, 'native')) {
     throw new Error('Refusing to replace an unmarked managed native root: ' + nativeRoot);
@@ -157,7 +171,11 @@ function installManagedNativeVersion({ packageRoot, nativeRoot, version }) {
   for (const entry of buildRuntimeFileManifest({ packageRoot })) {
     copyFile(entry.sourcePath, path.join(stage, entry.relativePath));
   }
-  fs.writeFileSync(path.join(stage, '.codex-overleaf-version.json'), JSON.stringify({ version }, null, 2) + '\n');
+  fs.writeFileSync(path.join(stage, '.codex-overleaf-version.json'), JSON.stringify({
+    version,
+    releaseRef,
+    releaseChannel
+  }, null, 2) + '\n');
   if (fs.existsSync(target)) {
     safeRemove(target);
   }
@@ -175,7 +193,7 @@ function installManagedNativeVersion({ packageRoot, nativeRoot, version }) {
   fs.writeFileSync(path.join(nativeRoot, NATIVE_MARKER), JSON.stringify({
     managedBy: MANAGED_BY,
     kind: 'native',
-    bootstrapProtocol: 1,
+    bootstrapProtocol: 2,
     version,
     installedAt: new Date().toISOString()
   }, null, 2) + '\n', 'utf8');
@@ -330,6 +348,24 @@ function copyFile(source, target) {
   fs.chmodSync(target, fs.statSync(source).mode & 0o777);
 }
 
+function rewriteManagedRuntimeAssetPaths(targetRoot) {
+  const cssPath = path.join(targetRoot, 'runtime/vendor/katex/katex.min.css');
+  if (!fs.existsSync(cssPath)) {
+    return;
+  }
+  const sourcePrefix = 'chrome-extension://__MSG_@@extension_id__/vendor/katex/fonts/';
+  const managedPrefix = 'chrome-extension://__MSG_@@extension_id__/runtime/vendor/katex/fonts/';
+  const css = fs.readFileSync(cssPath, 'utf8');
+  if (!css.includes(sourcePrefix)) {
+    throw new Error('Managed KaTeX CSS does not contain the expected source font prefix.');
+  }
+  const rewritten = css.split(sourcePrefix).join(managedPrefix);
+  if (rewritten.includes(sourcePrefix)) {
+    throw new Error('Managed KaTeX CSS retained a source-only font path.');
+  }
+  fs.writeFileSync(cssPath, rewritten, 'utf8');
+}
+
 function normalizeAllowedFiles(value) {
   if (!value) return null;
   return value instanceof Set ? value : new Set(value);
@@ -344,7 +380,9 @@ function readManagedMarker(root, markerName) {
 }
 
 function isManagedMarker(marker, kind) {
-  return marker?.managedBy === MANAGED_BY && marker?.kind === kind && marker?.bootstrapProtocol === 1;
+  return marker?.managedBy === MANAGED_BY &&
+    marker?.kind === kind &&
+    (marker?.bootstrapProtocol === 1 || marker?.bootstrapProtocol === 2);
 }
 
 function readVersionPointer(nativeRoot, name) {

package/native-host/src/providerProfile.js

@@ -407,8 +407,8 @@ function normalizeUpstreamResponseMode(value, allowAuto) {
 
 function normalizeMaxOutputTokens(value) {
   const number = Number(value);
-  if (!Number.isFinite(number) || number === 8192) return 32768;
-  return Math.min(200000, Math.max(256, Math.floor(number)));
+  if (!Number.isFinite(number) || number === 8192 || number === 32768) return 65536;
+  return Math.min(65536, Math.max(256, Math.floor(number)));
 }
 
 function normalizeRequiredText(value, code, message, maxLength) {

package/native-host/src/providerStreamLifecycle.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const DEFAULT_IDLE_TIMEOUT_MS = 120000;
+const DEFAULT_TOTAL_TIMEOUT_MS = 30 * 60 * 1000;
+const MAX_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_TOTAL_TIMEOUT_MS = 60 * 60 * 1000;
+
+function createProviderStreamLifecycle({
+  controller,
+  idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS,
+  totalTimeoutMs = DEFAULT_TOTAL_TIMEOUT_MS,
+  onAbort = () => {}
+} = {}) {
+  if (!controller?.signal || typeof controller.abort !== 'function') {
+    throw new TypeError('A provider stream lifecycle requires an AbortController.');
+  }
+  let idleTimeout = null;
+  let totalTimeout = null;
+  let abortReason = '';
+  let started = false;
+  let finished = false;
+
+  const clearTimers = () => {
+    clearTimeout(idleTimeout);
+    clearTimeout(totalTimeout);
+    idleTimeout = null;
+    totalTimeout = null;
+  };
+  const abort = reason => {
+    if (finished || controller.signal.aborted) return;
+    abortReason = String(reason || 'cancelled');
+    onAbort(abortReason);
+    clearTimers();
+    controller.abort();
+  };
+  const touch = () => {
+    if (finished || controller.signal.aborted) return;
+    clearTimeout(idleTimeout);
+    idleTimeout = setTimeout(() => abort('idle_timeout'), idleTimeoutMs);
+    idleTimeout.unref?.();
+  };
+  const start = () => {
+    if (started || finished || controller.signal.aborted) return;
+    started = true;
+    touch();
+    totalTimeout = setTimeout(() => abort('total_timeout'), totalTimeoutMs);
+    totalTimeout.unref?.();
+  };
+  const finish = () => {
+    if (finished) return;
+    finished = true;
+    clearTimers();
+  };
+  const recoverInterrupted = error => {
+    if (abortReason === 'idle_timeout' || abortReason === 'total_timeout') return abortReason;
+    if (abortReason) return '';
+    return isTransportInterruption(error) ? 'transport_interrupted' : '';
+  };
+
+  return {
+    abort,
+    dispose: finish,
+    finish,
+    recoverInterrupted,
+    start,
+    touch,
+    get abortReason() { return abortReason; }
+  };
+}
+
+function resolveProviderIdleTimeoutMs(launch = {}) {
+  const configured = Number(launch.requestTimeoutMs);
+  if (!Number.isFinite(configured) || configured <= 0) return DEFAULT_IDLE_TIMEOUT_MS;
+  return Math.min(MAX_IDLE_TIMEOUT_MS, Math.max(DEFAULT_IDLE_TIMEOUT_MS, Math.floor(configured)));
+}
+
+function resolveProviderTotalTimeoutMs(launch = {}, idleTimeoutMs = resolveProviderIdleTimeoutMs(launch)) {
+  const configured = Number(launch.totalRequestTimeoutMs);
+  const requested = Number.isFinite(configured) && configured > 0
+    ? Math.floor(configured)
+    : DEFAULT_TOTAL_TIMEOUT_MS;
+  return Math.min(MAX_TOTAL_TIMEOUT_MS, Math.max(requested, idleTimeoutMs * 2));
+}
+
+function isTransportInterruption(error) {
+  const code = String(error?.cause?.code || error?.code || '').toUpperCase();
+  if (['ECONNRESET', 'EPIPE', 'ETIMEDOUT', 'UND_ERR_SOCKET', 'UND_ERR_CONNECT_TIMEOUT'].includes(code)) return true;
+  const message = String(error?.message || '').toLowerCase();
+  return error?.name === 'AbortError'
+    || message.includes('fetch failed')
+    || message.includes('terminated')
+    || message.includes('socket')
+    || message.includes('connection reset');
+}
+
+module.exports = {
+  createProviderStreamLifecycle,
+  resolveProviderIdleTimeoutMs,
+  resolveProviderTotalTimeoutMs
+};