@chatpanel/bridge 0.2.13 → 0.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "type": "module",
   "description": "Local bridge that exposes the AI coding agents installed on your machine — Claude Code (CLI), Codex (CLI), and Gemini CLI — to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
   "keywords": [
@@ -37,6 +37,9 @@
     "build:bin": "bash scripts/build-binaries.sh"
   },
   "dependencies": {},
+  "optionalDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.0"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

package/src/engines/claude.js

@@ -1,40 +1,54 @@
-// Claude Code engine — drives the Claude Code CLI (`claude --print`) directly,
-// the SAME way the Codex engine drives `codex exec`. No Agent SDK, no bundled
-// cli.js, no native `sharp` dependency — so it works in any environment that has
-// `claude` on PATH (npm install, native installer, or `npx`), and there's nothing
-// to resolve inside a compiled binary (the old "/$bunfs/root/cli.js" failure).
+// Claude Code engine — drives the Claude Code CLI (`claude --print`) the SAME
+// way the Codex engine drives `codex exec`, but with cross-platform launching so
+// it works no matter where `claude` lives:
 //
-// It uses your *local* Claude Code login. By default the agent can READ your code
-// (Read/Grep/Glob/WebFetch/…) but cannot write or run shell commands unless the
-// agent's permissionMode is 'acceptEdits' or 'bypassPermissions' in ChatPanel
-// Settings. The working directory comes from the agent config.
+//   • macOS / Linux / WSL-native Node — spawn the native `claude` on PATH.
+//   • Windows (native install) — run the package's cli.js with our own Node/Bun
+//     (npm's claude.cmd/.ps1 shims aren't directly spawnable → "spawn …ENOENT").
+//   • Windows host + claude only in WSL — cross the boundary via `wsl.exe`.
+//   • Last resort — the in-process Claude Agent SDK (bundled cli.js), if present.
+//
+// Resolution lives in env.js (resolveClaude); set CHATPANEL_CLAUDE_PATH to force
+// a specific executable. It uses your *local* Claude Code login. By default the
+// agent can READ your code but cannot write/run shell unless the agent's
+// permissionMode is 'acceptEdits'/'bypassPermissions' in ChatPanel Settings.
 
 import { spawn } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
