@chatpanel/bridge 0.10.6 → 0.10.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "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": [

package/scripts/install.sh

@@ -34,16 +34,21 @@ url="https://dl.chatpanel.net/${asset}"
 dest="${HOME}/.local/bin"
 bin="${dest}/chatpanel-bridge"
 mkdir -p "$dest"
+tmp="$(mktemp "${dest}/.chatpanel-bridge.XXXXXX")"
+trap 'rm -f "$tmp"' EXIT
 
 echo "Downloading ChatPanel Bridge (~60 MB)..."
-curl -fL --progress-bar "$url" -o "$bin"   # show a progress bar (not silent)
-chmod +x "$bin"
-xattr -c "$bin" 2>/dev/null || true   # belt-and-suspenders; curl files aren't quarantined
+curl -fL --progress-bar "$url" -o "$tmp"   # show a progress bar (not silent)
+chmod +x "$tmp"
+xattr -c "$tmp" 2>/dev/null || true   # belt-and-suspenders; curl files aren't quarantined
 
 # Clean upgrade: stop any running bridge (incl. a stray npx one) so the new
 # install replaces it in place — same path, same service, no duplicates.
 pkill -f 'chatpanel-bridge' 2>/dev/null || true
 sleep 1
+rm -f "$bin"
+mv "$tmp" "$bin"
+trap - EXIT
 
 echo "Installed to ${bin}"
 "$bin" --install

package/src/engines/cli-agents.js

@@ -82,9 +82,14 @@ export const kiro = makeCliAgent(
     args: 'chat --no-interactive --require-mcp-startup',
     promptVia: 'arg',
     modelArg: '--model {model}',
-    trustToolsArg: '--trust-tools={tools}',
+    // Kiro can see MCP tools with --trust-tools, but in --no-interactive mode it
+    // only executes MCP calls when this broader trust flag is present.
+    trustAllToolsForMcp: true,
+    trustAllToolsArg: '--trust-all-tools',
     requiresStableMcp: true,
+    autoSetupStableMcp: true,
     stableMcpConfigCheck: 'kiro',
+    stableMcpSetupArgs: ['mcp', 'add', '--scope', 'global', '--name', 'chatpanel_browser', '--url', 'http://127.0.0.1:4319/mcp', '--force'],
     stableMcpSetupCommand: 'kiro-cli mcp add --scope global --name chatpanel_browser --url http://127.0.0.1:4319/mcp --force',
     listModelsArgs: '--list-models',
     label: 'Kiro',

package/src/engines/custom.js

@@ -150,11 +150,22 @@ export function trustToolArgs(template, mcp) {
     : [...tmpl.split(/\s+/).filter(Boolean), value];
 }
 
+export function mcpTrustArgs(spec = {}, mcp) {
+  if (spec.trustAllToolsForMcp) return [spec.trustAllToolsArg || '--trust-all-tools'];
+  return spec.trustToolsArg ? trustToolArgs(spec.trustToolsArg, mcp) : [];
+}
+
 export function stableMcpSetupCommand(spec = {}) {
   if (spec.stableMcpSetupCommand) return spec.stableMcpSetupCommand;
   return `opencode mcp add chatpanel --url ${CHATPANEL_STABLE_MCP_URL}`;
 }
 
+export function stableMcpSetupPlan(spec = {}) {
+  const args = Array.isArray(spec.stableMcpSetupArgs) ? spec.stableMcpSetupArgs.filter((a) => a != null).map(String) : null;
+  if (!args?.length) return null;
+  return { command: spec.stableMcpSetupCommandName || spec.command, args };
+}
+
 export function buildPiExtensionSource(mcp) {
   const specs = mcpToolSpecs(mcp);
   const declarations = specs.map((spec, index) => {
@@ -256,25 +267,27 @@ async function opencodeHasStableMcpConfig() {
   return false;
 }
 
-async function commandStdout(command, args, cwd) {
+export async function commandOutput(command, args, cwd) {
   const resolved = resolveCommand(command);
   if (!resolved) return '';
   const [bin, argv, opts] = buildSpawnSpec(resolved, args, cwd || null);
   return new Promise((resolve) => {
     const child = spawn(bin, argv, opts);
     let out = '';
+    let err = '';
     const timer = setTimeout(() => {
       child.kill('SIGKILL');
-      resolve(out);
+      resolve(out + err);
     }, 4000);
     child.stdout.on('data', (d) => (out += d.toString()));
+    child.stderr.on('data', (d) => (err += d.toString()));
     child.on('error', () => {
       clearTimeout(timer);
-      resolve('');
+      resolve(out + err);
     });
     child.on('close', () => {
       clearTimeout(timer);
-      resolve(out);
+      resolve(out + err);
     });
     try { child.stdin.end(); } catch { /* ignore */ }
   });
@@ -282,7 +295,7 @@ async function commandStdout(command, args, cwd) {
 
 async function kiroHasStableMcpConfig(command, cwd) {
   for (const scope of ['workspace', 'global', 'default']) {
-    const out = await commandStdout(command, ['mcp', 'list', scope], cwd);
+    const out = await commandOutput(command, ['mcp', 'list', scope], cwd);
     if (out.includes(CHATPANEL_STABLE_MCP_URL) || /chatpanel_browser/i.test(out)) return true;
   }
   return false;
@@ -294,6 +307,59 @@ async function hasStableMcpConfig(spec, cwd) {
   return false;
 }
 
+async function runStableMcpSetup(plan, cwd) {
+  const resolved = resolveCommand(plan.command);
+  if (!resolved) throw new Error(`Couldn't find "${plan.command}" to set up browser tools.`);
+  const [bin, argv, opts] = buildSpawnSpec(resolved, plan.args, cwd || null);
+  opts.env = { ...(opts.env || process.env), NO_COLOR: '1', FORCE_COLOR: '0', CLICOLOR: '0', TERM: 'dumb' };
+  await new Promise((resolve, reject) => {
+    let child;
+    try { child = spawn(bin, argv, opts); } catch (e) { return reject(new Error(`Failed to start ${plan.command}: ${e.message}`)); }
+    let stderr = '';
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`${plan.command} MCP setup timed out.`));
+    }, 20_000);
+    child.stderr.on('data', (d) => (stderr += d.toString()));
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      reject(new Error(`Failed to start ${plan.command}: ${e.message}`));
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code === 0) return resolve();
+      reject(new Error(`${plan.command} MCP setup exited ${code}: ${stderr.trim().split('\n').pop() || 'failed'}`));
+    });
+    try { child.stdin.end(); } catch { /* ignore */ }
+  });
+}
+
+export async function ensureStableMcpConfig(spec, cwd, label, emit, deps = {}) {
+  if (!spec.requiresStableMcp) return true;
+  const hasConfig = deps.hasConfig || hasStableMcpConfig;
+  const runSetup = deps.runSetup || runStableMcpSetup;
+  if (await hasConfig(spec, cwd)) return true;
+
+  const setupCommand = stableMcpSetupCommand(spec);
+  if (!spec.autoSetupStableMcp) {
+    const text = `${label} needs one-time browser-tool setup: ${setupCommand}`;
+    emit({ type: 'status', text });
+    throw new Error(text);
+  }
+
+  const plan = stableMcpSetupPlan(spec);
+  if (!plan?.command) {
+    const text = `${label} needs one-time browser-tool setup: ${setupCommand}`;
+    emit({ type: 'status', text });
+    throw new Error(text);
+  }
+
+  emit({ type: 'status', text: `${label} is setting up one-time browser tools...` });
+  await runSetup(plan, cwd);
+  if (await hasConfig(spec, cwd)) return true;
+  throw new Error(`${label} browser-tool setup completed, but the MCP server is still not visible. Run: ${setupCommand}`);
+}
+
 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))) {
@@ -373,19 +439,10 @@ export async function runSpec(spec, { messages, system, options = {}, images },
       : [...tmpl.split(/\s+/).filter(Boolean), cfgFile];
     args = [...tokens, ...args];
   }
-  if (options.mcp?.url && spec.trustToolsArg) {
-    args.push(...trustToolArgs(spec.trustToolsArg, options.mcp));
-  }
-  // NOTE: opencode only loads MCP from its GLOBAL config (~/.config/opencode),
-  // 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 hasStableMcpConfig(spec, cwd))) {
-    emit({
-      type: 'status',
-      text: `${label} needs one-time browser-tool setup: ${stableMcpSetupCommand(spec)}`,
-    });
-  }
+  if (options.mcp?.url) args.push(...mcpTrustArgs(spec, options.mcp));
+  // Some CLIs only load MCP from their persistent config, so ensure that stable
+  // /mcp endpoint is present before letting the agent answer with no tools.
+  if (options.mcp?.url) await ensureStableMcpConfig(spec, cwd, label, emit);
 
   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.6';
+const VERSION = '0.10.8';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;