codex-overleaf-link 2.5.0 → 2.6.0

package/native-host/src/taskRunnerRuntime.js

@@ -2,7 +2,12 @@
 
 const { buildCodexRuntimeEvent } = require('./codexRuntimeIdentity');
 
+const { runOwnedNativeHelper } = require('./nativeHelperLifecycle');
+const { stopCodexAppServer, throwIfAborted } = require('./codexSessionTiming');
 const { spawn } = require('node:child_process');
+const { normalizeSafeProjectPath } = require('../../extension/src/shared/projectFiles');
+const { createHash } = require('node:crypto');
+const NativeRequestIdentity = require('../../extension/src/shared/nativeRequestIdentity');
 const { buildOperationSummary, splitDeletePlan } = require('../../extension/src/shared/summary');
 const {
   MIN_COMPATIBLE_EXTENSION_VERSION,
@@ -36,6 +41,7 @@ const {
 const { version: PACKAGE_VERSION } = require('../../package.json');
 
 const processStopBarrier = require('./processStopBarrier');
+const runLifecycle = require('./nativeRunLifecycle');
 const activeProjectLocks = new Map();
 const activeRunControllers = new Map();
 const activeRunEntries = new Map();
@@ -44,7 +50,7 @@ const activeRunEntries = new Map();
 // Overleaf tab was reloaded — the requestId lived in content-side JS state
 // and is gone, but the native-host-side controller is still running).
 const activeRunByProject = new Map();
-const CODEX_RUN_PASSTHROUGH_ERROR_CODES = new Set(['thread_resume_failed', 'codex_no_usable_result', 'codex_process_stop_unconfirmed', 'selected_context_unresolved']);
+const CODEX_RUN_PASSTHROUGH_ERROR_CODES = new Set(['thread_resume_failed', 'codex_no_usable_result', 'codex_context_limit', 'codex_process_stop_unconfirmed', 'selected_context_unresolved', 'codex_local_skill_unavailable']);
 
 async function handleRequest(request, env = process.env, emit = () => {}) {
   if (!request || typeof request !== 'object') {
@@ -66,7 +72,7 @@ async function handleRequest(request, env = process.env, emit = () => {}) {
       platform: getNativeRuntimePlatform({ env }),
       protocolVersion: 2,
       supportedProtocol: { ...SUPPORTED_NATIVE_PROTOCOL },
-      capabilities: Object.fromEntries(REQUIRED_CAPABILITIES.map(capability => [capability, true])),
+      capabilities: { ...Object.fromEntries(REQUIRED_CAPABILITIES.map(capability => [capability, true])), literalProjectPaths: true, threadCompact: true },
       minExtensionVersion: MIN_COMPATIBLE_EXTENSION_VERSION,
       version: PACKAGE_VERSION,
       environment: summarizeNativeEnvironment(env)
@@ -204,7 +210,16 @@ function quotaErrorResponse(id, violation) {
 }
 
 async function handleCodexRun(request, env, emit) {
+  const identity = NativeRequestIdentity.validate(request.id);
+  if (!identity.ok) return errorResponse(request.id, identity.error.code, identity.error.message, identity.error.details);
   let params = request.params || {};
+  if (params.operation === 'compact') {
+    if (typeof params.threadId !== 'string' || !params.threadId.trim() || params.threadId.length > 160
+      || typeof params.projectId !== 'string' || !params.projectId.trim()) {
+      return errorResponse(request.id, 'codex_compact_thread_required', 'Compaction requires an existing project conversation.');
+    }
+    params = { ...params, threadId: params.threadId.trim(), mode: 'ask', writingStyleBuild: undefined };
+  }
   if (params.writingStyleBuild != null) {
     if (typeof params.writingStyleBuild !== 'object' || Array.isArray(params.writingStyleBuild)) {
       return errorResponse(request.id, 'writing_style_invalid_build', 'Writing style build settings must be an object.');
@@ -215,7 +230,7 @@ async function handleCodexRun(request, env, emit) {
       useExistingMirror: false,
       fileOverlays: [],
       writingStyle: null,
-      writingStyleBuild: { ...params.writingStyleBuild, requestId: String(request.id || '') }
+      writingStyleBuild: { ...params.writingStyleBuild, requestId: String(request.id) }
     };
   }
   if (isCodexMissing(env)) {
@@ -236,17 +251,16 @@ async function handleCodexRun(request, env, emit) {
     return errorResponse(request.id, 'project_locked', `Project ${projectKey} is currently in use by codex.run`);
   }
   const abortController = new AbortController();
+  const lifetime = runLifecycle.register({ controller: abortController, projectKey, rootDir: env.CODEX_OVERLEAF_MIRROR_ROOT });
   const activeEntry = {
-    id: request.id || '',
+    id: request.id,
     projectKey,
     controller: abortController,
     control: null
   };
-  if (request.id) {
-    activeRunControllers.set(request.id, abortController);
-    activeRunEntries.set(request.id, activeEntry);
-    activeRunByProject.set(projectKey, activeEntry);
-  }
+  activeRunControllers.set(request.id, abortController);
+  activeRunEntries.set(request.id, activeEntry);
+  activeRunByProject.set(projectKey, activeEntry);
   let providerResolution;
   try {
     try {
@@ -264,7 +278,10 @@ async function handleCodexRun(request, env, emit) {
       return providerErrorResponse(request.id, error);
     }
 
-    if (params.useExistingMirror) {
+    abortController.signal.throwIfAborted();
+    // Compaction only updates the captured thread; it neither refreshes the
+    // project mirror nor accepts document overlays as part of this request.
+    if (params.operation !== 'compact' && params.useExistingMirror) {
       const { getMirrorStatus, applyFileOverlays } = require('./mirrorWorkspace');
       const rootDir = env.CODEX_OVERLEAF_MIRROR_ROOT;
       const status = getMirrorStatus(projectKey, { rootDir });
@@ -288,10 +305,12 @@ async function handleCodexRun(request, env, emit) {
         );
       }
 
-      if (Array.isArray(params.fileOverlays) && params.fileOverlays.length) {
+      // OT overlays prove that the current page agrees with the trusted OT
+      // baseline; they must not rewrite it or supply a replacement hash.
+      if (!isOtWarmMirrorReuseRequest(params) && Array.isArray(params.fileOverlays) && params.fileOverlays.length) {
         await applyFileOverlays({ projectId: projectKey, overlays: params.fileOverlays, rootDir });
       }
-    } else if (!params.writingStyleBuild && !isSnapshotlessSkillInstallerRun(params) && !hasRunnableProjectSnapshotEvidence(params)) {
+    } else if (params.operation !== 'compact' && !params.writingStyleBuild && !isSnapshotlessSkillInstallerRun(params) && !hasRunnableProjectSnapshotEvidence(params)) {
       return errorResponse(
         request.id,
         'codex_run_requires_snapshot_evidence',
@@ -306,6 +325,7 @@ async function handleCodexRun(request, env, emit) {
       rootDir: env.CODEX_OVERLEAF_MIRROR_ROOT,
       providerLaunch: providerResolution.providerLaunch,
       onStopUnconfirmed: error => processStopBarrier.record(projectKey, env.CODEX_OVERLEAF_MIRROR_ROOT, error),
+      onProcessStarted: lifetime.trackProcess,
       onControlReady: control => {
         activeEntry.control = control;
       },
@@ -346,16 +366,17 @@ async function handleCodexRun(request, env, emit) {
     });
     return errorResponse(request.id, 'codex_run_failed', truncateText(error.message, 12000));
   } finally {
-    if (request.id && activeRunControllers.get(request.id) === abortController) {
+    if (activeRunControllers.get(request.id) === abortController) {
       activeRunControllers.delete(request.id);
     }
-    if (request.id && activeRunEntries.get(request.id) === activeEntry) {
+    if (activeRunEntries.get(request.id) === activeEntry) {
       activeRunEntries.delete(request.id);
     }
     if (activeRunByProject.get(projectKey)?.controller === abortController) {
       activeRunByProject.delete(projectKey);
     }
     releaseProjectLock(projectKey, lockToken);
+    lifetime.complete();
   }
 }
 
@@ -365,6 +386,9 @@ async function handleCodexSteer(request) {
   if (!entry?.control) {
     return errorResponse(request.id, 'codex_turn_not_ready', 'The active Codex turn is not ready for guidance.');
   }
+  if (entry.control.operation === 'compact') {
+    return errorResponse(request.id, 'codex_compact_not_steerable', 'Wait for context compaction to finish before sending a message.');
+  }
   const expectedThreadId = String(params.threadId || '');
   const expectedTurnId = String(params.expectedTurnId || params.turnId || '');
   if ((expectedThreadId && expectedThreadId !== entry.control.threadId)
@@ -400,8 +424,8 @@ async function handleCodexSteer(request) {
 }
 
 function findActiveRunEntry(params = {}) {
-  const targetId = String(params.requestId || params.id || '');
-  if (targetId && activeRunEntries.has(targetId)) {
+  const targetId = params.requestId ?? params.id;
+  if (activeRunEntries.has(targetId)) {
     return activeRunEntries.get(targetId);
   }
   const projectKey = String(params.projectKey || '');
@@ -420,11 +444,11 @@ function findActiveRunEntry(params = {}) {
 //      can't punch through a real live run.
 function handleCodexCancel(request, env = process.env) {
   const params = request.params || {};
-  const targetId = params.requestId || params.id;
+  const targetId = params.requestId ?? params.id;
   const projectKey = typeof params.projectKey === 'string' ? params.projectKey : '';
   const force = params.force === true;
 
-  if (targetId && activeRunControllers.has(targetId)) {
+  if (activeRunControllers.has(targetId)) {
     activeRunControllers.get(targetId).abort(createCancellationError());
     return okResponse(request.id, {
       cancelled: true,
@@ -439,7 +463,7 @@ function handleCodexCancel(request, env = process.env) {
       return okResponse(request.id, {
         cancelled: true,
         projectKey,
-        requestId: entry.id || ''
+        requestId: entry.id
       });
     }
     if (processStopBarrier.isBlocked(projectKey, env.CODEX_OVERLEAF_MIRROR_ROOT)) {
@@ -473,8 +497,10 @@ function handleCodexHistoryClear(request, env) {
   }
 }
 
-function handleSkillsList(request, env) {
+async function handleSkillsList(request, env) {
   try {
+    if (request.params?.scope === 'codex-local') return okResponse(request.id,
+      await require('./codexLocalSkills').listCodexLocalSkills({ env }));
     const { CODEX_OVERLEAF_SKILL_SCOPE, listCodexOverleafSkills, listProjectSkills } = require('./localSkills');
     if (request.params?.scope === CODEX_OVERLEAF_SKILL_SCOPE) {
       // Install/restore official skills before listing so newly shipped ones
@@ -493,9 +519,9 @@ function handleSkillsList(request, env) {
     return errorResponse(request.id, 'skills_list_failed', error.message);
   }
 }
-
 function handleSkillsInstall(request, env) {
   try {
+    if (request.params?.scope === 'codex-local') throw new Error('Local Codex skills are managed by Codex.');
     const { CODEX_OVERLEAF_SKILL_SCOPE, installCodexOverleafSkill, installProjectSkill } = require('./localSkills');
     if (request.params?.scope === CODEX_OVERLEAF_SKILL_SCOPE) {
       return okResponse(request.id, installCodexOverleafSkill({
@@ -514,9 +540,9 @@ function handleSkillsInstall(request, env) {
     return errorResponse(request.id, 'skills_install_failed', error.message);
   }
 }
-
 function handleSkillsRemove(request, env) {
   try {
+    if (request.params?.scope === 'codex-local') throw new Error('Local Codex skills are managed by Codex.');
     const { CODEX_OVERLEAF_SKILL_SCOPE, removeCodexOverleafSkill, removeProjectSkill } = require('./localSkills');
     if (request.params?.scope === CODEX_OVERLEAF_SKILL_SCOPE) {
       return okResponse(request.id, removeCodexOverleafSkill({
@@ -544,13 +570,13 @@ function hasRunnableProjectSnapshotEvidence(params = {}) {
   if (params.restrictToFocusFiles !== true) {
     return false;
   }
-  const normalizedFocusFiles = normalizeSnapshotEvidencePaths(params.focusFiles);
+  const normalizedFocusFiles = normalizeSnapshotEvidencePaths(params.focusFiles, params.focusFilesAreLiteral === true);
   if (!normalizedFocusFiles.length || !Array.isArray(params.project?.files)) {
     return false;
   }
   const evidenceFiles = new Map();
   for (const file of params.project.files) {
-    const filePath = normalizeSnapshotEvidencePath(file?.path);
+    const filePath = normalizeSafeProjectPath(file?.path);
     if (!filePath || !isUsableSnapshotEvidenceContent(file?.content)) {
       continue;
     }
@@ -561,19 +587,14 @@ function hasRunnableProjectSnapshotEvidence(params = {}) {
 
 function isSnapshotlessSkillInstallerRun(params = {}) {
   return params.skipMirrorSync === true
-    && String(params.skillInvocation?.id || '').trim() === 'skill-installer';
+    && String(params.skillInvocation?.id || '').trim() === 'skill-installer'
+    && (!params.skillInvocation?.scope || params.skillInvocation.scope === 'builtin');
 }
 
 function validateOtFocusedWarmMirrorReuse(params = {}, status = {}) {
   if (!isOtWarmMirrorReuseRequest(params)) {
     return { ok: false };
   }
-  if (Array.isArray(params.fileOverlays) && params.fileOverlays.length) {
-    return {
-      ok: false,
-      message: 'OT warm mirror reuse does not accept file overlays'
-    };
-  }
   if (status?.exists !== true) {
     return {
       ok: false,
@@ -586,7 +607,7 @@ function validateOtFocusedWarmMirrorReuse(params = {}, status = {}) {
       message: 'OT warm mirror reuse requires restrictToFocusFiles=true'
     };
   }
-  const normalizedFocusFiles = normalizeSnapshotEvidencePaths(params.focusFiles);
+  const normalizedFocusFiles = normalizeSnapshotEvidencePaths(params.focusFiles, params.focusFilesAreLiteral === true);
   if (!normalizedFocusFiles.length) {
     return {
       ok: false,
@@ -594,14 +615,14 @@ function validateOtFocusedWarmMirrorReuse(params = {}, status = {}) {
     };
   }
 
-  const freshFiles = new Set();
+  const freshFiles = new Map();
   for (const file of Array.isArray(status.otFreshFiles) ? status.otFreshFiles : []) {
     if (file?.state !== 'fresh') {
       continue;
     }
-    const filePath = normalizeSnapshotEvidencePath(file.path);
+    const filePath = normalizeSafeProjectPath(file.path);
     if (filePath) {
-      freshFiles.add(filePath);
+      freshFiles.set(filePath, file);
     }
   }
   const missingFiles = normalizedFocusFiles.filter(filePath => !freshFiles.has(filePath));
@@ -612,6 +633,22 @@ function validateOtFocusedWarmMirrorReuse(params = {}, status = {}) {
     };
   }
 
+  if (Array.isArray(params.fileOverlays) && params.fileOverlays.length) {
+    const overlays = new Set();
+    for (const overlay of params.fileOverlays) {
+      const filePath = normalizeSafeProjectPath(overlay?.path);
+      if (!normalizedFocusFiles.includes(filePath) || overlays.has(filePath)
+        || typeof overlay?.content !== 'string' || !/^[a-f0-9]{64}$/i.test(freshFiles.get(filePath)?.sha256 || '')
+        || createHash('sha256').update(overlay.content).digest('hex') !== freshFiles.get(filePath).sha256.toLowerCase()) {
+        return { ok: false, message: 'OT warm mirror overlay does not match the current focused OT baseline' };
+      }
+      overlays.add(filePath);
+    }
+    if (normalizedFocusFiles.some(filePath => !overlays.has(filePath))) {
+      return { ok: false, message: 'OT warm mirror overlays do not cover all focused files' };
+    }
+  }
+
   return { ok: true };
 }
 
@@ -627,11 +664,11 @@ function isUsableSnapshotEvidenceContent(content) {
   return Boolean(text) && !/^(loading|loading\.{3}|loading…)$/i.test(text);
 }
 
-function normalizeSnapshotEvidencePaths(value) {
+function normalizeSnapshotEvidencePaths(value, literal = false) {
   const seen = new Set();
   const paths = [];
   for (const item of Array.isArray(value) ? value : []) {
-    const filePath = normalizeSnapshotEvidencePath(item);
+    const filePath = literal ? normalizeSafeProjectPath(item) : normalizeSnapshotEvidencePath(item);
     if (!filePath || seen.has(filePath)) {
       continue;
     }
@@ -656,13 +693,14 @@ function createCancellationError() {
 }
 
 function isCancellationError(error = {}) {
+  if (['codex_turn_failed', 'codex_turn_status_invalid', 'codex_context_limit'].includes(error.code)) return false;
   return error.code === 'codex_cancelled'
     || error.name === 'AbortError'
     || /cancelled by the user|was cancelled/i.test(error.message || '');
 }
 
 function shouldPassthroughCodexRunError(error = {}) {
-  return CODEX_RUN_PASSTHROUGH_ERROR_CODES.has(error.code);
+  return CODEX_RUN_PASSTHROUGH_ERROR_CODES.has(error.code) || String(error.code || '').startsWith('codex_compact_');
 }
 
 function isCodexMissing(env = process.env) {
@@ -753,6 +791,7 @@ async function handleMirrorConfirmWriteback(request, env) {
     const result = await confirmWritebackFiles({
       projectId,
       paths: params.paths,
+      expectedFiles: params.expectedFiles,
       rootDir
     });
     return okResponse(request.id, result);
@@ -1127,10 +1166,12 @@ function parseAgentArgsJson(value) {
 }
 
 function runExternalAgent(agentSpec, params, emit = () => {}, options = {}) {
-  return new Promise((resolve, reject) => {
+  return runOwnedNativeHelper(signal => new Promise((resolve, reject) => {
+    throwIfAborted(signal);
     const child = spawn(agentSpec.file, agentSpec.args || [], {
       env: options.env || process.env,
       shell: false,
+      detached: process.platform !== 'win32',
       stdio: ['pipe', 'pipe', 'pipe']
     });
     const timeoutMs = parseOptionalPositiveInteger(options.timeoutMs);
@@ -1140,6 +1181,8 @@ function runExternalAgent(agentSpec, params, emit = () => {}, options = {}) {
     let stderrRemainder = '';
     let outputBytes = 0;
     let settled = false;
+    const onAbort = () => fail(signal.reason);
+    signal.addEventListener('abort', onAbort, { once: true });
 
     const timeout = timeoutMs
       ? setTimeout(() => {
@@ -1164,10 +1207,8 @@ function runExternalAgent(agentSpec, params, emit = () => {}, options = {}) {
       if (timeout) {
         clearTimeout(timeout);
       }
-      if (child.exitCode === null && !child.killed) {
-        child.kill('SIGTERM');
-      }
-      reject(error);
+      signal.removeEventListener('abort', onAbort);
+      stopCodexAppServer(child, { processGroup: process.platform !== 'win32', reason: error }).then(() => reject(error), reject);
     }
 
     function succeed(result) {
@@ -1178,7 +1219,8 @@ function runExternalAgent(agentSpec, params, emit = () => {}, options = {}) {
       if (timeout) {
         clearTimeout(timeout);
       }
-      resolve(result);
+      signal.removeEventListener('abort', onAbort);
+      stopCodexAppServer(child, { processGroup: process.platform !== 'win32' }).then(() => resolve(result), reject);
     }
 
     child.stdout.setEncoding('utf8');
@@ -1200,6 +1242,7 @@ function runExternalAgent(agentSpec, params, emit = () => {}, options = {}) {
         emitTaskEvent(emit, event.type || 'agent.progress', event.title || event.type || 'Agent progress', event.detail || {}, event.status || 'running');
       }
     });
+    child.stdin.on('error', fail);
     child.on('error', fail);
     child.on('close', code => {
       if (settled) {
@@ -1226,7 +1269,7 @@ function runExternalAgent(agentSpec, params, emit = () => {}, options = {}) {
     });
 
     child.stdin.end(JSON.stringify(params));
-  });
+  }));
 }
 
 function parsePositiveInteger(value, fallback) {
@@ -1299,27 +1342,19 @@ function errorResponse(id, code, message, details = {}) {
   };
 }
 
-function getActiveNativeWorkState() {
+function getActiveNativeWorkState(env = process.env) {
   return {
     projectLocks: activeProjectLocks.size,
+    processStopBarriers: processStopBarrier.getBlockedProjectCount(env.CODEX_OVERLEAF_MIRROR_ROOT, { env }),
     runControllers: activeRunControllers.size,
     activeTurnControls: Array.from(activeRunEntries.values()).filter(entry => entry.control).length
   };
 }
 
-function abortAllActiveOperations(reason = 'Native messaging transport disconnected.') {
-  const error = new Error(String(reason || 'Native messaging transport disconnected.'));
-  error.code = 'native_transport_closed';
-  for (const controller of activeRunControllers.values()) {
-    if (controller && !controller.signal?.aborted) {
-      controller.abort(error);
-    }
-  }
-}
-
 module.exports = {
   NATIVE_REQUEST_QUOTAS,
-  abortAllActiveOperations,
+  abortAllActiveOperations: runLifecycle.abortAllActiveOperations,
+  quarantineActiveOperations: runLifecycle.quarantineActiveOperations,
   buildDefaultTaskResult,
   getActiveNativeWorkState,
   handleRequest,