fix: spawn agents via resolved absolute path on Windows (#10)

Detection in `/api/agents` resolves each agent's full executable path,
but `/api/chat` was spawning the bare `def.bin` ("claude"). On Windows
the child process's PATH often doesn't include the user's npm-global
shim directory, so spawn() failed with ENOENT despite the picker
showing the agent as available.

Use the resolved path at spawn time, and pass `shell: true` when the
resolved bin is a `.cmd`/`.bat` shim so Node ≥21 doesn't refuse to
execute it (CVE-2024-27980).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

daemon/agents.js

@@ -7,7 +7,12 @@ import path from 'node:path';
 const execFileP = promisify(execFile);
 
 // Each entry defines how to invoke the agent in non-interactive "one-shot" mode.
-// `buildArgs(prompt, imagePaths)` returns argv for the child process.
+// `buildArgs(prompt, imagePaths, extraAllowedDirs)` returns argv for the child
+// process. `extraAllowedDirs` is a list of absolute directories the agent must
+// be permitted to read files from (skill seeds, design-system specs) that live
+// outside the project cwd. Currently only Claude Code wires this through
+// (`--add-dir`); other agents either inherit broader access or run with cwd
+// boundaries we can't widen via flags.
 // `streamFormat` hints to the daemon how to interpret stdout:
 //   - 'claude-stream-json' : line-delimited JSON emitted by Claude Code's
 //     `--output-format stream-json`. Daemon parses it into typed events
@@ -19,14 +24,23 @@ export const AGENT_DEFS = [
     name: 'Claude Code',
     bin: 'claude',
     versionArgs: ['--version'],
-    buildArgs: (prompt) => [
+    buildArgs: (prompt, _imagePaths, extraAllowedDirs = []) => {
-      '-p',
+      const args = [
-      prompt,
+        '-p',
-      '--output-format',
+        prompt,
-      'stream-json',
+        '--output-format',
-      '--verbose',
+        'stream-json',
-      '--include-partial-messages',
+        '--verbose',
-    ],
+        '--include-partial-messages',
+      ];
+      const dirs = (extraAllowedDirs || []).filter(
+        (d) => typeof d === 'string' && d.length > 0,
+      );
+      if (dirs.length > 0) {
+        args.push('--add-dir', ...dirs);
+      }
+      return args;
+    },
     streamFormat: 'claude-stream-json',
   },
   {
@@ -111,3 +125,13 @@ export async function detectAgents() {
 export function getAgentDef(id) {
   return AGENT_DEFS.find((a) => a.id === id) || null;
 }
+
+// Resolve the absolute path of an agent's binary on the current PATH.
+// Used by the chat handler so spawn() gets the same executable that
+// detection reported as available — fixes Windows ENOENT when the bare
+// bin name isn't on the child process's PATH (issue #10).
+export function resolveAgentBin(id) {
+  const def = getAgentDef(id);
+  if (!def?.bin) return null;
+  return resolveOnPath(def.bin);
+}

daemon/server.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
-import { detectAgents, getAgentDef } from './agents.js';
+import { detectAgents, getAgentDef, resolveAgentBin } from './agents.js';
 import { listSkills } from './skills.js';
 import { listDesignSystems, readDesignSystem } from './design-systems.js';
 import { createClaudeStreamHandler } from './claude-stream.js';
@@ -769,7 +769,17 @@ export async function startServer({ port = 7456 } = {}) {
       safeImages.length ? `\n\n${safeImages.map((p) => `@${p}`).join(' ')}` : '',
     ].join('');
 
-    const args = def.buildArgs(composed, safeImages);
+    // Skill seeds (`skills/<id>/assets/template.html`) and design-system
+    // specs (`design-systems/<id>/DESIGN.md`) live outside the project cwd.
+    // The composed system prompt asks the agent to Read them via absolute
+    // paths in the skill-root preamble — without an explicit allowlist,
+    // Claude Code blocks those reads (issue #6: "no permission to read
+    // skills template"). We surface both roots so any agent that honours
+    // `--add-dir` can resolve those side files.
+    const extraAllowedDirs = [SKILLS_DIR, DESIGN_SYSTEMS_DIR].filter(
+      (d) => fs.existsSync(d),
+    );
+    const args = def.buildArgs(composed, safeImages, extraAllowedDirs);
 
     res.setHeader('Content-Type', 'text/event-stream');
     res.setHeader('Cache-Control', 'no-cache, no-transform');
@@ -782,9 +792,20 @@ export async function startServer({ port = 7456 } = {}) {
       res.write(`data: ${JSON.stringify(data)}\n\n`);
     };
 
+    // Resolve the agent's bin to its absolute path. Detection (`/api/agents`)
+    // already locates the executable via PATH, but spawning the bare name here
+    // fails on Windows (ENOENT) when the child process's PATH doesn't contain
+    // the user's npm-global / shim directory — see issue #10.
+    const resolvedBin = resolveAgentBin(agentId) || def.bin;
+    // npm shims on Windows are .cmd/.bat files; Node ≥21 refuses to spawn
+    // those without `shell: true` (CVE-2024-27980). When `shell: true` is set
+    // on Windows, Node escapes args automatically for the cmd.exe shell.
+    const useShell =
+      process.platform === 'win32' && /\.(cmd|bat)$/i.test(resolvedBin);
+
     send('start', {
       agentId,
-      bin: def.bin,
+      bin: resolvedBin,
       streamFormat: def.streamFormat ?? 'plain',
       projectId: typeof projectId === 'string' ? projectId : null,
       cwd,
@@ -792,10 +813,11 @@ export async function startServer({ port = 7456 } = {}) {
 
     let child;
     try {
-      child = spawn(def.bin, args, {
+      child = spawn(resolvedBin, args, {
         env: { ...process.env },
         stdio: ['ignore', 'pipe', 'pipe'],
         cwd: cwd || undefined,
+        shell: useShell,
       });
     } catch (err) {
       send('error', { message: `spawn failed: ${err.message}` });

package.json

@@ -11,7 +11,7 @@
   "scripts": {
     "daemon": "node daemon/cli.js --no-open",
     "dev": "vite",
-    "dev:all": "concurrently -k -n daemon,web -c cyan,magenta \"npm:daemon\" \"npm:dev\"",
+    "dev:all": "node scripts/dev-all.mjs",
     "build": "tsc -b && vite build",
     "preview": "vite preview",
     "typecheck": "tsc -b --noEmit",

scripts/dev-all.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+// Launcher for `npm run dev:all`.
+//
+// Probes for free ports for the daemon (OD_PORT, default 7456) and the Vite
+// dev server (VITE_PORT, default 5173) before spawning `concurrently`, so a
+// stray process holding either port doesn't kill the whole boot. The
+// resolved ports are exported into the child env, which means:
+//   * the daemon's cli.js sees the new OD_PORT and binds to it
+//   * vite.config.ts reads the same OD_PORT and points its /api proxy at
+//     the daemon's actual port
+//   * Vite itself binds to VITE_PORT
+//
+// If a port is busy we walk forward up to PORT_SEARCH_RANGE steps and log
+// the switch so the user notices.
+
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+
+const HOST = '127.0.0.1';
+const PORT_SEARCH_RANGE = 50;
+
+function isPortFree(port, host = HOST) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+    server.once('error', () => resolve(false));
+    server.listen({ port, host, exclusive: true }, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+async function findFreePort(start, label) {
+  for (let port = start; port < start + PORT_SEARCH_RANGE; port++) {
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error(
+    `[dev:all] could not find a free ${label} port near ${start} (tried ${PORT_SEARCH_RANGE})`,
+  );
+}
+
+const desiredDaemon = Number(process.env.OD_PORT) || 7456;
+const desiredVite = Number(process.env.VITE_PORT) || 5173;
+
+const daemonPort = await findFreePort(desiredDaemon, 'daemon');
+const vitePort = await findFreePort(desiredVite, 'vite');
+
+if (daemonPort !== desiredDaemon) {
+  console.log(
+    `[dev:all] daemon port ${desiredDaemon} is busy, switching to ${daemonPort}`,
+  );
+}
+if (vitePort !== desiredVite) {
+  console.log(
+    `[dev:all] vite port ${desiredVite} is busy, switching to ${vitePort}`,
+  );
+}
+
+const env = {
+  ...process.env,
+  OD_PORT: String(daemonPort),
+  VITE_PORT: String(vitePort),
+};
+
+// We spawn the local `concurrently` bin via shell so Windows .cmd shims
+// resolve correctly. The `npm:daemon` / `npm:dev` shorthand runs the
+// matching package.json scripts, so any future tweak to those scripts is
+// picked up automatically.
+const child = spawn(
+  'concurrently',
+  ['-k', '-n', 'daemon,web', '-c', 'cyan,magenta', 'npm:daemon', 'npm:dev'],
+  { env, stdio: 'inherit', shell: true },
+);
+
+child.on('exit', (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 0);
+});
+
+for (const sig of ['SIGINT', 'SIGTERM']) {
+  process.on(sig, () => {
+    if (!child.killed) child.kill(sig);
+  });
+}

src/App.tsx

@@ -116,6 +116,7 @@ export function App() {
     const withOnboarding: AppConfig = { ...next, onboardingCompleted: true };
     saveConfig(withOnboarding);
     setConfig(withOnboarding);
+    setSettingsOpen(false);
   }, []);
 
   const handleModeChange = useCallback(

src/components/SettingsDialog.tsx

@@ -276,10 +276,7 @@ export function SettingsDialog({
             type="button"
             className="primary"
             disabled={!canSave}
-            onClick={() => {
+            onClick={() => onSave(cfg)}
-              onSave(cfg);
-              onClose();
-            }}
           >
             {welcome ? t('settings.getStarted') : t('common.save')}
           </button>

vite.config.ts

@@ -2,11 +2,12 @@ import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
 
 const DAEMON_PORT = Number(process.env.OD_PORT) || 7456;
+const VITE_PORT = Number(process.env.VITE_PORT) || 5173;
 
 export default defineConfig({
   plugins: [react()],
   server: {
-    port: 5173,
+    port: VITE_PORT,
     proxy: {
       '/api': {
         target: `http://127.0.0.1:${DAEMON_PORT}`,