oh-my-codex 0.18.9 → 0.18.11

package/src/scripts/run-test-files.ts

@@ -6,14 +6,24 @@ const DEFAULT_TEST_TIMEOUT_MS = 0;
 const DEFAULT_RUNNER_TIMEOUT_MS = 30 * 60 * 1_000;
 const DEFAULT_FORCE_EXIT_GRACE_MS = 30_000;
 const DEFAULT_CI_TEST_CONCURRENCY = 1;
-const RUNTIME_STATE_ENV_KEYS = [
-  'OMX_ROOT',
-  'OMX_STATE_ROOT',
-  'OMX_TEAM_STATE_ROOT',
-  'OMX_SESSION_ID',
-  'CODEX_SESSION_ID',
-  'SESSION_ID',
-] as const;
+const DEFAULT_LOCAL_TEST_CONCURRENCY = 1;
+const PRESERVED_TEST_ENV_KEYS = new Set([
+  'OMX_EXPLORE_BIN',
+  'OMX_NODE_TEST_CONCURRENCY',
+  'OMX_NODE_TEST_FORCE_EXIT',
+  'OMX_NODE_TEST_FORCE_EXIT_GRACE_MS',
+  'OMX_NODE_TEST_PRESERVE_RUNTIME_ENV',
+  'OMX_NODE_TEST_RUNNER_TIMEOUT_MS',
+  'OMX_NODE_TEST_TIMEOUT_MS',
+]);
+
+type TestRunResult = {
+  status: number | null;
+  signal: NodeJS.Signals | null;
+  errorMessage?: string;
+  timedOut: boolean;
+  abnormal: boolean;
+};
 
 function parseBooleanEnv(value: string | undefined): boolean {
   if (!value) return false;
@@ -60,7 +70,36 @@ function parseTestConcurrency(env: NodeJS.ProcessEnv): number | undefined {
     return undefined;
   }
 
-  return env.CI === 'true' || env.GITHUB_ACTIONS === 'true' ? DEFAULT_CI_TEST_CONCURRENCY : undefined;
+  return env.CI === 'true' || env.GITHUB_ACTIONS === 'true'
+    ? DEFAULT_CI_TEST_CONCURRENCY
+    : DEFAULT_LOCAL_TEST_CONCURRENCY;
+}
+
+function shouldScrubRuntimeEnvKey(key: string): boolean {
+  if (PRESERVED_TEST_ENV_KEYS.has(key)) return false;
+  return (
+    key.startsWith('OMX_') ||
+    key.startsWith('OMXBOX_') ||
+    key.startsWith('CODEX_') ||
+    key === 'USE_OMX_EXPLORE_CMD' ||
+    key === 'SESSION_ID' ||
+    key === 'TMUX' ||
+    key === 'TMUX_PANE'
+  );
+}
+
+function buildChildEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+  const childEnv = { ...env };
+  delete childEnv.NODE_TEST_CONTEXT;
+  if (!parseBooleanEnv(env.OMX_NODE_TEST_PRESERVE_RUNTIME_ENV)) {
+    for (const key of Object.keys(childEnv)) {
+      if (shouldScrubRuntimeEnvKey(key)) {
+        delete childEnv[key];
+      }
+    }
+  }
+  childEnv.OMX_TEST_RELAX_TMUX_TIMEOUT = '1';
+  return childEnv;
 }
 
 const roots = process.argv.slice(2);
@@ -82,41 +121,33 @@ const runnerTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_RUNNER_TIMEOUT_
 const forceExitGraceMs = parseTimeoutMs(process.env.OMX_NODE_TEST_FORCE_EXIT_GRACE_MS, DEFAULT_FORCE_EXIT_GRACE_MS);
 const testConcurrency = parseTestConcurrency(process.env);
 const forceExit = parseBooleanEnv(process.env.OMX_NODE_TEST_FORCE_EXIT);