-import { findAgentBin } from '../env.js';
+import { resolveClaude, toWslPath, isCompiledBinary } from '../env.js';
 
 const TIMEOUT_MS = Number(process.env.CHATPANEL_CLAUDE_TIMEOUT_MS) || 180_000;
 // Read-only tools allowed without approval in headless mode; writes/shell are
 // gated behind the agent's permission mode.
 const READONLY_TOOLS = ['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'TodoWrite', 'Task'];
 
-let installed = false;
+let lastReason = 'Claude Code not found.';
 let lastProbe = 0;
+let cachedOk = false;
 export async function available() {
-  // Availability = "is claude findable on PATH" (mirrors the codex engine), NOT
-  // "does `claude --version` exit 0" (which fails when it just needs login).
-  if (!installed && Date.now() - lastProbe > 4000) {
+  // Availability = "can we launch claude somehow" (native / cli.js / WSL / SDK),
+  // NOT "does `claude --version` exit 0" (which fails when it just needs login).
+  if (!cachedOk && Date.now() - lastProbe > 4000) {
     lastProbe = Date.now();
     try {
-      installed = !!findAgentBin('claude');
+      const spec = resolveClaude();
+      if (spec) {
+        cachedOk = true;
+      } else if (!isCompiledBinary() && (await loadSdk())) {
+        cachedOk = true;
+      } else {
+        cachedOk = false;
+        lastReason =
+          process.platform === 'win32'
+            ? 'Claude Code not found on Windows PATH or in WSL. Install it (npm i -g @anthropic-ai/claude-code) and run `claude` once to log in — in Windows or in your WSL distro.'
+            : 'Claude Code not found on PATH. Install it (npm i -g @anthropic-ai/claude-code) and run `claude` once to log in.';
+      }
     } catch {
-      installed = false;
+      cachedOk = false;
     }
   }
-  return installed
-    ? { ok: true }
-    : { ok: false, reason: 'Claude Code not found on PATH. Install it (npm i -g @anthropic-ai/claude-code) and run `claude` once to log in.' };
+  return cachedOk ? { ok: true } : { ok: false, reason: lastReason };
 }
 
 // The bridge is stateless, so we replay the conversation as a single prompt.
@@ -51,15 +65,51 @@ function buildPrompt(messages) {
   return prompt;
 }
 
-// Spawn `claude` and stream its stream-json output, forwarding events via `emit`.
-// `extraArgs` lets complete() run a tool-free single shot. Resolves with the final
-// result text once the process closes 0.
+// Turn a launch spec + the claude CLI args into a concrete [bin, argv, options]
+// for spawn(). `cwd` is the resolved working dir (Windows path on win32), or null
+// to use the home directory.
+function buildSpawn(spec, args, cwd) {
+  if (spec.kind === 'wsl') {
+    // Run claude inside WSL's login shell so nvm/etc. PATH resolves it. The
+    // `'exec claude "$@"'` + 'chatpanel' ($0) trick passes our args through as a
+    // proper argv array — no manual quoting, even for multi-line system prompts.
+    const pre = [];
+    if (cwd) {
+      const wslCwd = toWslPath(cwd);
+      if (wslCwd) pre.push('--cd', wslCwd); // else: run in WSL home
+    }
+    const argv = [...pre, '-e', 'bash', '-lic', 'exec claude "$@"', 'chatpanel', ...args];
+    return ['wsl.exe', argv, { stdio: ['pipe', 'pipe', 'pipe'], env: process.env, windowsHide: true }];
+  }
+
+  const spawnCwd = cwd || os.homedir();
+  const opts = { cwd: spawnCwd, stdio: ['pipe', 'pipe', 'pipe'], env: process.env, windowsHide: true };
+  if (spec.kind === 'script') {
+    // Run cli.js with the interpreter already running the bridge (node/bun).
+    return [process.execPath, [spec.script, ...args], opts];
+  }
+  if (spec.kind === 'cmd') {
+    // Launch the .cmd/.bat shim via cmd.exe with a real argv (shell:false). Node
+    // applies cmd.exe-aware quoting here, so args are passed safely — unlike
+    // spawn(..., { shell: true }), which concatenates (DEP0190).
+    return ['cmd.exe', ['/d', '/s', '/c', spec.bin, ...args], opts];
+  }
+  // kind === 'native' — a directly executable file (mac/linux binary or .exe).
+  return [spec.bin, args, opts];
+}
+
+// Spawn claude (however it resolves) and stream its stream-json output via
+// `emit`. Resolves with { streamedAny, resultText } once it closes 0. Returns
+// null (no spawn) when claude can't be resolved, so the caller can fall back.
 function runClaude({ prompt, args, cwd, emit }) {
-  const bin = findAgentBin('claude') || 'claude';
+  const spec = resolveClaude();
+  if (!spec) return null;
+  const [bin, argv, opts] = buildSpawn(spec, args, cwd);
+
   return new Promise((resolve, reject) => {
     let child;
     try {
-      child = spawn(bin, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: process.env });
+      child = spawn(bin, argv, opts);
     } catch (e) {
       return reject(new Error(`Failed to start claude: ${e.message}`));
     }
@@ -95,7 +145,7 @@ function runClaude({ prompt, args, cwd, emit }) {
     child.stderr.on('data', (d) => (stderr += d.toString()));
     child.on('error', (e) => {
       clearTimeout(timer);
-      reject(e);
+      reject(new Error(`Failed to start claude (${bin}): ${e.message}`));
     });
     child.on('close', (code) => {
       clearTimeout(timer);
@@ -140,7 +190,8 @@ function handleMessage(msg, emit, alreadyStreamed) {
 
 export async function chat({ messages, system, options }, emit) {
   const permissionMode = options.permissionMode || 'default';
-  const cwd = options.workingDir ? path.resolve(options.workingDir) : os.homedir();
+  // Explicit project dir, else null → CLI runs in home (or WSL home).
+  const cwd = options.workingDir ? path.resolve(options.workingDir) : null;
 
   const args = ['--print', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'];
 
@@ -158,7 +209,9 @@ export async function chat({ messages, system, options }, emit) {
   // "Use my local skills & config" off → run clean.
   if (options.useLocalConfig === false) args.push('--setting-sources', '');
 
-  const { streamedAny, resultText } = await runClaude({ prompt: buildPrompt(messages), args, cwd, emit });
+  const run = runClaude({ prompt: buildPrompt(messages), args, cwd, emit });
+  if (run === null) return sdkChat({ messages, system, options }, emit); // no CLI → SDK
+  const { streamedAny, resultText } = await run;
   emit({ type: 'done', text: streamedAny ? '' : resultText });
 }
 
@@ -175,14 +228,16 @@ export async function complete({ prompt, system, model }) {
     '--system-prompt', system || "Continue the user's text briefly. Reply with only the continuation.",
   ];
   let text = '';
-  const { resultText } = await runClaude({
+  const run = runClaude({
     prompt,
     args,
-    cwd: os.homedir(),
+    cwd: null,
     emit: (e) => {
       if (e.type === 'delta') text += e.text;
     },
   });
+  if (run === null) return sdkComplete({ prompt, system, model }); // no CLI → SDK
+  const { resultText } = await run;
   return (text || resultText || '').trim();
 }
 
@@ -194,3 +249,82 @@ function toolSummary(block) {
   if (i.url) return i.url;
   return '';
 }
+
+// ---------------------------------------------------------------------------
+// Fallback: in-process Claude Agent SDK. Only reached when no native/WSL claude
+// CLI is resolvable (and we're not a compiled binary, where its bundled cli.js
+// is unreachable). The SDK ships its own cli.js and uses your ~/.claude login.
+
+let sdkPromise = null;
+function loadSdk() {
+  // Optional dependency — absent in lean/compiled installs; import().catch makes
+  // that a graceful "no fallback available" rather than a crash.
+  if (!sdkPromise) sdkPromise = import('@anthropic-ai/claude-agent-sdk').catch(() => null);
+  return sdkPromise;
+}
+
+async function sdkChat({ messages, system, options }, emit) {
+  const sdk = await loadSdk();
+  if (!sdk) throw new Error(lastReason);
+  const { query } = sdk;
+
+  const permissionMode = options.permissionMode || 'default';
+  const cwd = options.workingDir ? path.resolve(options.workingDir) : os.homedir();
+  const writesAllowed = permissionMode === 'acceptEdits' || permissionMode === 'bypassPermissions';
+  const readonly = new Set(READONLY_TOOLS);
+  const canUseTool = async (toolName) =>
+    readonly.has(toolName) || writesAllowed
+      ? { behavior: 'allow', updatedInput: undefined }
+      : { behavior: 'deny', message: `${toolName} blocked — set this agent's permission mode in ChatPanel to enable it.` };
+
+  let streamedAny = false;
+  let resultText = '';
+  const iterator = query({
+    prompt: buildPrompt(messages),
+    options: {
+      cwd,
+      permissionMode,
+      includePartialMessages: true,
+      canUseTool,
+      settingSources: options.useLocalConfig === false ? [] : ['user', 'project'],
+      systemPrompt: system
+        ? { type: 'preset', preset: 'claude_code', append: system }
+        : { type: 'preset', preset: 'claude_code' },
+      ...(options.model ? { model: options.model } : {}),
+      ...(process.env.CHATPANEL_MAX_TURNS ? { maxTurns: Number(process.env.CHATPANEL_MAX_TURNS) } : {}),
+    },
+  });
+  for await (const message of iterator) {
+    const r = handleMessage(message, emit, streamedAny);
+    if (r.streamed) streamedAny = true;
+    if (r.result != null) resultText = r.result;
+  }
+  emit({ type: 'done', text: streamedAny ? '' : resultText });
+}
+
+async function sdkComplete({ prompt, system, model }) {
+  const sdk = await loadSdk();
+  if (!sdk) throw new Error(lastReason);
+  const { query } = sdk;
+  let text = '';
+  const iterator = query({
+    prompt,
+    options: {
+      cwd: os.homedir(),
+      permissionMode: 'default',
+      allowedTools: [],
+      maxTurns: 1,
+      settingSources: [],
+      systemPrompt: system || "Continue the user's text briefly. Reply with only the continuation.",
+      model: model || 'haiku',
+    },
+  });
+  for await (const message of iterator) {
+    if (message.type === 'assistant') {
+      for (const block of message.message.content) if (block.type === 'text') text += block.text;
+    } else if (message.type === 'result' && message.subtype === 'success' && !text) {
+      text = message.result || '';
+    }
+  }
+  return text.trim();
+}

package/src/env.js

@@ -8,12 +8,13 @@
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { readdirSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
 
 let enriched = false;
 
-// The agent CLIs the bridge shells out to (Claude is the in-process SDK).
-const AGENT_CLIS = ['codex', 'gemini'];
+// The agent CLIs the bridge shells out to. Claude has its own richer resolution
+// (resolveClaude: native / cli.js / WSL / SDK) below.
+const AGENT_CLIS = ['codex', 'gemini', 'claude'];
 
 // Is `name` executable somewhere on the current PATH?
 function onPath(name) {
@@ -64,6 +65,153 @@ function shellWhich(name) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Claude Code launcher resolution.
+//
+// The Codex/Gemini engines can assume `spawn('codex', …)` runs a directly
+// executable file on the current OS's PATH. Claude needs more care:
+//   • On Windows, npm installs `claude.cmd` / `claude.ps1` / an extensionless
+//     bash shim — NONE of which Node's spawn() can execute directly (that's the
+//     "spawn C:\… ENOENT"). The runnable thing is the package's `cli.js`, which
+//     we run with our own Node/Bun.
+//   • A very common setup is "Windows host, `claude` only installed inside WSL."
+//     A Windows process can't see WSL's filesystem or PATH, so we cross the
+//     boundary explicitly via `wsl.exe`.
+// On macOS/Linux (and WSL-native Node) none of this applies: we return the same
+// native binary the old code spawned, so behavior there is unchanged.
+//
+// Returns one of:
+//   { kind: 'native', bin }          → spawn(bin, args)          (directly exec'able)
+//   { kind: 'script', script }       → spawn(process.execPath, [script, ...args])
+//   { kind: 'cmd', bin }             → spawn('cmd.exe', ['/c', bin, ...args])
+//   { kind: 'wsl' }                  → spawn('wsl.exe', [wsl prefix, ...args])
+//   null                             → not found (caller may fall back to SDK)
+//
+// We never use spawn's `shell: true` — with an args array it concatenates rather
+// than escapes (Node DEP0190 / a real injection surface). The 'script' and 'cmd'
+// kinds run the shim safely with a proper argv instead.
+export function resolveClaude() {
+  const override = process.env.CHATPANEL_CLAUDE_PATH;
+  if (override) {
+    const ext = path.extname(override).toLowerCase();
+    if (!isCompiledBinary() && /^\.(c?js|mjs)$/.test(ext)) return { kind: 'script', script: override };
+    if (process.platform === 'win32' && (ext === '.cmd' || ext === '.bat')) return { kind: 'cmd', bin: override };
+    return { kind: 'native', bin: override };
+  }
+
+  if (process.platform === 'win32') {
+    const win = findClaudeWindows();
+    if (win) return win;
+    if (claudeInWsl()) return { kind: 'wsl' };
+    return null;
+  }
+
+  // macOS / Linux / WSL-native: same resolution the engine used before.
+  const bin = findAgentBin('claude');
+  return bin ? { kind: 'native', bin } : null;
+}
+
+// Locate a runnable Claude Code on Windows. Prefer the package's cli.js (run
+// with our own Node/Bun — clean arg passing, no cmd.exe quoting), then a real
+// .exe, then a .cmd/.bat shim launched safely via cmd.exe.
+function findClaudeWindows() {
+  const dirs = (process.env.PATH || '').split(path.delimiter);
+  for (const d of dirs) {
+    if (!d) continue;
+    const hasShim = ['claude', 'claude.cmd', 'claude.exe', 'claude.ps1', 'claude.bat'].some((n) =>
+      existsSync(path.join(d, n)),
+    );
+    if (!hasShim) continue;
+    // Running cli.js with our own interpreter only works under a real Node/Bun,
+    // not inside a compiled single-file binary (which is not a JS interpreter).
+    if (!isCompiledBinary()) {
+      const js = claudeCliJs(d) || shimTarget(d);
+      if (js) return { kind: 'script', script: js };
+    }
+    if (existsSync(path.join(d, 'claude.exe'))) return { kind: 'native', bin: path.join(d, 'claude.exe') };
+    if (existsSync(path.join(d, 'claude.cmd'))) return { kind: 'cmd', bin: path.join(d, 'claude.cmd') };
+    if (existsSync(path.join(d, 'claude.bat'))) return { kind: 'cmd', bin: path.join(d, 'claude.bat') };
+  }
+  return null;
+}
+
+// The npm shim usually sits next to (or one level up from) the claude-code
+// package — quick static guesses before parsing the shim itself.
+function claudeCliJs(dir) {
+  const rels = [
+    ['node_modules', '@anthropic-ai', 'claude-code', 'cli.js'],
+    ['..', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js'],
+    ['..', 'lib', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js'],
+  ];
+  for (const r of rels) {
+    const c = path.join(dir, ...r);
+    if (existsSync(c)) return c;
+  }
+  return null;
+}
+
+// Robust fallback: every npm/pnpm/yarn/volta shim literally names the JS entry it
+// runs, relative to the shim dir (`%dp0%\…\cli.js` in .cmd, `$basedir/…/cli.js`
+// in the sh/.ps1 shims). Extract that so any install layout resolves to a real
+// cli.js we can run with our own interpreter.
+function shimTarget(dir) {
+  for (const shim of ['claude.cmd', 'claude', 'claude.ps1']) {
+    let txt;
+    try {
+      txt = readFileSync(path.join(dir, shim), 'utf8');
+    } catch {
+      continue;
+    }
+    const m = txt.match(/(?:%~?dp0%|\$basedir|\$\{basedir\})[\\/]+([^"'\s]+\.[cm]?js)/i);
+    if (m) {
+      const abs = path.join(dir, m[1].replace(/[\\/]+/g, path.sep));
+      if (existsSync(abs)) return abs;
+    }
+  }
+  return null;
+}
+
+// Is `claude` reachable inside the default WSL distro's login shell? Cached;
+// re-probed (throttled) while not found so it self-heals once WSL/claude appear.
+let wslClaude = null;
+let wslProbe = 0;
+function claudeInWsl() {
+  if (wslClaude === null || (!wslClaude && Date.now() - wslProbe > 4000)) {
+    wslProbe = Date.now();
+    try {
+      const r = spawnSync('wsl.exe', ['-e', 'bash', '-lic', 'command -v claude'], {
+        encoding: 'utf8',
+        timeout: 8000,
+        windowsHide: true,
+      });
+      wslClaude = r.status === 0 && /\S/.test(stripBom(r.stdout || ''));
+    } catch {
+      wslClaude = false;
+    }
+  }
+  return wslClaude;
+}
+
+// Translate a Windows path to its WSL (/mnt/c/…) equivalent. Returns null on
+// failure so the caller can just run in WSL's home instead.
+export function toWslPath(winPath) {
+  try {
+    const r = spawnSync('wsl.exe', ['-e', 'wslpath', '-a', winPath], {
+      encoding: 'utf8',
+      timeout: 5000,
+      windowsHide: true,
+    });
+    const out = stripBom(r.stdout || '').trim();
+    return out.startsWith('/') ? out : null;
+  } catch {
+    return null;
+  }
+}
+
+function stripBom(s) {
+  return s.replace(/^/, '').trim();
+}
+
 // Version managers install CLIs under versioned bin dirs that a lazy-loaded
 // shell (nvm/fnm) doesn't export into a non-interactive service PATH. Add them.
 function versionManagerBins(home) {