remote-codex 0.11.44 → 0.11.49

package/packages/acp/src/terminal-service.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+
+import { AcpTerminalService } from './terminal-service';
+
+describe('AcpTerminalService', () => {
+  it('parses agents that send command and argv as one ACP command string', async () => {
+    const service = new AcpTerminalService(() => process.cwd());
+    const created = service.create({
+      sessionId: 'session-1',
+      command: `"${process.execPath}" -e "process.stdout.write('ACP_TERMINAL_OK')"`,
+      args: [],
+      outputByteLimit: 1_000,
+    });
+    const exit = await service.waitForExit({
+      sessionId: 'session-1',
+      terminalId: created.terminalId,
+    });
+    const output = service.output({
+      sessionId: 'session-1',
+      terminalId: created.terminalId,
+    });
+
+    expect(exit.exitCode).toBe(0);
+    expect(output.output).toBe('ACP_TERMINAL_OK');
+    expect(output.truncated).toBe(false);
+    service.release({
+      sessionId: 'session-1',
+      terminalId: created.terminalId,
+    });
+  });
+});

package/packages/acp/src/terminal-service.ts

@@ -0,0 +1,137 @@
+import type { ChildProcess } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+
+import type * as acp from '@agentclientprotocol/sdk';
+
+import {
+  parseCommandLine,
+  spawnProcess,
+} from '../../process-runtime/src/index';
+
+const DEFAULT_OUTPUT_BYTE_LIMIT = 1024 * 1024;
+
+interface AcpTerminalState {
+  child: ChildProcess;
+  chunks: Buffer[];
+  outputByteLimit: number;
+  exitStatus: acp.TerminalExitStatus | null;
+  exitPromise: Promise<acp.WaitForTerminalExitResponse>;
+  resolveExit: (status: acp.WaitForTerminalExitResponse) => void;
+}
+
+function retainedOutput(state: AcpTerminalState) {
+  const complete = Buffer.concat(state.chunks);
+  if (complete.byteLength <= state.outputByteLimit) {
+    return { output: complete.toString('utf8'), truncated: false };
+  }
+
+  let start = complete.byteLength - state.outputByteLimit;
+  while (start < complete.byteLength && (complete[start]! & 0xc0) === 0x80) {
+    start += 1;
+  }
+  return {
+    output: complete.subarray(start).toString('utf8'),
+    truncated: true,
+  };
+}
+
+export class AcpTerminalService {
+  private readonly terminals = new Map<string, AcpTerminalState>();
+
+  constructor(private readonly sessionCwd: (sessionId: string) => string | null) {}
+
+  create(params: acp.CreateTerminalRequest): acp.CreateTerminalResponse {
+    const terminalId = randomUUID();
+    const cwd = params.cwd ?? this.sessionCwd(params.sessionId) ?? process.cwd();
+    const parsed = params.args && params.args.length > 0
+      ? { command: params.command, args: params.args }
+      : parseCommandLine(params.command);
+    const child = spawnProcess({
+      command: parsed.command,
+      args: parsed.args,
+      cwd,
+      env: {
+        ...process.env,
+        ...Object.fromEntries((params.env ?? []).map((entry) => [entry.name, entry.value])),
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let resolveExit!: (status: acp.WaitForTerminalExitResponse) => void;
+    const exitPromise = new Promise<acp.WaitForTerminalExitResponse>((resolve) => {
+      resolveExit = resolve;
+    });
+    const state: AcpTerminalState = {
+      child,
+      chunks: [],
+      outputByteLimit: Math.max(1, params.outputByteLimit ?? DEFAULT_OUTPUT_BYTE_LIMIT),
+      exitStatus: null,
+      exitPromise,
+      resolveExit,
+    };
+    this.terminals.set(terminalId, state);
+
+    const append = (chunk: Buffer | string) => {
+      state.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    };
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', (error) => append(`${error.message}\n`));
+    child.on('close', (code, signal) => {
+      const exitStatus: acp.TerminalExitStatus = {
+        exitCode: code,
+        signal,
+      };
+      state.exitStatus = exitStatus;
+      state.resolveExit(exitStatus);
+    });
+
+    return { terminalId };
+  }
+
+  output(params: acp.TerminalOutputRequest): acp.TerminalOutputResponse {
+    const state = this.require(params.terminalId);
+    const output = retainedOutput(state);
+    return {
+      ...output,
+      ...(state.exitStatus ? { exitStatus: state.exitStatus } : {}),
+    };
+  }
+
+  waitForExit(params: acp.WaitForTerminalExitRequest) {
+    return this.require(params.terminalId).exitPromise;
+  }
+
+  kill(params: acp.KillTerminalRequest): acp.KillTerminalResponse {
+    const state = this.require(params.terminalId);
+    if (!state.exitStatus) {
+      state.child.kill('SIGTERM');
+    }
+    return {};
+  }
+
+  release(params: acp.ReleaseTerminalRequest): acp.ReleaseTerminalResponse {
+    const state = this.require(params.terminalId);
+    if (!state.exitStatus) {
+      state.child.kill('SIGTERM');
+    }
+    this.terminals.delete(params.terminalId);
+    return {};
+  }
+
+  stop() {
+    for (const state of this.terminals.values()) {
+      if (!state.exitStatus) {
+        state.child.kill('SIGTERM');
+      }
+    }
+    this.terminals.clear();
+  }
+
+  private require(terminalId: string) {
+    const state = this.terminals.get(terminalId);
+    if (!state) {
+      throw new Error(`ACP terminal not found: ${terminalId}`);
+    }
+    return state;
+  }
+}

package/packages/agent-runtime/src/runtime-errors.ts

@@ -73,6 +73,7 @@ export function isRemoteThreadBootstrapError(error: unknown) {
   }
 
   return (
+    (isRecord(error.details) && error.details.historyUnavailable === true) ||
     error.message.includes('includeTurns is unavailable before first user message') ||
     error.message.includes('is not materialized yet') ||
     error.message.includes('no rollout found for thread id') ||

package/packages/agent-runtime/src/types.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'node:events';
 import type {
+  AcpAgentOptionMetadataDto,
   AgentBackendIdDto,
   AgentBackendInstallationDto,
   ThreadHistoryItemDto,
@@ -159,6 +160,8 @@ export interface AgentModel {
     description: string;
   }>;
   defaultReasoningEffort: string | null;
+  selectionKind?: 'model' | 'agent';
+  acpAgent?: AcpAgentOptionMetadataDto | null;
 }
 
 export type AgentSessionStatus =
@@ -228,6 +231,7 @@ export interface ReadAgentSessionOptions {
 
 export interface StartAgentSessionInput {
   cwd: string;
+  agentId?: string | null;
   model: string;
   reasoningEffort?: string | null;
   approvalMode: 'yolo' | 'guarded';
@@ -237,6 +241,7 @@ export interface StartAgentSessionInput {
 
 export interface StartAgentSessionResult {
   provider: AgentProviderId;
+  agentId?: string | null;
   providerSessionId: string;
   model: string | null;
   reasoningEffort?: string | null;
@@ -549,6 +554,8 @@ export interface AgentRuntime extends EventEmitter {
   stop(): Promise<void>;
 
   listModels(): Promise<AgentModel[]>;
+  listAgentOptions?(): Promise<AgentModel[]>;
+  listModelsForAgent?(agentId: string, cwd: string): Promise<AgentModel[]>;
   listSessions(): Promise<AgentSessionSummary[]>;
   listLoadedSessions(): Promise<string[]>;
   readSession(
@@ -582,6 +589,7 @@ export interface AgentRuntime extends EventEmitter {
   getGoal?(providerSessionId: string): Promise<AgentGoal | null>;
   setGoal?(input: SetAgentGoalInput): Promise<AgentGoal>;
   clearGoal?(providerSessionId: string): Promise<boolean>;
+  installModel?(modelId: string): Promise<void>;
   getSubscriptionUsage?(): Promise<{
     provider: 'codex' | 'claude';
     authKind: 'subscription' | 'apiKey' | 'unknown';

package/packages/claude/src/runtimeAdapter.test.ts

@@ -1266,7 +1266,7 @@ describe('ClaudeRuntimeAdapter', () => {
           message: {
             role: 'user',
             content:
-              '<task-notification>\\n<task-id>task-1</task-id>\\n<tool-use-id>toolu_agent_xml</tool-use-id>\\n<status>completed</status>\\n<summary>Agent \"Audit docs\" finished</summary>\\n<result>Found one stale runbook.</result>\\n</task-notification>',
+              '<task-notification>\\n<task-id>task-1</task-id>\\n<tool-use-id>toolu_agent_xml</tool-use-id>\\n<status>completed</status>\\n<summary>Agent "Audit docs" finished</summary>\\n<result>Found one stale runbook.</result>\\n</task-notification>',
           },
           parent_tool_use_id: null,
           uuid: '00000000-0000-4000-8000-000000000042' as any,
@@ -2380,7 +2380,7 @@ describe('ClaudeRuntimeAdapter', () => {
           message: {
             role: 'user',
             content:
-              '<task-notification>\\n<task-id>task-a</task-id>\\n<tool-use-id>toolu_task_a</tool-use-id>\\n<status>completed</status>\\n<summary>Agent \"Audit infra docs\" finished</summary>\\n<result>Infra docs need one migration checklist.</result>\\n</task-notification>',
+              '<task-notification>\\n<task-id>task-a</task-id>\\n<tool-use-id>toolu_task_a</tool-use-id>\\n<status>completed</status>\\n<summary>Agent "Audit infra docs" finished</summary>\\n<result>Infra docs need one migration checklist.</result>\\n</task-notification>',
           },
           parent_tool_use_id: null,
         },

package/packages/claude/src/runtimeAdapter.ts

@@ -1,11 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
-import { execFile } from 'node:child_process';
 import fs from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { promisify } from 'node:util';
 
 import type {
   AgentActionQuestion,
@@ -58,8 +56,9 @@ import {
   userMessageHistoryItem,
   userMessageToHistoryItem,
 } from './historyItems';
+import { runProcess } from '../../process-runtime/src/index';
+import { isPathInside } from '../../workspace/src/index';
 
-const execFileAsync = promisify(execFile);
 
 type ClaudePromptInput = string | AsyncIterable<SDKUserMessage>;
 type ClaudeMessageContent =
@@ -379,8 +378,7 @@ function resolvePromptAssetPath(assetPath: string, cwd: string | null | undefine
   const resolvedPath = path.isAbsolute(assetPath)
     ? path.normalize(assetPath)
     : path.resolve(cwd, assetPath);
-  const relativePath = path.relative(cwd, resolvedPath);
-  if (relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath))) {
+  if (isPathInside(cwd, resolvedPath)) {
     return resolvedPath;
   }
   return null;
@@ -2566,12 +2564,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
 
     const relativePath = `./.temp/threads/${input.localThreadId}/claude-history-${safeAssetFilePart(input.messageId)}-${input.blockIndex}.${extension}`;
     const targetPath = path.resolve(input.workspacePath, relativePath);
-    const relativeToWorkspace = path.relative(input.workspacePath, targetPath);
-    if (
-      relativeToWorkspace === '' ||
-      relativeToWorkspace.startsWith('..') ||
-      path.isAbsolute(relativeToWorkspace)
-    ) {
+    if (!isPathInside(input.workspacePath, targetPath)) {
       return null;
     }
 
@@ -2833,12 +2826,10 @@ async function importOptionalPackage(specifier: string) {
 }
 
 async function npmGlobalRoot() {
-  try {
-    const { stdout } = await execFileAsync('npm', ['root', '-g'], {
-      timeout: 3_000,
-    });
-    return stdout.trim() || null;
-  } catch {
-    return null;
-  }
+  const result = await runProcess({
+    command: 'npm',
+    args: ['root', '-g'],
+    timeoutMs: 3_000,
+  });
+  return result.code === 0 ? result.stdout.trim() || null : null;
 }

package/packages/codex/src/appServerManager.test.ts

@@ -1,5 +1,8 @@
 import { EventEmitter } from 'node:events';
 import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 import { PassThrough, Writable } from 'node:stream';
 
 import { describe, expect, it } from 'vitest';
@@ -80,6 +83,8 @@ class ScriptedChild extends EventEmitter {
 }
 
 describe('CodexAppServerManager', () => {
+  const windowsIt = it.runIf(process.platform === 'win32');
+
   it('starts against a newline-delimited JSON-RPC process', async () => {
     const script = [
       "const readline=require('node:readline');",
@@ -117,6 +122,48 @@ describe('CodexAppServerManager', () => {
     await manager.stop();
   });
 
+  windowsIt('starts an npm-style Codex command shim from a path with spaces', async () => {
+    const directory = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'remote-codex app server shim '),
+    );
+    const scriptPath = path.join(directory, 'fake-codex.cjs');
+    const shimPath = path.join(directory, 'fake-codex.cmd');
+    const script = [
+      "const readline = require('node:readline');",
+      'const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });',
+      "rl.on('line', (line) => {",
+      ' const message = JSON.parse(line);',
+      " if (message.method === 'initialize') {",
+      "  process.stdout.write(JSON.stringify({ id: message.id, result: { userAgent: 'fake-cmd', codexHome: 'C:/tmp', platformFamily: 'windows', platformOs: 'windows' } }) + '\\n');",
+      ' }',
+      '});',
+    ].join('\n');
+
+    await fs.writeFile(scriptPath, script);
+    await fs.writeFile(
+      shimPath,
+      `@echo off\r\n"${process.execPath}" "%~dp0fake-codex.cjs" %*\r\n`,
+    );
+
+    const manager = new CodexAppServerManager({
+      command: shimPath,
+      startupTimeoutMs: 3_000,
+      clientInfo: {
+        name: 'test',
+        title: 'test',
+        version: '0.1.0',
+      },
+    });
+
+    try {
+      await manager.start();
+      expect(manager.getStatus().state).toBe('ready');
+    } finally {
+      await manager.stop();
+      await fs.rm(directory, { recursive: true, force: true });
+    }
+  });
+
   it('surfaces spawn failures as a failed status instead of crashing', async () => {
     class FailingChild extends EventEmitter {
       stdout = new PassThrough();

package/packages/codex/src/appServerManager.ts

@@ -1,6 +1,8 @@
-import { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';
+import { ChildProcessWithoutNullStreams } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 
+import { spawnProcess as spawnCrossPlatformProcess } from '../../process-runtime/src/index';
+
 import { JsonRpcClient, JsonRpcClientError } from './jsonrpc';
 import {
   AppServerStatusSnapshot,
@@ -250,7 +252,9 @@ export class CodexAppServerManager extends EventEmitter {
     this.spawnProcess =
       options.spawnProcess ??
       ((command: string, args: string[]) =>
-        spawn(command, args, {
+        spawnCrossPlatformProcess({
+          command,
+          args,
           stdio: 'pipe'
         }) as unknown as ChildProcessWithoutNullStreams);
   }

package/packages/codex/src/runtimeAdapter.test.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'node:events';
+import path from 'node:path';
 
 import { describe, expect, it } from 'vitest';
 
@@ -120,7 +121,10 @@ describe('CodexRuntimeAdapter', () => {
         { type: 'text', text: 'Inspect this ', text_elements: [] },
         {
           type: 'localImage',
-          path: '/tmp/workspace/.temp/threads/thread-1/photo.png',
+          path: path.join(
+            path.resolve('/tmp/workspace'),
+            '.temp/threads/thread-1/photo.png',
+          ),
         },
         { type: 'text', text: ' then summarize.', text_elements: [] },
       ],
@@ -141,7 +145,10 @@ describe('CodexRuntimeAdapter', () => {
       { type: 'text', text: 'Inspect ', text_elements: [] },
       {
         type: 'localImage',
-        path: '/tmp/workspace/.temp/threads/thread-1/photo.heic',
+        path: path.join(
+          path.resolve('/tmp/workspace'),
+          '.temp/threads/thread-1/photo.heic',
+        ),
       },
       { type: 'text', text: '.', text_elements: [] },
     ]);

package/packages/db/migrations/0030_thread_agent_id.sql

@@ -0,0 +1,9 @@
+ALTER TABLE threads ADD COLUMN agent_id TEXT;
+
+UPDATE threads
+SET agent_id = model,
+    model = NULL
+WHERE provider = 'acp'
+  AND agent_id IS NULL
+  AND model IS NOT NULL
+  AND provider_session_id LIKE model || '::%';

package/packages/db/src/repositories.ts

@@ -29,6 +29,7 @@ export interface CreateThreadRecordInput {
   workspaceId: string;
   title: string;
   provider?: string;
+  agentId?: string | null;
   providerSessionId: string | null;
   providerTurnId?: string | null;
   model?: string | null;
@@ -47,6 +48,7 @@ export interface CreateThreadRecordInput {
 
 export interface UpdateThreadRecordInput {
   provider?: string;
+  agentId?: string | null;
   providerSessionId?: string | null;
   providerTurnId?: string | null;
   title?: string;
@@ -278,6 +280,7 @@ export function createThreadRecord(db: DatabaseClient, input: CreateThreadRecord
     id: randomUUID(),
     workspaceId: input.workspaceId,
     provider: input.provider ?? 'codex',
+    agentId: input.agentId ?? null,
     providerSessionId: input.providerSessionId,
     providerTurnId: input.providerTurnId ?? null,
     source: input.source ?? 'supervisor',

package/packages/db/src/schema.ts

@@ -23,6 +23,7 @@ export const threads = sqliteTable('threads', {
   id: text('id').primaryKey(),
   workspaceId: text('workspace_id').notNull(),
   provider: text('provider').notNull().default('codex'),
+  agentId: text('agent_id'),
   providerSessionId: text('provider_session_id'),
   providerTurnId: text('provider_turn_id'),
   source: text('source').notNull().default('supervisor'),

package/packages/opencode/src/historyItems.ts

@@ -1,5 +1,7 @@
 import path from 'node:path';
 
+import { isPathInside } from '../../workspace/src/index';
+
 import type {
   AgentHistoryItem,
   AgentTurn,
@@ -163,15 +165,14 @@ function displayPath(pathValue: string | null, options: OpenCodeHistoryItemMappi
 
   const root = path.resolve(options.workspacePath);
   const absolutePath = path.resolve(pathValue);
+  if (!isPathInside(root, absolutePath)) {
+    return pathValue;
+  }
   const relativePath = path.relative(root, absolutePath);
-  if (
-    !relativePath ||
-    relativePath.startsWith('..') ||
-    path.isAbsolute(relativePath)
-  ) {
+  if (!relativePath) {
     return pathValue;
   }
-  return relativePath;
+  return relativePath.split(path.sep).join('/');
 }
 
 function toolIsLowInformationPatch(

package/packages/opencode/src/runtimeAdapter.ts

@@ -1,11 +1,9 @@
 import { EventEmitter } from 'node:events';
-import { execFile } from 'node:child_process';
 import fs from 'node:fs/promises';
 import net from 'node:net';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { promisify } from 'node:util';
 
 import type {
   AgentHistoryItem,
@@ -37,8 +35,8 @@ import {
   openCodeMessageToHistoryItems,
   openCodeMessagesToPlanUpdate,
 } from './historyItems';
+import { runProcess } from '../../process-runtime/src/index';
 
-const execFileAsync = promisify(execFile);
 const openCodeWaitTimeoutMs = 1_500;
 const openCodePromptPollIntervalMs = 500;
 const openCodePromptTimeoutMs = 120_000;
@@ -1476,12 +1474,10 @@ function resolveOptionalPackage(
 }
 
 async function npmGlobalRoot() {
-  try {
-    const { stdout } = await execFileAsync('npm', ['root', '-g'], {
-      timeout: 3_000,
-    });
-    return stdout.trim() || null;
-  } catch {
-    return null;
-  }
+  const result = await runProcess({
+    command: 'npm',
+    args: ['root', '-g'],
+    timeoutMs: 3_000,
+  });
+  return result.code === 0 ? result.stdout.trim() || null : null;
 }

package/packages/process-runtime/src/index.test.ts

@@ -0,0 +1,132 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { parseCommandLine, resolveExecutable, runProcess } from './index';
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryDirectories.splice(0).map((directory) =>
+      fs.rm(directory, { recursive: true, force: true }),
+    ),
+  );
+});
+
+describe('runProcess', () => {
+  const windowsIt = it.runIf(process.platform === 'win32');
+
+  it('preserves argv values without shell interpretation', async () => {
+    const argument = 'space & (parentheses) 中文';
+    const result = await runProcess({
+      command: process.execPath,
+      args: ['-e', 'process.stdout.write(process.argv[1])', argument],
+    });
+
+    expect(result.code).toBe(0);
+    expect(result.stdout).toBe(argument);
+    expect(result.spawnError).toBeNull();
+  });
+
+  it('returns stderr and a non-zero exit code', async () => {
+    const result = await runProcess({
+      command: process.execPath,
+      args: ['-e', "process.stderr.write('failure'); process.exit(7)"],
+    });
+
+    expect(result.code).toBe(7);
+    expect(result.stderr).toBe('failure');
+  });
+
+  it('reports a missing executable', async () => {
+    const result = await runProcess({
+      command: `remote-codex-missing-${Date.now()}`,
+    });
+
+    expect(result.code).toBeNull();
+    expect(result.spawnError).not.toBeNull();
+  });
+
+  it('terminates a timed out process', async () => {
+    const result = await runProcess({
+      command: process.execPath,
+      args: ['-e', 'setInterval(() => {}, 1000)'],
+      timeoutMs: 50,
+    });
+
+    expect(result.timedOut).toBe(true);
+  });
+
+  it('bounds captured output', async () => {
+    const result = await runProcess({
+      command: process.execPath,
+      args: ['-e', "process.stdout.write('x'.repeat(100))"],
+      maxOutputBytes: 10,
+    });
+
+    expect(result.stdout).toBe('x'.repeat(10));
+    expect(result.outputTruncated).toBe(true);
+  });
+
+  windowsIt('executes an npm-style command shim from a path with spaces', async () => {
+    const directory = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'remote-codex command shim '),
+    );
+    temporaryDirectories.push(directory);
+    const shimPath = path.join(directory, 'fake-codex.cmd');
+    await fs.writeFile(shimPath, '@echo off\r\necho %~1\r\n');
+
+    const result = await runProcess({
+      command: shimPath,
+      args: ['shim executed'],
+      timeoutMs: 3_000,
+    });
+
+    expect(result.code).toBe(0);
+    expect(result.stdout.trim()).toBe('shim executed');
+    expect(result.spawnError).toBeNull();
+  });
+});
+
+describe('parseCommandLine', () => {
+  it('parses built-in npm and quoted node commands without a shell', () => {
+    expect(parseCommandLine('npm install -g @openai/codex@latest')).toEqual({
+      command: 'npm',
+      args: ['install', '-g', '@openai/codex@latest'],
+    });
+    expect(parseCommandLine('node -e "process.exit(0)"')).toEqual({
+      command: 'node',
+      args: ['-e', 'process.exit(0)'],
+    });
+  });
+
+  it('does not interpret shell operators', () => {
+    expect(parseCommandLine('tool first && second')).toEqual({
+      command: 'tool',
+      args: ['first', '&&', 'second'],
+    });
+  });
+});
+
+describe('resolveExecutable', () => {
+  it('resolves an executable from PATH', async () => {
+    const resolved = await resolveExecutable(process.execPath);
+    expect(resolved).toBe(path.resolve(process.execPath));
+  });
+
+  it('uses Windows PATHEXT semantics for command shims', async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex process '));
+    temporaryDirectories.push(directory);
+    const shimPath = path.join(directory, 'codex.CMD');
+    await fs.writeFile(shimPath, '@echo off\r\n');
+
+    const resolved = await resolveExecutable('codex', {
+      env: { PATH: directory, PATHEXT: '.EXE;.CMD' },
+      platform: 'win32',
+    });
+
+    expect(resolved?.toLowerCase()).toBe(shimPath.toLowerCase());
+  });
+});