fix(windows): resolve .cmd shim path for Node spawn

[ElRaxy]

PR #1 — fix(windows): resolve .cmd shim path for Node spawn

Branch suggested: fix/windows-cmd-shim-spawn
File: src/daemon/headless.ts
Severity: Critical — every CLI reviewer/doer fails on Windows
Affects: Windows + Node 18.20+ / 20.x / 22+ / 24+

---

Summary

spawnHeadless invokes CLI shims by their bare name ('claude', 'codex', 'gemini'). On Windows these are .cmd files in the npm global prefix (claude.cmd, codex.cmd, gemini.cmd). Node's child_process.spawn cannot resolve those without shell: true — and Node 18.20+ added CVE-2024-27980 mitigations that block spawn of .cmd/.bat outright (returning EINVAL). The result: the daemon emits [cli_not_in_path] ENOENT spawn claude for every CLI on Windows, even though the binaries are present and discoverable via where claude.

Reproduction

Fresh Windows 10/11 + Node 24, with all three official CLIs installed globally:

npm i -g @anthropic-ai/claude-code @openai/codex @google/gemini-cli
where claude   # C:\Users\...\npm\claude
               # C:\Users\...\npm\claude.cmd  ← actual binary

chorus init
chorus start
# Submit any chat → daemon log:
# [cli_not_in_path] claude not found on the daemon's PATH
# (ENOENT: spawn claude ENOENT)

The daemon's PATH includes C:\Users\...\npm\ (verified by inspecting getSpawnPath() output), but child_process.spawn('claude', ...) resolves the bash shim sibling (no extension, not executable by Node) before the .cmd and crashes.

On Node 24 specifically, the same code path produces:

Error: spawn EINVAL
  at ChildProcess.spawn (node:internal/child_process:421:11)

That's the CVE-2024-27980 hard-block on .cmd files outside of shell:true.

Root cause

Two stacked Windows-specific quirks:

1. where claude returns multiple paths, in PATHEXT-resolution order. npm globals on Windows ship a Bash shim (claude — POSIX shell, no extension) alongside the Windows shim (claude.cmd). Node spawn picks the first one.
2. Node's spawn refuses .cmd files without shell: true. The legacy work-around (always shell:true on Windows) trips DEP0190 in newer Node versions and has shell-escaping caveats; the modern work-around requires the explicit .cmd/.bat/.exe extension on the executable path.

The shim files themselves don't know about this; every runHeadless implementation just calls spawnHeadless({ command: 'claude' | 'codex' | 'gemini' | ... }) and assumes spawn will resolve PATH.

Fix

Resolve the binary's full path with extension via where on Windows before calling spawn. Cache per command name (one shell-out per daemon boot per CLI). Set shell: true only on Windows. Args are static CLI flags (not user-controlled) so the DEP0190 risk class doesn't apply.

On Unix this is a no-op — process.platform !== 'win32' short-circuits both helpers.

Diff

diff --git a/src/daemon/headless.ts b/src/daemon/headless.ts
index c0c36f0..2a1ea39 100644
--- a/src/daemon/headless.ts
+++ b/src/daemon/headless.ts
@@ -20,6 +20,7 @@
 
 import {
   spawn as spawnChild,
+  spawnSync,
   type ChildProcessWithoutNullStreams,
 } from 'child_process';
 import * as fs from 'fs';
@@ -28,6 +29,36 @@ import * as path from 'path';
 import type { AgentEvent } from './agents/types.js';
 import { cliPaths } from '../lib/cli-paths.js';
 
