codex-overleaf-link 2.4.0 → 2.4.1

package/native-host/src/codexSessionRunner.js

@@ -25,12 +25,14 @@ const { createSubagentBroker } = require('./subagentBroker');
 const { prepareBinaryAssetChanges } = require('./nativeAssetTransfer');
 const { resolveCodexCommand, shouldUseShellForCommand } = require('./codexCommand');
 const { applyProviderEnvironment, buildProviderConfigArgs, prepareProviderLaunch } = require('./codexProviderLaunch');
-const { buildReadProgressRules, createReadProgressController } = require('./readProgressGuard');
+const { buildReadProgressRules, createReadProgressController, createRunEventScope } = require('./readProgressGuard');
 const {
   createCodexIdleWatchdog,
   createOptionalTimeout,
   getAbortReason,
   parseOptionalPositiveInteger,
+  rejectPendingRequests,
+  stopCodexAppServer,
   throwIfAborted
 } = require('./codexSessionTiming');
 
@@ -806,23 +808,26 @@ function runCodexAppServerProcess(input) {
     const child = spawn(codexCommand, buildCodexAppServerArgs(input), {
       env: childEnv,
       shell: shouldUseShellForCommand(codexCommand, childEnv),
+      detached: process.platform !== 'win32',
       stdio: ['pipe', 'pipe', 'pipe']
     });
     const pending = new Map();
     let nextId = 1;
     let stdoutBuffer = '';
     let stderr = '';
-    let activeThreadId = '';
+    let activeThreadId = String(input.threadId || '');
     let activeTurnId = '';
     let controlPublished = false;
     const assistantMessages = new Map();
     const assistantMessageOrder = [];
+    const eventScope = createRunEventScope(() => ({ threadId: activeThreadId, turnId: activeTurnId }));
     const readProgressController = createReadProgressController({
       input, request, fail,
       getTurn: () => ({ threadId: activeThreadId, turnId: activeTurnId }),
       emitEvent: (...args) => emitCodexEvent(input.emit, ...args)
     });
     let settled = false;
+    let stopping = false;
     // Two-layer timeout strategy:
     //   1. Optional absolute deadline (CODEX_OVERLEAF_CODEX_TIMEOUT_MS) —
     //      legacy override; off by default. When set, the whole run must
@@ -847,23 +852,14 @@ 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 = () => {
-      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));
-    };
+    const onAbort = () => fail(getAbortReason(input.signal));
     input.signal?.addEventListener('abort', onAbort, { once: true });
 
     child.stdout.setEncoding('utf8');
     child.stderr.setEncoding('utf8');
     child.stdout.on('data', chunk => {
-      idleWatchdog.reset();
+      if (settled) return;
+      if (!stopping) idleWatchdog.reset();
       stdoutBuffer += chunk;
       const lines = stdoutBuffer.split(/\r?\n/);
       stdoutBuffer = lines.pop() || '';
@@ -876,6 +872,7 @@ function runCodexAppServerProcess(input) {
     child.stderr.on('data', chunk => {
       stderr += chunk;
     });
+    child.stdin.on?.('error', fail);
     child.on('error', fail);
     child.on('close', code => {
       if (settled) {
@@ -951,12 +948,14 @@ function runCodexAppServerProcess(input) {
     }
 
     function request(method, params) {
-      idleWatchdog.reset();
+      if (settled || (stopping && method !== 'turn/interrupt')) return Promise.reject(new Error('Codex turn is stopping or has ended.'));
+      if (!stopping) idleWatchdog.reset();
       const id = nextId++;
       const message = { id, method, params };
       child.stdin.write(`${JSON.stringify(message)}\n`);
       return new Promise((resolveRequest, rejectRequest) => {
         pending.set(id, {
+          method, params,
           resolve: resolveRequest,
           reject: rejectRequest
         });
@@ -972,10 +971,12 @@ function runCodexAppServerProcess(input) {
     }
 
     function handleMessage(line) {
+      if (settled) return;
       let message;
       try {
         message = JSON.parse(line);
       } catch {
+        if (stopping) return;
         emitCodexEvent(input.emit, 'codex.session.raw', 'Codex app-server emitted non-JSON output', {
           text: truncateText(line, 1000)
         });
@@ -992,23 +993,29 @@ function runCodexAppServerProcess(input) {
         if (message.error) {
           pendingRequest.reject(new Error(message.error.message || JSON.stringify(message.error)));
         } else {
+          if (pendingRequest.method === 'thread/start' || pendingRequest.method === 'thread/resume') {
+            activeThreadId = message.result?.thread?.id || message.result?.threadId || pendingRequest.params?.threadId || activeThreadId;
+          }
+          if (pendingRequest.method === 'turn/start') activeTurnId = message.result?.turn?.id || activeTurnId;
           pendingRequest.resolve(message.result);
         }
         return;
       }
 
       if (Object.prototype.hasOwnProperty.call(message, 'id') && message.method) {
+        if (stopping) { response(message.id, { decision: 'decline' }); return; }
         handleServerRequest(message);
         return;
       }
 
       if (message.method) {
+        if (stopping || !eventScope.accepts(message.params)) return;
         if (message.method === 'turn/started') {
-          activeThreadId = message.params?.thread?.id || message.params?.threadId || activeThreadId;
-          activeTurnId = message.params?.turn?.id || message.params?.turnId || activeTurnId;
+          const threadId = message.params?.thread?.id || message.params?.threadId;
+          if (!activeTurnId && threadId === activeThreadId) activeTurnId = message.params?.turn?.id || message.params?.turnId || '';
           publishActiveTurnControl();
         }
-        recordAssistantMessage(message);
+        if (activeTurnId) recordAssistantMessage(message);
         // For `error` events surface the actual error text as the visible
         // title so the run timeline reads "Reconnecting... 2/5" instead of
         // a generic "error". Other methods continue to use the method name.
@@ -1019,9 +1026,9 @@ function runCodexAppServerProcess(input) {
           method: message.method,
           params: message.params || {}
         }, inferNotificationStatus(message));
-        if (message.method === 'item/completed' &&
+        if (message.method === 'item/completed' && eventScope.owns(message.params) &&
           !readProgressController.observe(message.params?.item || {})) return;
-        if (message.method === 'turn/completed' && (!activeTurnId || message.params?.turn?.id === activeTurnId || message.params?.turnId === activeTurnId)) {
+        if (message.method === 'turn/completed' && activeTurnId && (message.params?.turn?.id === activeTurnId || message.params?.turnId === activeTurnId)) {
           succeed();
         }
         if (message.method === 'error' && isTransientCodexAppServerError(message.params)) {
@@ -1084,7 +1091,7 @@ function runCodexAppServerProcess(input) {
     }
 
     function publishActiveTurnControl() {
-      if (controlPublished || !activeThreadId || !activeTurnId) {
+      if (settled || stopping || controlPublished || !activeThreadId || !activeTurnId) {
         return;
       }
       controlPublished = true;
@@ -1100,6 +1107,7 @@ function runCodexAppServerProcess(input) {
         interrupt: () => interruptActiveTurn()
       });
       input.onControlReady?.(control);
+      if (settled || stopping) return;
       emitCodexEvent(input.emit, 'codex.turn.bound', 'Codex turn is ready for follow-up guidance', {
         threadId: activeThreadId,
         turnId: activeTurnId
@@ -1117,16 +1125,13 @@ function runCodexAppServerProcess(input) {
     }
 
     function succeed() {
-      if (settled) {
+      if (settled || stopping) {
         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();
+      rejectPendingRequests(pending, turnEndedError);
       cleanup();
       child.kill('SIGTERM');
       resolve({
@@ -1136,19 +1141,17 @@ function runCodexAppServerProcess(input) {
     }
 
     function fail(error) {
-      if (settled) {
-        return;
-      }
-      settled = true;
+      if (settled || stopping) return;
+      stopping = true;
       cleanup();
-      for (const pendingRequest of pending.values()) {
-        pendingRequest.reject(error);
-      }
-      pending.clear();
-      if (child.exitCode === null && !child.killed) {
-        child.kill('SIGTERM');
-      }
-      reject(error);
+      rejectPendingRequests(pending, error);
+      return stopCodexAppServer(child, {
+        interrupt: interruptActiveTurn, reason: error, processGroup: process.platform !== 'win32'
+      }).then(() => error, stopError => stopError).then(finalError => {
+        settled = true;
+        rejectPendingRequests(pending, finalError);
+        reject(finalError);
+      });
     }
 
     function cleanup() {

package/native-host/src/codexSessionTiming.js

@@ -36,10 +36,78 @@ function throwIfAborted(signal) {
   if (signal?.aborted) throw getAbortReason(signal);
 }
 
+function rejectPendingRequests(pending, error) {
+  for (const entry of pending.values()) entry.reject(error);
+  pending.clear();
+}
+
+async function stopCodexAppServer(child, {
+  interrupt, reason, processGroup = false, platform = process.platform,
+  interruptTimeoutMs = 1500, terminateTimeoutMs = 500, forceTimeoutMs = 1500,
+  kill = process.kill.bind(process), taskkill = defaultTaskkill
+} = {}) {
+  const pid = Number(child?.pid);
+  if (!Number.isInteger(pid) || pid <= 0) return;
+  const grouped = processGroup && platform !== 'win32';
+  const exited = () => child.exitCode != null || child.signalCode != null;
+  const groupGone = () => {
+    if (!grouped) return true;
+    try { kill(-pid, 0); return false; } catch (error) { return error?.code === 'ESRCH'; }
+  };
+  const stopped = () => exited() && groupGone();
+  const waitForStop = async timeoutMs => {
+    const deadline = Date.now() + timeoutMs;
+    while (!stopped() && Date.now() < deadline) {
+      await new Promise(resolve => setTimeout(resolve, Math.min(20, Math.max(1, deadline - Date.now()))));
+    }
+    return stopped();
+  };
+  const signal = value => {
+    if (grouped) {
+      try { kill(-pid, value); return; } catch (_error) { /* fall back to the owned child */ }
+    }
+    if (!exited()) {
+      try { child.kill(value); } catch (_error) { /* the exit check remains authoritative */ }
+    }
+  };
+  if (stopped()) return;
+  if (!exited() && typeof interrupt === 'function') {
+    let timer;
+    try {
+      await Promise.race([
+        Promise.resolve().then(interrupt).catch(() => {}),
+        new Promise(resolve => { timer = setTimeout(resolve, interruptTimeoutMs); })
+      ]);
+    } finally { clearTimeout(timer); }
+  }
+  if (platform === 'win32') {
+    if (!exited()) await taskkill(pid, forceTimeoutMs).catch(() => {});
+  } else {
+    signal('SIGTERM');
+    if (await waitForStop(terminateTimeoutMs)) return;
+    signal('SIGKILL');
+  }
+  if (!await waitForStop(forceTimeoutMs)) {
+    const error = new Error('Codex process exit could not be confirmed. Do not retry this project until the old process has stopped.');
+    error.code = 'codex_process_stop_unconfirmed';
+    error.cause = reason;
+    throw error;
+  }
+}
+
+function defaultTaskkill(pid, timeout) {
+  return new Promise((resolve, reject) => {
+    require('node:child_process').execFile('taskkill', ['/pid', String(pid), '/t', '/f'],
+      { windowsHide: true, timeout }, error => error ? reject(error) : resolve());
+  });
+}
+
 module.exports = {
   createCodexIdleWatchdog,
   createOptionalTimeout,
   getAbortReason,
   parseOptionalPositiveInteger,
+  rejectPendingRequests,
+  stopCodexAppServer,
   throwIfAborted
 };

package/native-host/src/readProgressGuard.js

@@ -19,6 +19,36 @@ function buildReadProgressRules() {
   ].join('\n');
 }
 
+function createRunEventScope(getTurn = () => ({})) {
+  const owners = new Map();
+  const identity = params => ({
+    threadId: String(params?.threadId || params?.thread?.id || ''),
+    turnId: String(params?.turnId || params?.turn?.id || '')
+  });
+  const itemId = params => String(params?.itemId || params?.item?.id || '');
+  const matches = owner => {
+    const active = getTurn() || {};
+    return (!owner.threadId || owner.threadId === active.threadId)
+      && (!owner.turnId || !active.turnId || owner.turnId === active.turnId);
+  };
+  return {
+    accepts(params = {}) {
+      const owner = identity(params);
+      const id = itemId(params);
+      if (owner.threadId || owner.turnId) {
+        if (id) owners.set(id, owner);
+        return matches(owner);
+      }
+      return !owners.has(id) || matches(owners.get(id));
+    },
+    owns(params = {}) {
+      const explicit = identity(params);
+      const owner = explicit.threadId || explicit.turnId ? explicit : owners.get(itemId(params));
+      return Boolean((getTurn() || {}).turnId && owner?.threadId && matches(owner));
+    }
+  };
+}
+
 function createReadProgressGuard(options = {}) {
   const settings = {
     minReadCommands: positiveInteger(options.minReadCommands, DEFAULT_MIN_READ_COMMANDS),
@@ -37,11 +67,19 @@ function createReadProgressGuard(options = {}) {
   let redundantStreak = 0;
   let postSteerRedundantStreak = 0;
   let steerIssued = false;
+  let steerAcknowledged = false;
   let abortIssued = false;
 
   return {
     observe(item) {
       if (abortIssued) return noAction();
+      if (item?.type === 'fileChange') {
+        coverageByFile.clear();
+        commandCounts.clear();
+        readCount = redundantStreak = postSteerRedundantStreak = 0;
+        steerIssued = steerAcknowledged = false;
+        return noAction();
+      }
       const inspection = extractReadInspection(item, settings.workspacePath);
       if (!inspection) {
         if (item?.type === 'commandExecution') {
@@ -52,8 +90,9 @@ function createReadProgressGuard(options = {}) {
       }
 
       readCount += 1;
-      const signatureCount = (commandCounts.get(inspection.signature) || 0) + 1;
-      commandCounts.set(inspection.signature, signatureCount);
+      const signatureKey = inspection.fileKey + '\0' + inspection.signature;
+      const signatureCount = (commandCounts.get(signatureKey) || 0) + 1;
+      commandCounts.set(signatureKey, signatureCount);
       let overlapRatio = 0;
       let redundant = signatureCount > 1;
 
@@ -85,6 +124,7 @@ function createReadProgressGuard(options = {}) {
       });
 
       if (steerIssued) {
+        if (!steerAcknowledged) return noAction(evidence);
         postSteerRedundantStreak = redundant ? postSteerRedundantStreak + 1 : 0;
         if (postSteerRedundantStreak >= settings.postSteerRedundantStreak) {
           abortIssued = true;
@@ -101,12 +141,20 @@ function createReadProgressGuard(options = {}) {
       return noAction(evidence);
     },
 
+    acknowledgeSteer() {
+      if (steerIssued && !abortIssued) {
+        steerAcknowledged = true;
+        postSteerRedundantStreak = 0;
+      }
+    },
+
     snapshot() {
       return {
         readCount,
         redundantStreak,
         postSteerRedundantStreak,
         steerIssued,
+        steerAcknowledged,
         abortIssued
       };
     }
@@ -120,9 +168,15 @@ function createReadProgressController({ input = {}, request, fail, getTurn, emit
   });
   let pendingSteer = null;
   let steerInFlight = false;
+  let generation = 0;
 
   return {
     observe(item) {
+      if (item?.type === 'fileChange') {
+        generation += 1;
+        pendingSteer = null;
+        steerInFlight = false;
+      }
       const decision = guard.observe(item);
       if (decision.action === 'steer') {
         steer(decision);
@@ -153,6 +207,7 @@ function createReadProgressController({ input = {}, request, fail, getTurn, emit
       return;
     }
     steerInFlight = true;
+    const steerGeneration = generation;
     emitEvent('codex.no_progress.steered', 'Repeated file reads detected; asking Codex to synthesize', {
       ...decision.evidence,
       guardAction: 'steer'
@@ -165,7 +220,10 @@ function createReadProgressController({ input = {}, request, fail, getTurn, emit
         text: buildReadProgressSteerText(decision.evidence, input.mode),
         text_elements: []
       }]
+    }).then(() => {
+      if (steerGeneration === generation) guard.acknowledgeSteer();
     }).catch(error => {
+      if (steerGeneration !== generation) return;
       const progressError = createNoProgressError(decision.evidence);
       progressError.message += ` Automatic steering failed: ${String(error?.message || error).slice(0, 500)}`;
       fail(progressError);
@@ -175,30 +233,35 @@ function createReadProgressController({ input = {}, request, fail, getTurn, emit
 
 function extractReadInspection(item = {}, workspacePath = '') {
   if (item.type !== 'commandExecution') return null;
+  if (item.status && item.status !== 'completed') return null;
+  if (Number.isInteger(item.exitCode) && item.exitCode !== 0) return null;
   const command = String(item.command || '').trim();
   if (!command) return null;
+  const cwd = typeof item.cwd === 'string' && item.cwd ? path.resolve(workspacePath || '.', item.cwd) : workspacePath;
   const actions = Array.isArray(item.commandActions) ? item.commandActions : [];
-  const readAction = actions.find(action => action?.type === 'read');
-  if (!readAction && !looksLikeReadCommand(command)) return null;
-
+  const readActions = actions.filter(action => action?.type === 'read');
+  if (!readActions.length && !looksLikeReadCommand(command)) return null;
+  const paths = [...new Set(readActions.map(action => normalizeFileKey(action.path, cwd)).filter(Boolean))];
+  if (paths.length > 1) return null;
   const bounded = extractBoundedRange(command);
-  const rawPath = bounded?.path || readAction?.path || '';
-  const fileKey = normalizeFileKey(rawPath, workspacePath);
-  const displayPath = safeDisplayPath(fileKey, workspacePath) || path.basename(fileKey) || 'project file';
-  const range = bounded
-    ? { startLine: bounded.startLine, endLine: bounded.endLine }
-    : null;
+  const boundedKey = normalizeFileKey(bounded?.path, cwd);
+  if (boundedKey && paths[0] && boundedKey !== paths[0]) return null;
+  const fileKey = paths[0] || boundedKey;
+  if (!fileKey) return null;
   return {
-    fileKey: fileKey || displayPath,
-    displayPath,
-    range,
+    fileKey,
+    displayPath: safeDisplayPath(fileKey, workspacePath) || path.basename(fileKey),
+    range: bounded && boundedKey === fileKey
+      ? { startLine: bounded.startLine, endLine: bounded.endLine } : null,
     signature: normalizeCommandSignature(command, workspacePath)
   };
 }
 
 function extractBoundedRange(command) {
   const source = String(command || '');
-  const sedMatch = source.match(/\bsed\s+(?:-[A-Za-z]+\s+)*["']?(\d+)\s*,\s*(\d+)p["']?(?:\s+((?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s;&|]+)))?/i);
+  // Stream pagination and compound commands do not prove source-file ranges.
+  if (/[|;&<>\x60]/.test(source)) return null;
+  const sedMatch = source.match(/\bsed\s+(?:-[A-Za-z]+\s+)*["']?(\d+)\s*,\s*(\d+)p["']?\s+((?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s;&|]+))/i);
   if (sedMatch) {
     return normalizeRangeMatch(sedMatch[1], sedMatch[2], sedMatch[3]);
   }
@@ -212,13 +275,15 @@ function extractBoundedRange(command) {
 function normalizeRangeMatch(startValue, endValue, pathValue) {
   const startLine = Number(startValue);
   const endLine = Number(endValue);
+  const filePath = unquoteShellWord(pathValue);
+  if (!filePath || filePath === '-') return null;
   if (!Number.isSafeInteger(startLine) || !Number.isSafeInteger(endLine) || startLine < 1 || endLine < startLine) {
     return null;
   }
   return {
     startLine,
     endLine,
-    path: unquoteShellWord(pathValue)
+    path: filePath
   };
 }
 
@@ -228,8 +293,9 @@ function looksLikeReadCommand(command) {
 }
 
 function normalizeFileKey(value, workspacePath) {
+  if (typeof value !== 'string') return '';
   const source = unquoteShellWord(value);
-  if (!source) return '';
+  if (!source || source === '-' || source.startsWith('~') || /[$\x60*?\[\]{}]/.test(source)) return '';
   if (path.isAbsolute(source)) return path.normalize(source);
   return path.resolve(workspacePath || '.', source);
 }
@@ -355,6 +421,7 @@ module.exports = {
   createNoProgressError,
   createReadProgressController,
   createReadProgressGuard,
+  createRunEventScope,
   extractBoundedRange,
   extractReadInspection
 };

package/package.json

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