@chatpanel/bridge 0.10.0 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "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": [
@@ -34,6 +34,7 @@
   "scripts": {
     "start": "node src/server.js",
     "dev": "node --watch src/server.js",
+    "test": "node --test tests/*.test.mjs",
     "build:bin": "bash scripts/build-binaries.sh"
   },
   "dependencies": {},

package/src/engines/claude.js

@@ -17,7 +17,7 @@ import { spawn } from 'node:child_process';
 import { writeFile, unlink } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { resolveClaude, buildSpawnSpec, isCompiledBinary } from '../env.js';
+import { resolveClaude, buildSpawnSpec, isCompiledBinary, selfMcpStdio } from '../env.js';
 
 // Write base64 data-URL images to temp files. Claude Code reads them with its
 // Read tool (which feeds images to the model as vision), so we just reference the
@@ -93,6 +93,18 @@ function buildPrompt(messages) {
   return prompt;
 }
 
+export function claudeMcpConfig(mcp) {
+  if (!mcp?.url || !Array.isArray(mcp.specs) || !mcp.specs.length) return null;
+  const serverName = mcp.serverName || 'chatpanel_browser';
+  const { command, args } = selfMcpStdio(mcp.url);
+  const toolNames = [...new Set(mcp.specs.map((s) => s?.name).filter(Boolean))];
+  return {
+    serverName,
+    config: { mcpServers: { [serverName]: { command, args } } },
+    allowedTools: toolNames.map((name) => `mcp__${serverName}__${name}`),
+  };
+}
+
 // 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.
@@ -198,19 +210,20 @@ export async function chat({ messages, system, options, images }, emit) {
   const tag = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
   const args = ['--print', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'];
 
-  // Browser-tools relay: ChatPanel hands this CLI the page-action tools over an
-  // HTTP MCP server the bridge hosts (which relays each call to the extension).
+  // Browser-tools relay: ChatPanel hands this CLI the page-action tools through
+  // the bridge's stdio MCP proxy, which forwards each call to the per-chat HTTP
+  // MCP session and then to the extension.
   // options.mcp = { url, serverName, specs }. We pre-allow the tools so a headless
   // run doesn't block on approval, and merge alongside the user's own MCP servers.
   const mcpFiles = [];
   const mcpAllow = [];
-  if (options.mcp?.url && Array.isArray(options.mcp.specs) && options.mcp.specs.length) {
-    const serverName = options.mcp.serverName || 'chatpanel_browser';
+  const mcpConfig = claudeMcpConfig(options.mcp);
+  if (mcpConfig) {
     const cfgFile = path.join(os.tmpdir(), `chatpanel-mcp-${tag}.json`);
-    await writeFile(cfgFile, JSON.stringify({ mcpServers: { [serverName]: { type: 'http', url: options.mcp.url } } }));
+    await writeFile(cfgFile, JSON.stringify(mcpConfig.config));
     mcpFiles.push(cfgFile);
     args.push('--mcp-config', cfgFile);
-    for (const s of options.mcp.specs) mcpAllow.push(`mcp__${serverName}__${s.name}`);
+    mcpAllow.push(...mcpConfig.allowedTools);
   }
 
   // Gate writes/shell behind the chosen mode; otherwise restrict to read-only

package/src/engines/cli-agents.js

@@ -45,6 +45,7 @@ export const pi = makeCliAgent(
     promptVia: 'arg',
     modelArg: '--model {model}',
     imageArg: '@{path}',
+    toolAdapter: 'pi-extension',
     listModelsArgs: '--list-models',
     label: 'Pi',
   },
@@ -65,6 +66,7 @@ export const opencode = makeCliAgent(
     // Browser tools come via the bridge's STABLE /mcp endpoint, registered once
     // with `opencode mcp add chatpanel --url http://127.0.0.1:4319/mcp` (opencode
     // only loads MCP from its global config, not a per-run file).
+    requiresStableMcp: true,
     listModelsArgs: 'models',
     label: 'OpenCode',
   },

package/src/engines/codex.js

@@ -110,6 +110,29 @@ function buildPrompt(messages, system) {
   return p;
 }
 
+export function codexMcpConfigArgs(mcp) {
+  if (!mcp?.url) return [];
+  const name = mcp.serverName || 'chatpanel_browser';
+  const { command, args: pargs } = selfMcpStdio(mcp.url);
+  const args = [
+    '-c',
+    `mcp_servers.${name}.command=${JSON.stringify(command)}`,
+    '-c',
+    `mcp_servers.${name}.args=${JSON.stringify(pargs)}`,
+    '-c',
+    `mcp_servers.${name}.default_tools_approval_mode="approve"`,
+    '-c',
+    `mcp_servers.${name}.startup_timeout_sec=30`,
+    '-c',
+    `mcp_servers.${name}.tool_timeout_sec=120`,
+  ];
+  const toolNames = [...new Set((mcp.specs || []).map((s) => s?.name).filter(Boolean))];
+  if (toolNames.length) {
+    args.push('-c', `mcp_servers.${name}.enabled_tools=${JSON.stringify(toolNames)}`);
+  }
+  return args;
+}
+
 // Write base64 data-URL images to temp files so `codex exec -i <file>` can
 // attach them to the prompt as vision input. Returns the paths (caller cleans up).
 async function writeImages(images, tag) {
@@ -149,12 +172,7 @@ export async function chat({ messages, system, options, images }, emit) {
   // Browser tools: register the bridge's MCP server as a stdio MCP server (the
   // bridge binary in --mcp-stdio mode), so Codex can call our page-action tools.
   // `-c key=value` parses value as TOML; JSON.stringify yields valid TOML here.
-  if (options.mcp?.url) {
-    const name = options.mcp.serverName || 'chatpanel_browser';
-    const { command, args: pargs } = selfMcpStdio(options.mcp.url);
-    args.push('-c', `mcp_servers.${name}.command=${JSON.stringify(command)}`);
-    args.push('-c', `mcp_servers.${name}.args=${JSON.stringify(pargs)}`);
-  }
+  args.push(...codexMcpConfigArgs(options.mcp));
   if (options.model) args.push('-m', options.model);
   if (options.extraArgs) args.push(...String(options.extraArgs).split(/\s+/).filter(Boolean));
   for (const f of imageFiles) args.push('-i', f); // attach images to the initial prompt

package/src/engines/custom.js

@@ -16,7 +16,7 @@
 //                      speak it), reusing the Claude engine's parser.
 
 import { spawn } from 'node:child_process';
-import { writeFile, unlink } from 'node:fs/promises';
+import { readFile, writeFile, unlink } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { resolveCommand, buildSpawnSpec, selfMcpStdio } from '../env.js';
@@ -64,6 +64,7 @@ const IDLE_MS = Number(process.env.CHATPANEL_CUSTOM_TIMEOUT_MS) || 180_000;
 // also set NO_COLOR on the child env, but this is the robust backstop.)
 const ANSI_RE = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
 const stripAnsi = (s) => s.replace(ANSI_RE, '');
+const OPENCODE_STABLE_MCP_URL = 'http://127.0.0.1:4319/mcp';
 
 export async function available() {
   // The engine ships in every bridge; individual custom agents are user-defined
@@ -138,6 +139,120 @@ function buildPrompt(messages, system) {
   return p;
 }
 
+function mcpToolSpecs(mcp) {
+  return (mcp?.specs || []).filter((s) => s?.name);
+}
+
+function jsIdentifier(name, index) {
+  const id = String(name).replace(/[^A-Za-z0-9_$]/g, '_');
+  return /^[A-Za-z_$]/.test(id) ? id : `tool_${index}_${id}`;
+}
+
+export function piToolArgs(extensionFile, mcp) {
+  return ['--extension', extensionFile];
+}
+
+export function buildPiExtensionSource(mcp) {
+  const specs = mcpToolSpecs(mcp);
+  const declarations = specs.map((spec, index) => {
+    const id = jsIdentifier(spec.name, index);
+    const schema = spec.parameters || { type: 'object', properties: {} };
+    return `const ${id}Tool = {
+  name: ${JSON.stringify(spec.name)},
+  label: ${JSON.stringify(spec.name)},
+  description: ${JSON.stringify(spec.description || spec.name)},
+  parameters: ${JSON.stringify(schema)},
+  async execute(toolCallId, params, signal) {
+    return callMcpTool(${JSON.stringify(spec.name)}, toolCallId, params, signal);
+  },
+};`;
+  }).join('\n\n');
+  const registrations = specs.map((spec, index) => {
+    const id = jsIdentifier(spec.name, index);
+    return `  pi.registerTool(${id}Tool);`;
+  }).join('\n');
+
+  return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const MCP_URL = ${JSON.stringify(mcp.url)};
+
+function contentFromDataUrl(dataUrl) {
+  const match = /^data:([^;]+);base64,(.+)$/s.exec(String(dataUrl || ""));
+  return match ? { type: "image", data: match[2], mimeType: match[1] } : null;
+}
+
+function normalizeContent(content) {
+  const out = [];
+  for (const item of Array.isArray(content) ? content : []) {
+    if (item?.type === "text") {
+      out.push({ type: "text", text: String(item.text ?? "") });
+    } else if (item?.type === "image" && item.data) {
+      out.push({ type: "image", data: String(item.data), mimeType: String(item.mimeType || "image/png") });
+    } else if (typeof item?.image === "string") {
+      const img = contentFromDataUrl(item.image);
+      if (img) out.push(img);
+      if (item.text) out.push({ type: "text", text: String(item.text) });
+    }
+  }
+  return out.length ? out : [{ type: "text", text: "ok" }];
+}
+
+async function callMcpTool(toolName, toolCallId, params, signal) {
+  const response = await fetch(MCP_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: toolCallId || String(Date.now()),
+      method: "tools/call",
+      params: { name: toolName, arguments: params || {} },
+    }),
+    signal,
+  });
+  const message = await response.json();
+  if (message.error) {
+    return {
+      content: [{ type: "text", text: \`error: \${message.error.message || JSON.stringify(message.error)}\` }],
+      details: { error: message.error },
+    };
+  }
+  return {
+    content: normalizeContent(message.result?.content),
+    details: message.result ?? {},
+  };
+}
+
+${declarations}
+
+export default function (pi: ExtensionAPI) {
+${registrations}
+}
+`;
+}
+
+async function writePiExtension(mcp, tag) {
+  const file = path.join(os.tmpdir(), `chatpanel-pi-tools-${tag}.ts`);
+  await writeFile(file, buildPiExtensionSource(mcp));
+  return file;
+}
+
+async function opencodeHasStableMcpConfig() {
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  const files = [
+    path.join(configHome, 'opencode', 'opencode.jsonc'),
+    path.join(os.homedir(), 'Library', 'Application Support', 'opencode', 'opencode.jsonc'),
+  ];
+  for (const file of files) {
+    try {
+      const text = await readFile(file, 'utf8');
+      if (text.includes(OPENCODE_STABLE_MCP_URL)) return true;
+    } catch {
+      /* missing config is fine */
+    }
+  }
+  return false;
+}
+
 export async function chat({ messages, system, options, images }, emit) {
   // Pro gate — verified, not just UI. No valid signed entitlement → no run.
   if (!(await isProEntitled(options.entitlement))) {
@@ -201,7 +316,11 @@ export async function runSpec(spec, { messages, system, options = {}, images },
   // config file (spec.mcpArg, e.g. "--mcp-config {file}"), write a standard
   // mcpServers JSON pointing at the bridge's stdio MCP proxy and inject the flag.
   // Covers any CLI that reads the de-facto {mcpServers:{name:{command,args}}} shape.
-  if (options.mcp?.url && spec.mcpArg) {
+  if (options.mcp?.url && spec.toolAdapter === 'pi-extension') {
+    const extensionFile = await writePiExtension(options.mcp, tag);
+    mcpFiles.push(extensionFile);
+    args = [...piToolArgs(extensionFile, options.mcp), ...args];
+  } else if (options.mcp?.url && spec.mcpArg) {
     const name = options.mcp.serverName || 'chatpanel_browser';
     const { command, args: pargs } = selfMcpStdio(options.mcp.url);
     const cfgFile = path.join(os.tmpdir(), `chatpanel-mcp-${tag}.json`);
@@ -217,6 +336,12 @@ export async function runSpec(spec, { messages, system, options = {}, images },
   // never a per-run/project file — so we can't inject it here. opencode reaches
   // the browser tools via the bridge's STABLE /mcp endpoint, registered once with
   // `opencode mcp add chatpanel --url http://127.0.0.1:4319/mcp`.
+  if (options.mcp?.url && spec.requiresStableMcp && !(await opencodeHasStableMcpConfig())) {
+    emit({
+      type: 'status',
+      text: `OpenCode needs one-time browser-tool setup: opencode mcp add chatpanel --url ${OPENCODE_STABLE_MCP_URL}`,
+    });
+  }
 
   const imageTokens = imageTokensFor(spec.imageArg, imageFiles);
   let placedImages = false;

package/src/server.js

@@ -30,7 +30,7 @@ import { callLocalMcp } from './mcp-local.js';
 // Hardcoded (not read from package.json) so it survives Bun's single-file
 // --compile, where package.json isn't on a readable FS. CI fails the publish if
 // this drifts from package.json, so the two can't silently diverge.
-const VERSION = '0.10.0';
+const VERSION = '0.10.2';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;