+// Cache binary→path resolutions. `where` shells out — don't repeat per spawn.
+const binaryPathCache = new Map<string, string>();
+
+/**
+ * Resolve a binary name to a full path with extension. Critical on Windows
+ * where Node's spawn won't resolve `.cmd` shims (npm globals like
+ * claude.cmd, codex.cmd, gemini.cmd) without shell:true (DEP0190 in
+ * Node 22+). On Unix returns the name unchanged — spawn handles PATH
+ * resolution natively for ELF/script files with shebangs.
+ */
+function resolveBinaryPath(command: string): string {
+  if (process.platform !== 'win32') return command;
+  if (path.isAbsolute(command)) return command;
+  const cached = binaryPathCache.get(command);
+  if (cached) return cached;
+  const r = spawnSync('where', [command], { encoding: 'utf-8', timeout: 3000 });
+  if (r.status !== 0 || !r.stdout) {
+    binaryPathCache.set(command, command);
+    return command; // fallback — daemon will surface ENOENT cleanly.
+  }
+  // npm globals on Windows ship two siblings: `claude` (Bash shim, not
+  // executable by Node spawn) and `claude.cmd` (Windows shim). `where`
+  // returns both; we must pick the .cmd/.bat/.exe variant for Node.
+  const lines = r.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  const preferred = lines.find((l) => /\.(cmd|bat|exe)$/i.test(l));
+  const resolved = preferred ?? lines[0] ?? command;
+  binaryPathCache.set(command, resolved);
+  return resolved;
+}
+
@@ -253,10 +284,23 @@ export function spawnHeadless(opts: SpawnHeadlessOptions): HeadlessRun {
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const startedAt = Date.now();
 
-  const child: ChildProcessWithoutNullStreams = spawnChild(opts.command, [...opts.args], {
+  // Windows CLIs ship as .cmd shims (npm globals: claude.cmd, codex.cmd,
+  // gemini.cmd). Node 18.20+/20.x/22+ added CVE-2024-27980 mitigations that
+  // *block* spawn of .cmd/.bat without shell:true (EINVAL). We:
+  //   1. Resolve to the full .cmd path via `where` (cached) so PATH lookups
+  //      always pick the .cmd shim, never the Bash sibling.
+  //   2. Set shell:true ONLY on Windows. DEP0190 fires informationally; our
+  //      args are fixed CLI flags (not user-controlled) so the shell-escaping
+  //      class of risks doesn't apply here.
+  // On Unix this is a no-op: spawn handles ELF/shebang scripts natively.
+  const isWindows = process.platform === 'win32';
+  const resolvedCommand = resolveBinaryPath(opts.command);
+
+  const child: ChildProcessWithoutNullStreams = spawnChild(resolvedCommand, [...opts.args], {
     cwd: opts.cwd,
     env: spawnEnv(opts.env),
     stdio: ['pipe', 'pipe', 'pipe'],
+    shell: isWindows,
   });

Testing

Manual repro on Windows 10 + Node 24.11 + npm globals @anthropic-ai/claude-code 2.1.138, @openai/codex 0.130.0, @google/gemini-cli 0.41.2:

Before:

[cli_not_in_path] claude not found on the daemon's PATH
(ENOENT: spawn claude ENOENT)

After:

• Doer spawns successfully, writes ~/.chorus/chats/<id>/round-1/doer-claude-code/answer.md.
• Reviewer spawns successfully (codex tested), writes answer.md with verdict text.
• Verdict computed correctly (approved / request_changes).

Linux/Mac unaffected (verified: process.platform !== 'win32' returns the command unchanged, no shell:true).

Considerations for the maintainer

• shell:true triggers DEP0190 informational warning on Node 22+. Since args here are static CLI flags (--print, --output-format stream-json, etc.) the shell-escaping risk doesn't apply. If the project wants to silence the warning, an alternative is wrapping with cmd.exe /c <bin> <args> — but that introduces a level of indirection and is harder to debug.
• where may not be on PATH in some minimal Windows containers; consider falling back to process.env.PATHEXT-based search if where returns non-zero.
• Tests: a Vitest suite that mocks spawnSync and spawnChild could verify the resolution logic + Windows-only branching. We didn't add it in the fork to keep the diff minimal — happy to do that as a follow-up.