oh-my-codex 0.21.37 → 0.21.39

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

@@ -1,9 +1,11 @@
 import { spawnSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, writeFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { describe, it } from 'node:test';
+import { pathToFileURL } from 'node:url';
 import assert from 'node:assert/strict';
+import { computeOmxPluginCacheClaimDigest } from '../../cli/plugin-marketplace.js';
 
 function runCompiledRunner(root: string, envOverrides: Record<string, string> = {}, timeoutMs = 15_000) {
   return spawnSync(process.execPath, ['dist/scripts/run-test-files.js', root], {
@@ -18,6 +20,193 @@ function runCompiledRunner(root: string, envOverrides: Record<string, string> =
 }
 
 describe('run-test-files diagnostics', () => {
+  it('isolates personal config and plugin caches per file without changing protected inputs or tool access', async () => {
+    const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
+    try {
+      const personalHome = realpathSync(mkdtempSync(join(wd, 'personal-home-')));
+      const codexHome = join(personalHome, '.codex');
+      const pluginCache = join(codexHome, 'plugins', 'cache', 'test-marketplace', 'oh-my-codex', '1.0.0');
+      mkdirSync(join(pluginCache, '.codex-plugin'), { recursive: true });
+      const protectedFiles = new Map([
+        [join(codexHome, '.omx-config.json'), JSON.stringify({ agentReasoning: { explore: 'high' }, agentModels: { explore: 'personal-model' } })],
+        [join(pluginCache, '.codex-plugin', 'plugin.json'), JSON.stringify({ name: 'oh-my-codex', version: '1.0.0' })],
+      ]);
+      for (const [path, content] of protectedFiles) writeFileSync(path, content);
+      const markerPath = join(pluginCache, '.omx-complete');
+      const marker = `${JSON.stringify({ version: '1.0.0', claimDigest: await computeOmxPluginCacheClaimDigest(pluginCache) })}\n`;
+      writeFileSync(markerPath, marker);
+      protectedFiles.set(markerPath, marker);
+
+      const modelsUrl = pathToFileURL(resolve('dist/config/models.js')).href;
+      const pathsUrl = pathToFileURL(resolve('dist/utils/paths.js')).href;
+      const pluginUrl = pathToFileURL(resolve('dist/cli/plugin-marketplace.js')).href;
+      const testsDir = join(wd, '__tests__');
+      mkdirSync(testsDir);
+      for (const name of ['a', 'b']) {
+        writeFileSync(join(testsDir, `${name}.test.js`), [
+          "import { test } from 'node:test';",
+          "import assert from 'node:assert/strict';",
+          "import { writeFileSync, mkdirSync } from 'node:fs';",
+          "import { homedir } from 'node:os';",
+          "import { join } from 'node:path';",
+          "import { spawnSync } from 'node:child_process';",
+          `import { getAgentReasoningOverride, getAgentModelOverride } from ${JSON.stringify(modelsUrl)};`,
+          `import { codexHome } from ${JSON.stringify(pathsUrl)};`,
+          `import { discoverOmxPluginCacheDirs } from ${JSON.stringify(pluginUrl)};`,
+          "test('home is isolated before imports and remains overridable by fixtures', async () => {",
+          `  const personalCodexHome = ${JSON.stringify(codexHome)};`,
+          "  assert.equal(getAgentReasoningOverride('explore', personalCodexHome), 'high');",
+          "  assert.equal(getAgentModelOverride('explore', personalCodexHome), 'personal-model');",
+          `  assert.deepEqual(await discoverOmxPluginCacheDirs(personalCodexHome), [${JSON.stringify(pluginCache)}]);`,
+          `  assert.notEqual(homedir(), ${JSON.stringify(personalHome)});`,
+          "  assert.equal(process.env.HOME, homedir());",
+          "  assert.equal(process.env.USERPROFILE, homedir());",
+          "  assert.equal(getAgentReasoningOverride('explore'), undefined);",
+          "  assert.equal(getAgentModelOverride('explore'), undefined);",
+          "  assert.deepEqual(await discoverOmxPluginCacheDirs(codexHome()), []);",
+          `  assert.equal(process.env.PATH, ${JSON.stringify(process.env.PATH)});`,
+          `  assert.equal(process.env.TMPDIR, ${JSON.stringify(process.env.TMPDIR)});`,
+          `  const tool = spawnSync(process.execPath, ['-e', ${JSON.stringify("process.stdout.write('tool reachable')")}], { encoding: 'utf8' });`,
+          "  assert.equal(tool.status, 0, tool.stderr);",
+          "  assert.equal(tool.stdout, 'tool reachable');",
+          `  writeFileSync(${JSON.stringify(join(wd, `${name}-home.txt`))}, homedir());`,
+          "  mkdirSync(codexHome(), { recursive: true });",
+          "  writeFileSync(join(codexHome(), '.omx-config.json'), JSON.stringify({ agentReasoning: { explore: 'low' } }));",
+          "  assert.equal(getAgentReasoningOverride('explore'), 'low');",
+          `  process.env.HOME = ${JSON.stringify(personalHome)};`,
+          `  process.env.USERPROFILE = ${JSON.stringify(personalHome)};`,
+          "  assert.equal(getAgentReasoningOverride('explore'), 'high');",
+          "});",
+          '',
+        ].join('\n'));
+      }
+
+      for (const forceExit of ['0', '1']) {
+        const result = runCompiledRunner(testsDir, { HOME: personalHome, USERPROFILE: personalHome, OMX_NODE_TEST_FORCE_EXIT: forceExit });
+        assert.equal(result.status, 0, `${result.stderr}\n${result.stdout}`);
+        const homes = ['a', 'b'].map((name) => readFileSync(join(wd, `${name}-home.txt`), 'utf8'));
+        assert.notEqual(homes[0], homes[1]);
+        for (const home of homes) assert.equal(existsSync(home), false, 'completed test homes must be removed');
+        for (const [path, content] of protectedFiles) assert.equal(readFileSync(path, 'utf8'), content);
+      }
+    } finally {
+      rmSync(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('removes isolated homes after failing test files in both runner modes', () => {
+    const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
+    try {
+      const testPath = join(wd, 'failure.test.js');
+      const homeRecord = join(wd, 'home.txt');
+      writeFileSync(testPath, [
+        "import { test } from 'node:test';",
+        "import assert from 'node:assert/strict';",
+        "import { writeFileSync } from 'node:fs';",
+        "import { homedir } from 'node:os';",
+        `writeFileSync(${JSON.stringify(homeRecord)}, homedir());`,
+        "test('fails', () => assert.fail('expected fixture failure'));",
+        '',
+      ].join('\n'));
+      for (const forceExit of ['0', '1']) {
+        const result = runCompiledRunner(testPath, { OMX_NODE_TEST_FORCE_EXIT: forceExit });
+        assert.notEqual(result.status, 0, `${result.stderr}\n${result.stdout}`);
+        assert.match(result.stdout, /expected fixture failure/);
+        assert.equal(existsSync(readFileSync(homeRecord, 'utf8')), false);
+      }
+    } finally {
+      rmSync(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('keeps the isolated home until a force-terminated child closes', () => {
+    const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
+    try {
+      const recordPath = join(wd, 'child-close.json');
+      const preloadPath = join(wd, 'observe-close.mjs');
+      writeFileSync(preloadPath, [
+        "import childProcess from 'node:child_process';",
+        "import { existsSync, writeFileSync } from 'node:fs';",
+        "import { syncBuiltinESMExports } from 'node:module';",
+        'const originalSpawn = childProcess.spawn;',
+        'childProcess.spawn = (...args) => {',
+        '  const child = originalSpawn(...args);',
+        '  const home = args[2].env.HOME;',
+        '  child.once(\'close\', () => {',
+        `    writeFileSync(${JSON.stringify(recordPath)}, JSON.stringify({ home, exists: existsSync(home) }));`,
+        '  });',
+        '  return child;',
+        '};',
+        'syncBuiltinESMExports();',
+        '',
+      ].join('\n'));
+      const testPath = join(wd, 'exit-block.test.js');
+      writeFileSync(testPath, [
+        "import { test } from 'node:test';",
+        "test('passes but cannot exit normally', () => {",
+        "  process.on('SIGTERM', () => {});",
+        "  process.on('exit', () => { while (true) {} });",
+        '});',
+        '',
+      ].join('\n'));
+      const result = spawnSync(process.execPath, ['--import', pathToFileURL(preloadPath).href, 'dist/scripts/run-test-files.js', testPath], {
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          OMX_NODE_TEST_FORCE_EXIT: '1',
+          OMX_NODE_TEST_FORCE_EXIT_GRACE_MS: '100',
+          OMX_NODE_TEST_RUNNER_TIMEOUT_MS: '2000',
+        },
+        timeout: 5_000,
+      });
+
+      assert.equal(result.status, 0, `${result.stderr}\n${result.stdout}`);
+      assert.match(result.stderr, /force-exit completion grace elapsed/);
+      assert.equal(existsSync(recordPath), true, 'runner must observe child close before exiting');
+      const record = JSON.parse(readFileSync(recordPath, 'utf8')) as { home: string; exists: boolean };
+      assert.equal(record.exists, true, 'isolated home must remain available until child close');
+      assert.equal(existsSync(record.home), false, 'isolated home must be removed after child close');
+    } finally {
+      rmSync(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('can preserve the caller home for explicit diagnostics independently of runtime env', () => {
+    const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
+    try {
+      const home = join(wd, 'personal-home');
+      mkdirSync(home);
+      const markerPath = join(home, 'protected-input.txt');
+      writeFileSync(markerPath, 'unchanged input\n');
+      const testPath = join(wd, 'home-preserve.test.js');
+      writeFileSync(testPath, [
+        "import { test } from 'node:test';",
+        "import assert from 'node:assert/strict';",
+        "import { homedir } from 'node:os';",
+        "test('home diagnostic opt-in does not preserve runtime env', () => {",
+        `  assert.equal(homedir(), ${JSON.stringify(home)});`,
+        `  assert.equal(process.env.HOME, ${JSON.stringify(home)});`,
+        `  assert.equal(process.env.USERPROFILE, ${JSON.stringify(home)});`,
+        "  assert.equal(process.env.CODEX_HOME, undefined);",
+        "  assert.equal(process.env.OMX_ROOT, undefined);",
+        "});",
+        '',
+      ].join('\n'));
+
+      const result = runCompiledRunner(testPath, {
+        HOME: home,
+        USERPROFILE: home,
+        OMX_NODE_TEST_PRESERVE_HOME: '1',
+        CODEX_HOME: '/tmp/live-codex-home',
+        OMX_ROOT: '/tmp/live-omx-root',
+      });
+      assert.equal(result.status, 0, `${result.stderr}\n${result.stdout}`);
+      assert.equal(readFileSync(markerPath, 'utf8'), 'unchanged input\n');
+    } finally {
+      rmSync(wd, { recursive: true, force: true });
+    }
+  });
+
   it('applies a bounded node --test timeout so hanging tests fail with file context', () => {
     const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
     try {
@@ -398,6 +587,7 @@ describe('run-test-files diagnostics', () => {
           "import assert from 'node:assert/strict';",
           "test('runner env allowlist is narrow', () => {",
           "  assert.equal(process.env.OMX_EXPLORE_BIN, '/tmp/fake-explore');",
+          "  assert.equal(process.env.OMX_RUNTIME_BINARY, '/tmp/fake-runtime');",
           "  assert.equal(process.env.OMX_NODE_TEST_CONCURRENCY, '1');",
           "  assert.equal(process.env.OMX_ROOT, undefined);",
           "  assert.equal(process.env.CODEX_HOME, undefined);",
@@ -408,6 +598,7 @@ describe('run-test-files diagnostics', () => {
 
       const result = runCompiledRunner(wd, {
         OMX_EXPLORE_BIN: '/tmp/fake-explore',
+        OMX_RUNTIME_BINARY: '/tmp/fake-runtime',
         OMX_NODE_TEST_CONCURRENCY: '1',
         OMX_ROOT: '/tmp/live-omx-root',
         CODEX_HOME: '/tmp/live-codex-home',

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

@@ -1,5 +1,6 @@
 import { spawn, spawnSync, type ChildProcess } from 'node:child_process';
-import { readdirSync, statSync } from 'node:fs';
+import { mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 
 const DEFAULT_TEST_TIMEOUT_MS = 0;
@@ -13,6 +14,7 @@ const PRESERVED_TEST_ENV_KEYS = new Set([
   'OMX_NODE_TEST_CONCURRENCY',
   'OMX_NODE_TEST_FORCE_EXIT',
   'OMX_NODE_TEST_FORCE_EXIT_GRACE_MS',
+  'OMX_NODE_TEST_PRESERVE_HOME',
   'OMX_NODE_TEST_PRESERVE_RUNTIME_ENV',
   'OMX_NODE_TEST_RUNNER_TIMEOUT_MS',
   'OMX_NODE_TEST_TIMEOUT_MS',
@@ -123,6 +125,7 @@ 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 preserveHome = parseBooleanEnv(process.env.OMX_NODE_TEST_PRESERVE_HOME);
 const sharedTestArgs = ['--test'];
 if (testTimeoutMs > 0) {
   sharedTestArgs.push(`--test-timeout=${testTimeoutMs}`);
@@ -139,7 +142,7 @@ console.error(
     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'}, with per-file process isolation`,
+  }${runnerTimeoutMs > 0 ? `, and runner timeout ${runnerTimeoutMs}ms` : ', and runner timeout disabled'}, with per-file process isolation and ${preserveHome ? 'caller home preserved' : 'isolated homes'}`,
 );
 
 const childEnv = buildChildEnv(process.env);
@@ -179,7 +182,7 @@ function terminateChild(child: ChildProcess): void {
   signalChild(child, 'SIGKILL');
 }
 
-function runFileWithCompletionForceExit(file: string): Promise<TestRunResult> {
+function runFileWithCompletionForceExit(file: string, env: NodeJS.ProcessEnv): Promise<TestRunResult> {
   return new Promise((resolveRun) => {
     let finished = false;
     let sawFailure = false;
@@ -196,7 +199,7 @@ function runFileWithCompletionForceExit(file: string): Promise<TestRunResult> {
 
     const child = spawn(process.execPath, [...sharedTestArgs, file], {
       stdio: ['ignore', 'pipe', 'pipe'],
-      env: childEnv,
+      env,
       detached: !isWindows(),
     });
 
@@ -206,18 +209,22 @@ function runFileWithCompletionForceExit(file: string): Promise<TestRunResult> {
       if (completionTimer) clearTimeout(completionTimer);
       if (runnerTimer) clearTimeout(runnerTimer);
       console.error(`[run-test-files] ${file}: ${reason}; status ${status ?? 'unknown'}`);
+      // Signals start termination; close confirms this child and its stdio are
+      // finished before main removes the file's isolated home.
+      child.once('close', () => {
+        child.unref();
+        resolveRun({
+          status,
+          signal,
+          timedOut: reason.startsWith('runner timeout'),
+          abnormal: status === null || signal !== null || reason.startsWith('node --test failed to spawn'),
+        });
+      });
       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 {
@@ -323,10 +330,10 @@ function runFileWithCompletionForceExit(file: string): Promise<TestRunResult> {
   });
 }
 
-function runFileSync(file: string): TestRunResult {
+function runFileSync(file: string, env: NodeJS.ProcessEnv): TestRunResult {
   const result = spawnSync(process.execPath, [...sharedTestArgs, file], {
     stdio: 'inherit',
-    env: childEnv,
+    env,
     timeout: runnerTimeoutMs > 0 ? runnerTimeoutMs : undefined,
     killSignal: 'SIGTERM',
   });
@@ -351,7 +358,17 @@ async function main(): Promise<void> {
   let runnerTimedOut = false;
 
   for (const file of files) {
-    const result = forceExit ? await runFileWithCompletionForceExit(file) : runFileSync(file);
+    // Runtime env scrubbing does not isolate personal config or plugin caches.
+    // Keep tool paths and temporary-directory settings, but start each file with
+    // an empty home unless the caller explicitly opts into home diagnostics.
+    const home = preserveHome ? undefined : mkdtempSync(join(tmpdir(), 'omx-node-test-home-'));
+    const env = home ? { ...childEnv, HOME: home, USERPROFILE: home } : childEnv;
+    let result: TestRunResult;
+    try {
+      result = forceExit ? await runFileWithCompletionForceExit(file, env) : runFileSync(file, env);
+    } finally {
+      if (home) rmSync(home, { recursive: true, force: true });
+    }
 
     if (result.status === 0) {
       continue;