@chatpanel/bridge 0.2.10 → 0.2.12

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "type": "module",
-  "description": "Local bridge that exposes the AI coding agents installed on your machine — Claude Code (Agent SDK), Codex (CLI), and Gemini CLI — to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
+  "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": [
     "chatpanel",
     "claude-code",
@@ -36,9 +36,7 @@
     "dev": "node --watch src/server.js",
     "build:bin": "bash scripts/build-binaries.sh"
   },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.1.0"
-  },
+  "dependencies": {},
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

package/src/engines/claude.js

@@ -1,184 +1,189 @@
-// Claude Code engine — embeds the Claude Agent SDK using your *local* Claude
-// Code login (or ANTHROPIC_API_KEY). It streams text deltas and surfaces tool
-// use so the extension can show what the agent is doing.
+// 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).
 //
-// 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 set to
-// 'acceptEdits' or 'bypassPermissions' in ChatPanel Settings. The working
-// directory comes from the agent config (defaults to the bridge's cwd).
+// 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.
 
-import path from 'node:path';
+import { spawn } from 'node:child_process';
 import os from 'node:os';
-import { existsSync } from 'node:fs';
-import { findAgentBin, isCompiledBinary } from '../env.js';
+import path from 'node:path';
+import { findAgentBin } from '../env.js';
 
