@chatpanel/bridge 0.9.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "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/src/engines/cli-agents.js

@@ -54,10 +54,17 @@ export const pi = makeCliAgent(
 export const opencode = makeCliAgent(
   'opencode',
   {
-    args: 'run',
+    // `--format json` → clean NDJSON events (the default emits a TUI that's
+    // garbage when piped). --dangerously-skip-permissions so headless tool use
+    // (incl. our relayed browser tools) doesn't block on an approval prompt.
+    args: 'run --format json --dangerously-skip-permissions',
     promptVia: 'arg',
     modelArg: '-m {model}',
     imageArg: '-f {path}',
+    format: 'opencode-json',
+    // 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).
     listModelsArgs: 'models',
     label: 'OpenCode',
   },

package/src/engines/custom.js

@@ -158,9 +158,9 @@ export async function runSpec(spec, { messages, system, options = {}, images },
   }
 
   const prompt = buildPrompt(messages, system);
-  const cwd = options.workingDir ? path.resolve(options.workingDir) : null;
+  let cwd = options.workingDir ? path.resolve(options.workingDir) : null;
   const label = spec.label || spec.command;
-  const fmt = spec.format === 'claude-stream-json' ? 'claude-stream-json' : 'text';
+  const fmt = ['claude-stream-json', 'opencode-json'].includes(spec.format) ? spec.format : 'text';
 
   // Args: either a real array or a space-split string. With promptVia:'arg' we
   // substitute {prompt} (or append it if there's no placeholder); otherwise the
@@ -184,7 +184,10 @@ export async function runSpec(spec, { messages, system, options = {}, images },
     const injected = tmpl.includes('{model}')
       ? tmpl.replaceAll('{model}', options.model).split(/\s+/).filter(Boolean)
       : [...tmpl.split(/\s+/).filter(Boolean), options.model];
-    args = [...injected, ...args];
+    // APPEND (not prepend): subcommand CLIs (opencode `run`, kiro `chat`) must
+    // keep the subcommand first — `opencode -m X run` makes `run` look like a
+    // project path, so it never loads opencode.json / its MCP servers.
+    args = [...args, ...injected];
   }
   // Images: write to temp files, expand the agent's imageArg template, then place
   // the tokens. An explicit {images} placeholder in args wins; otherwise they go
@@ -210,6 +213,10 @@ export async function runSpec(spec, { messages, system, options = {}, images },
       : [...tmpl.split(/\s+/).filter(Boolean), cfgFile];
     args = [...tokens, ...args];
   }
+  // 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`.
 
   const imageTokens = imageTokensFor(spec.imageArg, imageFiles);
   let placedImages = false;
@@ -289,6 +296,28 @@ export async function runSpec(spec, { messages, system, options = {}, images },
           if (r.streamed) streamedAny = true;
           if (r.result != null) resultText = r.result;
         }
+      } else if (fmt === 'opencode-json') {
+        // opencode `run --format json` emits newline-delimited events: text parts,
+        // tool/tool_use, and errors. Extract the answer text + surface tools/errors.
+        jsonBuf += s;
+        let nl;
+        while ((nl = jsonBuf.indexOf('\n')) >= 0) {
+          const line = jsonBuf.slice(0, nl).trim();
+          jsonBuf = jsonBuf.slice(nl + 1);
+          if (!line.startsWith('{')) continue;
+          let ev;
+          try { ev = JSON.parse(line); } catch { continue; }
+          if (ev.type === 'text' && ev.part?.text) {
+            streamedAny = true;
+            emit({ type: 'delta', text: ev.part.text });
+          } else if (ev.type === 'tool' || ev.type === 'tool_use') {
+            const p = ev.part || {};
+            emit({ type: 'tool', name: p.tool || p.name || p.type || 'tool', summary: '' });
+          } else if (ev.type === 'error') {
+            const msg = ev.error?.data?.message || ev.error?.message || ev.error?.name || 'error';
+            emit({ type: 'status', text: String(msg).slice(0, 300) });
+          }
+        }
       } else {
         streamedAny = true;
         emit({ type: 'delta', text: stripAnsi(s) });

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.9.0';
+const VERSION = '0.10.0';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
 
@@ -55,11 +55,13 @@ const ENGINES = {
 // result POSTed back to /tool-result. The bridge itself never touches the page.
 // --------------------------------------------------------------------------
 const sessions = new Map(); // sessionId -> { id, emit, specs, pending: Map, nextId }
+let latestSessionId = null; // for the stable /mcp endpoint (CLIs configured once)
 
 function createSession(emit, specs) {
   const id = randomUUID();
   const s = { id, emit, specs, pending: new Map(), nextId: 0 };
   sessions.set(id, s);
+  latestSessionId = id;
   return s;
 }
 
@@ -68,6 +70,17 @@ function deleteSession(id) {
   if (!s) return;
   for (const p of s.pending.values()) p.reject(new Error('chat ended'));
   sessions.delete(id);
+  if (latestSessionId === id) {
+    // fall back to the most-recently-created surviving session, if any
+    const ids = [...sessions.keys()];
+    latestSessionId = ids.length ? ids[ids.length - 1] : null;
+  }
+}
+
+// The session a sessionless /mcp request maps to (CLIs configured once with a
+// stable URL — e.g. `opencode mcp add chatpanel --url …/mcp`). The active chat.
+function activeSession() {
+  return (latestSessionId && sessions.get(latestSessionId)) || null;
 }
 
 // Ask the extension to run a tool and await its result. Resolves to MCP content.
@@ -228,8 +241,9 @@ async function handleChat(req, res) {
   }
 }
 
-// POST /mcp/<session> — the HTTP MCP server the CLI agent connects to. JSON-RPC
-// over POST; tools/call relays to the extension and waits for /tool-result.
+// POST /mcp/<session> (per-run, bridge-injected) OR POST /mcp (stable: routes to
+// the active chat — for CLIs configured once, e.g. `opencode mcp add … …/mcp`).
+// JSON-RPC; tools/call relays to the extension and waits for /tool-result.
 async function handleMcp(req, res, sessionId) {
   let msg;
   try {
@@ -237,9 +251,10 @@ async function handleMcp(req, res, sessionId) {
   } catch {
     return json(res, 200, { jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
   }
-  const session = sessions.get(sessionId);
+  // Explicit session id (per-run URL) or the active chat (stable /mcp).
+  const session = sessionId ? sessions.get(sessionId) : activeSession();
   const reply = (result) => {
-    if (sessionId) res.setHeader('Mcp-Session-Id', sessionId);
+    if (session) res.setHeader('Mcp-Session-Id', session.id);
     json(res, 200, { jsonrpc: '2.0', id: msg.id ?? null, result });
   };
   const fail = (code, message) => json(res, 200, { jsonrpc: '2.0', id: msg.id ?? null, error: { code, message } });
@@ -254,7 +269,12 @@ async function handleMcp(req, res, sessionId) {
       serverInfo: { name: 'chatpanel-browser', version: VERSION },
     });
   }
-  if (!session) return fail(-32001, 'Session not found (chat already ended)');
+  // No active chat → advertise zero tools rather than erroring, so a CLI with a
+  // standing /mcp config (run outside ChatPanel) starts cleanly instead of failing.
+  if (!session) {
+    if (msg.method === 'tools/list') return reply({ tools: [] });
+    return fail(-32001, 'No active ChatPanel session — open a chat with “Act on page” on.');
+  }
   if (msg.method === 'tools/list') {
     return reply({
       tools: session.specs.map((s) => ({
@@ -424,6 +444,12 @@ const server = createServer(async (req, res) => {
       });
     }
     if (req.method === 'POST' && url.pathname === '/chat') return handleChat(req, res);
+    // Stable endpoint: routes to the active chat. For CLIs configured once with a
+    // fixed URL (e.g. `opencode mcp add chatpanel --url http://127.0.0.1:4319/mcp`).
+    if (url.pathname === '/mcp') {
+      if (req.method === 'POST') return handleMcp(req, res, null);
+      if (req.method === 'GET') { res.writeHead(405); return res.end(); }
+    }
     if (url.pathname.startsWith('/mcp/')) {
       const sid = decodeURIComponent(url.pathname.slice(5));
       if (req.method === 'POST') return handleMcp(req, res, sid);