-const testArgs = ['--test'];
+const sharedTestArgs = ['--test'];
 if (testTimeoutMs > 0) {
-  testArgs.push(`--test-timeout=${testTimeoutMs}`);
+  sharedTestArgs.push(`--test-timeout=${testTimeoutMs}`);
 }
 if (testConcurrency) {
-  testArgs.push(`--test-concurrency=${testConcurrency}`);
+  sharedTestArgs.push(`--test-concurrency=${testConcurrency}`);
 }
 if (forceExit) {
-  testArgs.push('--test-force-exit', '--test-reporter=tap');
+  sharedTestArgs.push('--test-force-exit', '--test-reporter=tap');
 }
-testArgs.push(...files);
 
 console.error(
   `[run-test-files] running ${files.length} test file(s) from ${targets.join(', ')}${
     testTimeoutMs > 0 ? ` with per-test timeout ${testTimeoutMs}ms` : ' with per-test timeout disabled'
   }${testConcurrency ? `, test concurrency ${testConcurrency}` : ', default test concurrency'}${
     forceExit ? `, force exit enabled with ${forceExitGraceMs}ms completion grace` : ', force exit disabled'
-  }${runnerTimeoutMs > 0 ? `, and runner timeout ${runnerTimeoutMs}ms` : ', and runner timeout disabled'}`,
+  }${runnerTimeoutMs > 0 ? `, and runner timeout ${runnerTimeoutMs}ms` : ', and runner timeout disabled'}, with per-file process isolation`,
 );
 
-const childEnv = { ...process.env };
-delete childEnv.NODE_TEST_CONTEXT;
-childEnv.OMX_TEST_RELAX_TMUX_TIMEOUT = '1';
-if (!parseBooleanEnv(process.env.OMX_NODE_TEST_PRESERVE_RUNTIME_ENV)) {
-  for (const key of RUNTIME_STATE_ENV_KEYS) {
-    delete childEnv[key];
-  }
-}
+const childEnv = buildChildEnv(process.env);
 
-function reportAbnormalExit(signal: NodeJS.Signals | null, errorMessage?: string): void {
+function reportAbnormalExit(file: string, signal: NodeJS.Signals | null, errorMessage?: string): void {
   if (errorMessage) {
-    console.error(`[run-test-files] node --test error: ${errorMessage}`);
+    console.error(`[run-test-files] node --test error for ${file}: ${errorMessage}`);
   }
   console.error(
-    `[run-test-files] node --test did not exit normally${signal ? ` (signal: ${signal})` : ''}. `
+    `[run-test-files] node --test did not exit normally for ${file}${signal ? ` (signal: ${signal})` : ''}. `
       + `Roots: ${targets.join(', ')}. Test files: ${files.length}. `
       + `Per-test timeout: ${testTimeoutMs > 0 ? `${testTimeoutMs}ms` : 'disabled'}. `
       + `Test concurrency: ${testConcurrency ?? 'default'}. `
@@ -146,155 +177,203 @@ function terminateChild(child: ChildProcess): void {
   signalChild(child, 'SIGKILL');
 }
 
-function runWithCompletionForceExit(): void {
-  let finished = false;
-  let sawFailure = false;
-  let lastTapOk = 0;
-  let tapTests: number | undefined;
-  let tapPass: number | undefined;
-  let tapFail = 0;
-  let tapCancelled = 0;
-  let completedFromSummary = false;
-  let completionTimer: NodeJS.Timeout | undefined;
-  let runnerTimer: NodeJS.Timeout | undefined;
-  let stdoutRemainder = '';
-  let stderrRemainder = '';
-
-  const child = spawn(process.execPath, testArgs, {
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: childEnv,
-    detached: !isWindows(),
-  });
-
-  function finish(exitCode: number, reason: string): void {
-    if (finished) return;
-    finished = true;
-    if (completionTimer) clearTimeout(completionTimer);
-    if (runnerTimer) clearTimeout(runnerTimer);
-    console.error(`[run-test-files] ${reason}; exiting with status ${exitCode}`);
-    terminateChild(child);
-    child.stdout?.destroy();
-    child.stderr?.destroy();
-    child.unref();
-    process.exit(exitCode);
-  }
+function runFileWithCompletionForceExit(file: string): Promise<TestRunResult> {
+  return new Promise((resolveRun) => {
+    let finished = false;
+    let sawFailure = false;
+    let lastTapOk = 0;
+    let tapTests: number | undefined;
+    let tapPass: number | undefined;
+    let tapFail = 0;
+    let tapCancelled = 0;
+    let completedFromSummary = false;
+    let completionTimer: NodeJS.Timeout | undefined;
+    let runnerTimer: NodeJS.Timeout | undefined;
+    let stdoutRemainder = '';
+    let stderrRemainder = '';
+
+    const child = spawn(process.execPath, [...sharedTestArgs, file], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: childEnv,
+      detached: !isWindows(),
+    });
+
+    function finish(status: number | null, signal: NodeJS.Signals | null, reason: string, terminate: boolean): void {
+      if (finished) return;
+      finished = true;
+      if (completionTimer) clearTimeout(completionTimer);
+      if (runnerTimer) clearTimeout(runnerTimer);
+      console.error(`[run-test-files] ${file}: ${reason}; status ${status ?? 'unknown'}`);
+      if (terminate) {
+        terminateChild(child);
+      }
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      child.unref();
+      resolveRun({
+        status,
+        signal,
+        timedOut: reason.startsWith('runner timeout'),
+        abnormal: status === null || signal !== null || reason.startsWith('node --test failed to spawn'),
+      });
+    }
 
-  function markFailure(): void {
-    sawFailure = true;
-    if (completionTimer) {
-      clearTimeout(completionTimer);
-      completionTimer = undefined;
+    function markFailure(): void {
+      sawFailure = true;
+      if (completionTimer) {
+        clearTimeout(completionTimer);
+        completionTimer = undefined;
+      }
     }
-  }
 
-  function armCompletionTimer(reason: string): void {
-    if (sawFailure) return;
-    if (completionTimer) clearTimeout(completionTimer);
-    completionTimer = setTimeout(() => {
+    function armCompletionTimer(reason: string): void {
       if (sawFailure) return;
-      finish(0, reason);
-    }, forceExitGraceMs);
-  }
-
-  function sawCleanTapSummary(): boolean {
-    if (tapTests === undefined || tapPass === undefined) return false;
-    return tapTests === tapPass && tapFail === 0 && tapCancelled === 0;
-  }
-
-  function parseTapLine(line: string): void {
-    if (/^(?:not ok|Bail out!)/.test(line)) {
-      markFailure();
-      return;
+      if (completionTimer) clearTimeout(completionTimer);
+      completionTimer = setTimeout(() => {
+        if (sawFailure) return;
+        finish(0, null, reason, true);
+      }, forceExitGraceMs);
     }
 
-    const summary = line.match(/^# (tests|pass|fail|cancelled) (\d+)$/);
-    if (summary) {
-      const count = Number(summary[2]);
-      if (summary[1] === 'tests') tapTests = count;
-      if (summary[1] === 'pass') tapPass = count;
-      if (summary[1] === 'fail') tapFail = count;
-      if (summary[1] === 'cancelled') tapCancelled = count;
-      if ((summary[1] === 'fail' || summary[1] === 'cancelled') && count > 0) markFailure();
-      return;
+    function sawCleanTapSummary(): boolean {
+      if (tapTests === undefined || tapPass === undefined) return false;
+      return tapTests === tapPass && tapFail === 0 && tapCancelled === 0;
     }
 
-    const ok = line.match(/^ok (\d+)\b/);
-    if (ok) {
-      lastTapOk = Number(ok[1]);
-      if (lastTapOk >= files.length) {
-        armCompletionTimer(`force-exit completion grace elapsed after TAP ok ${lastTapOk} with no later failures`);
+    function parseTapLine(line: string): void {
+      if (/^(?:not ok|Bail out!)/.test(line)) {
+        markFailure();
+        return;
       }
-      return;
-    }
 
-    const plan = line.match(/^1\.\.(\d+)$/);
-    if (plan && Number(plan[1]) === lastTapOk && !sawFailure) {
-      armCompletionTimer(`force-exit completion grace elapsed after TAP plan ${line}`);
-      return;
-    }
+      const summary = line.match(/^# (tests|pass|fail|cancelled) (\d+)$/);
+      if (summary) {
+        const count = Number(summary[2]);
+        if (summary[1] === 'tests') tapTests = count;
+        if (summary[1] === 'pass') tapPass = count;
+        if (summary[1] === 'fail') tapFail = count;
+        if (summary[1] === 'cancelled') tapCancelled = count;
+        if ((summary[1] === 'fail' || summary[1] === 'cancelled') && count > 0) markFailure();
+        return;
+      }
 
-    if (/^# duration_ms /.test(line) && sawCleanTapSummary()) {
-      completedFromSummary = true;
-      armCompletionTimer('force-exit completion grace elapsed after clean TAP summary');
-    }
-  }
+      const ok = line.match(/^ok (\d+)\b/);
+      if (ok) {
+        lastTapOk = Number(ok[1]);
+        if (lastTapOk >= files.length) {
+          armCompletionTimer(`force-exit completion grace elapsed after TAP ok ${lastTapOk} with no later failures`);
+        }
+        return;
+      }
 
-  function handleOutput(chunk: Buffer, stream: NodeJS.WriteStream, isStdout: boolean): void {
-    stream.write(chunk);
-    const text = chunk.toString('utf8');
-    let combined = (isStdout ? stdoutRemainder : stderrRemainder) + text;
-    const lines = combined.split(/\r?\n/);
-    combined = lines.pop() ?? '';
-    if (isStdout) {
-      stdoutRemainder = combined;
-    } else {
-      stderrRemainder = combined;
-    }
-    for (const line of lines) parseTapLine(line);
-  }
+      const plan = line.match(/^1\.\.(\d+)$/);
+      if (plan && Number(plan[1]) === lastTapOk && !sawFailure) {
+        armCompletionTimer(`force-exit completion grace elapsed after TAP plan ${line}`);
+        return;
+      }
 
-  child.stdout?.on('data', (chunk: Buffer) => handleOutput(chunk, process.stdout, true));
-  child.stderr?.on('data', (chunk: Buffer) => handleOutput(chunk, process.stderr, false));
+      if (/^# duration_ms /.test(line) && sawCleanTapSummary()) {
+        completedFromSummary = true;
+        armCompletionTimer('force-exit completion grace elapsed after clean TAP summary');
+      }
+    }
 
-  child.on('error', (error) => {
-    reportAbnormalExit(null, error.message);
-    finish(1, 'node --test failed to spawn');
-  });
+    function handleOutput(chunk: Buffer, stream: NodeJS.WriteStream, isStdout: boolean): void {
+      stream.write(chunk);
+      const text = chunk.toString('utf8');
+      let combined = (isStdout ? stdoutRemainder : stderrRemainder) + text;
+      const lines = combined.split(/\r?\n/);
+      combined = lines.pop() ?? '';
+      if (isStdout) {
+        stdoutRemainder = combined;
+      } else {
+        stderrRemainder = combined;
+      }
+      for (const line of lines) parseTapLine(line);
+    }
 
-  child.on('exit', (status, signal) => {
-    if (finished) return;
-    if (stdoutRemainder) parseTapLine(stdoutRemainder);
-    if (stderrRemainder) parseTapLine(stderrRemainder);
-    if (typeof status === 'number') {
-      finish(status, `node --test exited normally${completedFromSummary ? ' after clean TAP summary' : ''}`);
-      return;
+    child.stdout?.on('data', (chunk: Buffer) => handleOutput(chunk, process.stdout, true));
+    child.stderr?.on('data', (chunk: Buffer) => handleOutput(chunk, process.stderr, false));
+
+    child.on('error', (error) => {
+      reportAbnormalExit(file, null, error.message);
+      finish(null, null, 'node --test failed to spawn', true);
+    });
+
+    child.on('exit', (status, signal) => {
+      if (finished) return;
+      if (stdoutRemainder) parseTapLine(stdoutRemainder);
+      if (stderrRemainder) parseTapLine(stderrRemainder);
+      if (typeof status === 'number') {
+        finish(status, null, `node --test exited normally${completedFromSummary ? ' after clean TAP summary' : ''}`, false);
+        return;
+      }
+      reportAbnormalExit(file, signal);
+      finish(null, signal, 'node --test exited without a numeric status', true);
+    });
+
+    if (runnerTimeoutMs > 0) {
+      runnerTimer = setTimeout(() => {
+        reportAbnormalExit(file, null);
+        finish(1, null, `runner timeout ${runnerTimeoutMs}ms elapsed`, true);
+      }, runnerTimeoutMs);
     }
-    reportAbnormalExit(signal);
-    finish(1, 'node --test exited without a numeric status');
   });
-
-  if (runnerTimeoutMs > 0) {
-    runnerTimer = setTimeout(() => {
-      reportAbnormalExit(null);
-      finish(1, `runner timeout ${runnerTimeoutMs}ms elapsed`);
-    }, runnerTimeoutMs);
-  }
 }
 
-if (forceExit) {
-  runWithCompletionForceExit();
-} else {
-  const result = spawnSync(process.execPath, testArgs, {
+function runFileSync(file: string): TestRunResult {
+  const result = spawnSync(process.execPath, [...sharedTestArgs, file], {
     stdio: 'inherit',
     env: childEnv,
     timeout: runnerTimeoutMs > 0 ? runnerTimeoutMs : undefined,
     killSignal: 'SIGTERM',
   });
 
-  if (typeof result.status === 'number') {
-    process.exit(result.status);
+  const timedOut = (result.error as NodeJS.ErrnoException | undefined)?.code === 'ETIMEDOUT';
+  if (result.status !== 0 && (result.error || typeof result.status !== 'number')) {
+    reportAbnormalExit(file, result.signal, result.error?.message);
   }
 
-  reportAbnormalExit(result.signal, result.error?.message);
-  process.exit(1);
+  return {
+    status: result.status,
+    signal: result.signal,
+    errorMessage: result.error?.message,
+    timedOut,
+    abnormal: Boolean(result.error || typeof result.status !== 'number'),
+  };
 }
+
+async function main(): Promise<void> {
+  const failedFiles: string[] = [];
+  let abnormalExit = false;
+  let runnerTimedOut = false;
+
+  for (const file of files) {
+    const result = forceExit ? await runFileWithCompletionForceExit(file) : runFileSync(file);
+
+    if (result.status === 0) {
+      continue;
+    }
+
+    failedFiles.push(file);
+    abnormalExit = abnormalExit || result.abnormal;
+    runnerTimedOut = runnerTimedOut || result.timedOut;
+  }
+
+  if (failedFiles.length > 0 || runnerTimedOut) {
+    const failureSummary = failedFiles.length === 0 && runnerTimedOut
+      ? `runner timed out with 0 of ${files.length} test file(s) failed`
+      : `${failedFiles.length} of ${files.length} test file(s) failed${abnormalExit ? ' or timed out' : ''}${runnerTimedOut ? '; runner timed out' : ''}`;
+    console.error(
+      `[run-test-files] ${failureSummary}:`,
+    );
+    for (const file of failedFiles) {
+      console.error(`[run-test-files]   ${file}`);
+    }
+    process.exit(1);
+  }
+
+  process.exit(0);
+}
+
+await main();