remote-codex 0.11.43 → 0.11.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.43",
+  "version": "0.11.45",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",
@@ -11,6 +11,8 @@
     "bin/",
     "scripts/service-manager.mjs",
     "scripts/run-web-service.mjs",
+    "scripts/verify-relay-supervisor-smoke.mjs",
+    "scripts/windows/",
     "apps/supervisor-api/dist/",
     "apps/relay-server/dist/",
     "apps/supervisor-web/dist/",
@@ -19,12 +21,14 @@
     "packages/claude/src/",
     "packages/codex/src/",
     "packages/opencode/src/",
+    "packages/process-runtime/src/",
     "packages/db/src/",
     "packages/db/migrations/*.sql",
     "packages/plugin-terminal/package.json",
     "packages/plugin-terminal/plugin.json",
     "packages/plugin-terminal/src/",
     "packages/shared/src/",
+    "docs/windows.md",
     "README.md"
   ],
   "packageManager": "pnpm@10.11.1",
@@ -51,8 +55,10 @@
     "build:package": "pnpm --filter @remote-codex/supervisor-api build && pnpm --filter @remote-codex/relay-server build && pnpm --filter @remote-codex/supervisor-web build",
     "lint": "pnpm -r --if-present lint",
     "typecheck": "pnpm -r --if-present typecheck",
-    "test": "NODE_ENV=test pnpm -r --if-present test",
+    "test": "cross-env NODE_ENV=test pnpm -r --if-present test",
     "test:e2e": "playwright test",
+    "verify:package": "node scripts/verify-package-install.mjs",
+    "verify:relay": "node scripts/verify-relay-supervisor-smoke.mjs",
     "db:migrate": "pnpm --filter @remote-codex/db db:migrate",
     "release:mobile": "node scripts/publish-mobile-release-assets.mjs",
     "impeccable": "impeccable",
@@ -65,14 +71,17 @@
     "@fastify/websocket": "^11.0.2",
     "@fontsource/noto-sans": "^5.2.10",
     "@fontsource/noto-sans-sc": "^5.2.9",
-    "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.10.0",
+    "cross-spawn": "^7.0.6",
     "fastify": "^5.2.1",
     "marked": "^18.0.3",
     "puppeteer-core": "^24.43.1",
     "zod": "^4.4.3"
   },
+  "optionalDependencies": {
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1"
+  },
   "devDependencies": {
     "@eslint/js": "^9.24.0",
     "@playwright/test": "^1.59.1",
@@ -80,11 +89,13 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@types/better-sqlite3": "^7.6.13",
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.14.0",
     "@types/react": "^19.1.2",
     "@types/react-dom": "^19.1.2",
     "@vitejs/plugin-react": "^4.3.4",
     "concurrently": "^9.1.2",
+    "cross-env": "^10.1.0",
     "eslint": "^9.24.0",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-refresh": "^0.4.19",

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

@@ -94,6 +94,22 @@ class FakeQuery implements Query {
         supportsEffort: true,
         supportedEffortLevels: ['low', 'medium', 'high'],
       },
+      {
+        value: 'claude-fable-5[1m]',
+        resolvedModel: 'claude-fable-5',
+        displayName: 'Fable',
+        description: 'Fable 5 test model',
+        supportsEffort: true,
+        supportedEffortLevels: ['low', 'medium', 'high', 'xhigh', 'max'],
+      },
+      {
+        value: 'opus[1m]',
+        resolvedModel: 'claude-opus-5[1m]',
+        displayName: 'Opus (1M context)',
+        description: 'Opus 5 test model',
+        supportsEffort: true,
+        supportedEffortLevels: ['low', 'medium', 'high', 'xhigh', 'max'],
+      },
     ];
   }
   async supportedAgents(): Promise<any[]> {
@@ -832,16 +848,28 @@ describe('ClaudeRuntimeAdapter', () => {
         }),
         expect.objectContaining({
           model: 'fable',
-          displayName: 'Claude Fable',
+          displayName: 'Fable · 5',
           defaultReasoningEffort: 'medium',
           supportedReasoningEfforts: expect.arrayContaining([
             expect.objectContaining({ reasoningEffort: 'max' }),
           ]),
         }),
+        expect.objectContaining({
+          model: 'opus',
+          displayName: 'Opus · 5',
+        }),
+        expect.objectContaining({
+          model: 'opus[1m]',
+          displayName: 'Opus · 5 (1M context)',
+        }),
+      ]),
+    );
+    await expect(adapter.listModels()).resolves.not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ model: 'claude-fable-5[1m]' }),
       ]),
     );
     expect(queries[0]?.closed).toBe(true);
-    await adapter.listModels();
     expect(queries).toHaveLength(1);
 
     await adapter.startSession({
@@ -1238,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,
@@ -2352,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;
@@ -760,9 +758,12 @@ function versionedAlias(
 }
 
 function withClaudeCodeModelAliases(models: AgentModel[]) {
-  const output = [...models];
-  const discoveredSonnet = output.find((model) => /^Sonnet · /.test(model.displayName));
-  const discoveredFable = output.find((model) => /^Fable · /.test(model.displayName));
+  const discoveredSonnet = models.find((model) => /^Sonnet · /.test(model.displayName));
+  const discoveredFable = models.find((model) => /^Fable · /.test(model.displayName));
+  const discoveredOpus = models.find((model) => /^Opus · /.test(model.displayName));
+  const output = models.filter(
+    (model) => model !== discoveredFable || discoveredFable.model === 'fable',
+  );
   const defaultSonnet = versionedAlias(DEFAULT_CLAUDE_MODELS[0]!, discoveredSonnet);
   const oneMillionSonnet = versionedAlias(
     DEFAULT_CLAUDE_MODELS[1]!,
@@ -770,6 +771,7 @@ function withClaudeCodeModelAliases(models: AgentModel[]) {
     ' (1M context)',
   );
   const fable = versionedAlias(DEFAULT_CLAUDE_MODELS[2]!, discoveredFable);
+  const opus = versionedAlias(DEFAULT_CLAUDE_MODELS[3]!, discoveredOpus);
   const hasSonnetAlias = output.some((model) => model.model === 'sonnet');
   if (!hasSonnetAlias) {
     output.unshift(defaultSonnet);
@@ -780,6 +782,10 @@ function withClaudeCodeModelAliases(models: AgentModel[]) {
   if (!output.some((model) => model.model === 'fable')) {
     output.splice(2, 0, fable);
   }
+  if (!output.some((model) => model.model === 'opus')) {
+    const discoveredOpusIndex = output.findIndex((model) => /^Opus · /.test(model.displayName));
+    output.splice(discoveredOpusIndex >= 0 ? discoveredOpusIndex : output.length, 0, opus);
+  }
   return output.map((model, index) => ({
     ...model,
     isDefault: index === 0,
@@ -2558,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;
     }
 
@@ -2825,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/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());
+  });
+});