-let sdkPromise = null;
-function loadSdk() {
-  if (!sdkPromise) sdkPromise = import('@anthropic-ai/claude-agent-sdk').catch(() => null);
-  return sdkPromise;
-}
-
-// Where the Claude Code CLI lives. The SDK ships a bundled cli.js, but inside a
-// compiled binary that file is on a virtual FS that child processes can't reach
-// (it fails on Windows as "B:\~BUN\cli.js"). So in a binary we point the SDK at
-// the user's INSTALLED Claude Code instead — preferring the real cli.js next to
-// the npm shim (modern Node won't spawn a .cmd directly).
-function claudeExecutable() {
-  if (process.env.CHATPANEL_CLAUDE_PATH) return process.env.CHATPANEL_CLAUDE_PATH;
-  if (!isCompiledBinary()) return undefined; // under node/bun the bundled cli.js works
-  const bin = findAgentBin('claude');
-  if (!bin) return undefined;
-  const dir = path.dirname(bin);
-  const candidates = [
-    path.join(dir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js'),
-    path.join(dir, '..', 'lib', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js'),
-  ];
-  for (const c of candidates) if (existsSync(c)) return c;
-  return bin;
-}
+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 lastProbe = 0;
 export async function available() {
-  const sdk = await loadSdk();
-  if (!sdk) {
-    return { ok: false, reason: 'Agent SDK not installed (npm i in bridge/)' };
-  }
-  // In a compiled binary the bundled CLI is unreachable, so Claude Code must be
-  // installed locally. (Under node/bun the bundled CLI works, so this is skipped.)
-  if (isCompiledBinary() && !process.env.CHATPANEL_CLAUDE_PATH && !findAgentBin('claude')) {
-    return {
-      ok: false,
-      reason: 'Claude Code not found. Install it (npm i -g @anthropic-ai/claude-code), or run the bridge with `npx @chatpanel/bridge`.',
-    };
+  // 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) {
+    lastProbe = Date.now();
+    try {
+      installed = !!findAgentBin('claude');
+    } catch {
+      installed = false;
+    }
   }
-  return { ok: true };
+  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.' };
 }
 
-const READONLY_TOOLS = new Set(['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'TodoWrite', 'Task']);
-
-// Build a single prompt that carries the conversation history. The bridge is
-// stateless, so we replay the chat each turn.
+// The bridge is stateless, so we replay the conversation as a single prompt.
 function buildPrompt(messages) {
   const history = messages.slice(0, -1);
   const last = messages[messages.length - 1];
   let prompt = '';
   if (history.length) {
     prompt += 'Conversation so far:\n';
-    for (const m of history) {
-      prompt += `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}\n\n`;
-    }
+    for (const m of history) prompt += `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}\n\n`;
     prompt += '---\n\n';
   }
   prompt += last ? last.content : '';
   return prompt;
 }
 
-export async function chat({ messages, system, options }, emit) {
-  const sdk = await loadSdk();
-  if (!sdk) throw new Error('Claude Agent SDK not installed. Run `npm install` in bridge/.');
-  const { query } = sdk;
+// 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.
+function runClaude({ prompt, args, cwd, emit }) {
+  const bin = findAgentBin('claude') || 'claude';
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(bin, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: process.env });
+    } catch (e) {
+      return reject(new Error(`Failed to start claude: ${e.message}`));
+    }
 
-  const permissionMode = options.permissionMode || 'default';
-  // No project configured → a neutral cwd, so the agent doesn't fixate on
-  // whatever directory the bridge happens to be running in.
-  const cwd = options.workingDir ? path.resolve(options.workingDir) : os.homedir();
-  const writesAllowed = permissionMode === 'acceptEdits' || permissionMode === 'bypassPermissions';
-
-  // Approve read-only tools always; gate writes/shell behind the chosen mode.
-  const canUseTool = async (toolName) => {
-    if (READONLY_TOOLS.has(toolName) || writesAllowed) return { behavior: 'allow', updatedInput: undefined };
-    return { behavior: 'deny', message: `${toolName} blocked — set this agent's permission mode to acceptEdits/bypassPermissions in ChatPanel to enable it.` };
-  };
-
-  let streamedAny = false;
-  let resultText = '';
-
-  const iterator = query({
-    prompt: buildPrompt(messages),
-    options: {
-      cwd,
-      permissionMode,
-      includePartialMessages: true,
-      canUseTool,
-      // Default: load your ~/.claude + project settings so your skills, MCP
-      // servers and CLAUDE.md apply. Turn the agent's "Use my local skills &
-      // config" off to run clean.
-      settingSources: options.useLocalConfig === false ? [] : ['user', 'project'],
-      // Native Claude Code system prompt. Only append the user's OWN system
-      // prompt if they set one — no ChatPanel persona is injected, so the agent
-      // is exactly as capable as it is in the terminal.
-      systemPrompt: system
-        ? { type: 'preset', preset: 'claude_code', append: system }
-        : { type: 'preset', preset: 'claude_code' },
-      ...(options.model ? { model: options.model } : {}),
-      ...(claudeExecutable() ? { pathToClaudeCodeExecutable: claudeExecutable() } : {}),
-      ...(process.env.CHATPANEL_MAX_TURNS ? { maxTurns: Number(process.env.CHATPANEL_MAX_TURNS) } : {}),
-    },
-  });
+    let stdout = '';
+    let stderr = '';
+    let streamedAny = false;
+    let resultText = '';
 
-  for await (const message of iterator) {
-    if (message.type === 'stream_event') {
-      const ev = message.event;
-      if (ev?.type === 'content_block_delta') {
-        if (ev.delta?.type === 'text_delta') {
-          streamedAny = true;
-          emit({ type: 'delta', text: ev.delta.text });
-        } else if (ev.delta?.type === 'thinking_delta') {
-          // Extended thinking — stream the reasoning text to the panel.
-          emit({ type: 'reasoning', text: ev.delta.thinking || '' });
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`Claude Code timed out after ${Math.round(TIMEOUT_MS / 1000)}s.`));
+    }, TIMEOUT_MS);
+
+    child.stdout.on('data', (d) => {
+      stdout += d.toString();
+      let nl;
+      while ((nl = stdout.indexOf('\n')) >= 0) {
+        const line = stdout.slice(0, nl).trim();
+        stdout = stdout.slice(nl + 1);
+        if (!line.startsWith('{')) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue; // not a JSON event line
         }
+        const r = handleMessage(msg, emit, streamedAny);
+        if (r.streamed) streamedAny = true;
+        if (r.result != null) resultText = r.result;
       }
-    } else if (message.type === 'assistant') {
-      for (const block of message.message.content) {
-        if (block.type === 'tool_use') {
-          emit({ type: 'tool', name: block.name, summary: toolSummary(block) });
-        } else if (block.type === 'text' && !streamedAny) {
-          // Partials were unavailable — stream the whole block.
-          streamedAny = true;
-          emit({ type: 'delta', text: block.text });
-        }
+    });
+    child.stderr.on('data', (d) => (stderr += d.toString()));
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve({ streamedAny, resultText });
+      else reject(new Error(`Claude Code exited ${code}: ${stderr.trim().split('\n').pop() || 'failed'}`));
+    });
+
+    child.stdin.write(prompt);
+    child.stdin.end();
+  });
+}
+
+// Map one stream-json message to emit() calls. Returns { streamed, result }.
+// The CLI's stream-json mirrors the SDK message shapes.
+function handleMessage(msg, emit, alreadyStreamed) {
+  const out = { streamed: false, result: null };
+  if (msg.type === 'stream_event') {
+    const ev = msg.event;
+    if (ev?.type === 'content_block_delta') {
+      if (ev.delta?.type === 'text_delta') {
+        out.streamed = true;
+        emit({ type: 'delta', text: ev.delta.text });
+      } else if (ev.delta?.type === 'thinking_delta') {
+        emit({ type: 'reasoning', text: ev.delta.thinking || '' });
       }
-    } else if (message.type === 'result') {
-      if (message.subtype === 'success') resultText = message.result || '';
-      else if (message.subtype !== 'success') {
-        emit({ type: 'status', text: `(${message.subtype})` });
+    }
+  } else if (msg.type === 'assistant') {
+    for (const block of msg.message?.content || []) {
+      if (block.type === 'tool_use') {
+        emit({ type: 'tool', name: block.name, summary: toolSummary(block) });
+      } else if (block.type === 'text' && !alreadyStreamed) {
+        out.streamed = true;
+        emit({ type: 'delta', text: block.text });
       }
     }
+  } else if (msg.type === 'result') {
+    if (msg.subtype === 'success') out.result = msg.result || '';
+    else emit({ type: 'status', text: `(${msg.subtype})` });
   }
+  return out;
+}
 
+export async function chat({ messages, system, options }, emit) {
+  const permissionMode = options.permissionMode || 'default';
+  const cwd = options.workingDir ? path.resolve(options.workingDir) : os.homedir();
+
+  const args = ['--print', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'];
+
+  // Gate writes/shell behind the chosen mode; otherwise restrict to read-only
+  // tools so headless runs never block on an approval prompt.
+  if (permissionMode === 'bypassPermissions') args.push('--permission-mode', 'bypassPermissions');
+  else if (permissionMode === 'acceptEdits') args.push('--permission-mode', 'acceptEdits');
+  else args.push('--allowedTools', ...READONLY_TOOLS);
+
+  // Native Claude Code behavior; append the user's own system prompt if they set
+  // one (no ChatPanel persona injected).
+  if (system) args.push('--append-system-prompt', system);
+  if (options.model) args.push('--model', options.model);
+  // Default loads your ~/.claude + project settings (skills, MCP, CLAUDE.md).
+  // "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 });
   emit({ type: 'done', text: streamedAny ? '' : resultText });
 }
 
 // A fast, tool-free single-shot completion — used for prompt autocomplete. No
-// claude_code preset, no tools, no local config: just a quick text continuation
-// from a fast model (Haiku by default). Returns the completion string.
+// tools, no local config: just a quick text continuation from a fast model.
 export async function complete({ prompt, system, model }) {
-  const sdk = await loadSdk();
-  if (!sdk) throw new Error('Claude Agent SDK not installed.');
-  const { query } = sdk;
+  const args = [
+    '--print',
+    '--output-format', 'stream-json',
+    '--verbose',
+    '--disallowedTools', 'Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'Bash', 'Edit', 'Write', 'Task', 'TodoWrite',
+    '--setting-sources', '',
+    '--model', model || 'haiku',
+    '--system-prompt', system || "Continue the user's text briefly. Reply with only the continuation.",
+  ];
   let text = '';
-  const iterator = query({
+  const { resultText } = await runClaude({
     prompt,
-    options: {
-      cwd: os.homedir(),
-      permissionMode: 'default',
-      allowedTools: [], // no tools — pure text completion
-      maxTurns: 1,
-      settingSources: [], // skip CLAUDE.md / MCP for a tiny completion
-      systemPrompt: system || "Continue the user's text briefly. Reply with only the continuation.",
-      model: model || 'haiku',
-      ...(claudeExecutable() ? { pathToClaudeCodeExecutable: claudeExecutable() } : {}),
+    args,
+    cwd: os.homedir(),
+    emit: (e) => {
+      if (e.type === 'delta') text += e.text;
     },
   });
-  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();
+  return (text || resultText || '').trim();
 }
 
 function toolSummary(block) {

package/src/server.js

@@ -22,7 +22,7 @@ import * as gemini from './engines/gemini.js';
 import { installService, uninstallService, serviceStatus } from './service.js';
 import { enrichPath, findAgentBin } from './env.js';
 
-const VERSION = '0.2.10';
+const VERSION = '0.2.12';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;