@chatpanel/bridge 0.10.33 → 0.10.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.10.33",
+  "version": "0.10.35",
   "type": "module",
   "description": "Local bridge that exposes the AI coding agents installed on your machine \u2014 Claude Code (CLI), Codex (CLI), and Antigravity CLI (formerly Gemini CLI, which remains available for business/enterprise) \u2014 to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
   "keywords": [

package/src/engines/claude.js

@@ -166,6 +166,18 @@ function runClaude({ prompt, args, cwd, emit, signal }) {
   });
 }
 
+// A tool_result's content is either a string or Anthropic's block array. Flatten to text and
+// cap it: the panel truncates for display anyway, and an un-capped file read would otherwise
+// push megabytes through the SSE for no benefit.
+function toolResultText(content) {
+  let text = '';
+  if (typeof content === 'string') text = content;
+  else if (Array.isArray(content)) {
+    text = content.map((c) => (typeof c === 'string' ? c : (c?.text || ''))).filter(Boolean).join('\n');
+  }
+  return text.length > 4000 ? `${text.slice(0, 4000)}…` : text;
+}
+
 // Map one stream-json message to emit() calls. Returns { streamed, result }.
 // The CLI's stream-json mirrors the SDK message shapes. Exported so the custom
 // engine can reuse it for agents that emit Claude-style stream-json.
@@ -184,12 +196,33 @@ export function handleMessage(msg, emit, alreadyStreamed, cwdForSteps = '') {
   } 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, cwdForSteps) });
+        // PHASE-BASED, like the Codex engine: the panel renders a step with the call's
+        // arguments and then fills in its status and output when the result arrives. The old
+        // single `summary` event produced one anonymous line per call and no outcome — you
+        // could see that Claude did something, never what it returned. `summary` is still
+        // sent so an older extension keeps the line it used to draw.
+        emit({
+          type: 'tool', name: block.name, phase: 'start',
+          callId: block.id, input: block.input,
+          summary: toolSummary(block, cwdForSteps),
+        });
       } else if (block.type === 'text' && !alreadyStreamed) {
         out.streamed = true;
         emit({ type: 'delta', text: block.text });
       }
     }
+  } else if (msg.type === 'user') {
+    // Claude reports every tool's OUTCOME as a tool_result block on a synthetic user message.
+    // Pairing it with the call by tool_use_id is what turns the step list into a readable
+    // log: each action shows ok / error and the text the tool actually returned.
+    for (const block of msg.message?.content || []) {
+      if (block.type !== 'tool_result') continue;
+      emit({
+        type: 'tool', phase: 'done', callId: block.tool_use_id,
+        status: block.is_error ? 'error' : 'ok',
+        result: toolResultText(block.content),
+      });
+    }
   } else if (msg.type === 'result') {
     if (msg.subtype === 'success') out.result = msg.result || '';
     else emit({ type: 'status', text: `(${msg.subtype})` });

package/src/engines/cli-agents.js

@@ -6,6 +6,7 @@
 //   pi       — pi -p "<prompt>"        · --model · @{path} images · --list-models
 //   opencode — opencode run "<prompt>" · -m provider/model · -f {path} images · models
 //   kiro     — kiro-cli chat --no-interactive "<prompt>" · --model · --list-models
+//   hermes   — hermes -z "<prompt>"      · -m model · config get model (no list command)
 
 import { runSpec, listSpecModels, runForStdout } from './custom.js';
 import { findAgentBin } from '../env.js';
@@ -248,3 +249,43 @@ export async function listDshModels(command = 'dsh', workingDir) {
   }
   return [...DSH_KNOWN_MODELS];
 }
+
+// Hermes Agent (Nous Research). `-z/--oneshot` prints ONLY the final response text — no
+// banner, no spinner, no tool previews — which is exactly the contract the shared runner
+// wants, and it auto-bypasses approvals so a headless turn never blocks on a prompt.
+//
+// Its own tools and skills (82 of them here) stay ACTIVE: Hermes loads them itself, and the
+// bridge's browser tools arrive over the stable /mcp endpoint like opencode and kiro, since
+// Hermes only reads MCP servers from its own config rather than a per-run file.
+//
+// `hermes model` is interactive with no --list flag, so model discovery goes through
+// `hermes config get model`, which prints the resolved default + provider as `key: value`
+// lines. That yields the one model the user has actually configured — honest, if short.
+export const hermes = makeCliAgent(
+  'hermes',
+  {
+    args: '-z',
+    promptVia: 'arg',
+    modelArg: '-m {model}',
+    requiresStableMcp: true,
+    autoSetupStableMcp: true,
+    stableMcpConfigCheck: 'hermes',
+    stableMcpSetupArgs: ['mcp', 'add', 'chatpanel_browser', '--url', 'http://127.0.0.1:4319/mcp'],
+    stableMcpSetupCommand: 'hermes mcp add chatpanel_browser --url http://127.0.0.1:4319/mcp',
+    label: 'Hermes',
+  },
+  'hermes not found on PATH. Install Hermes Agent, then run `hermes setup` to sign in.',
+  {
+    // `config get model` prints resolved settings as `key: value`; we want the default model
+    // id, not the provider or base_url lines around it.
+    listModels: async (command, options = {}) => {
+      try {
+        const out = await runForStdout(command, ['config', 'get', 'model'], options.workingDir);
+        const m = /^\s*default:\s*(\S+)/m.exec(out || '');
+        return m ? [m[1]] : [];
+      } catch {
+        return []; // not configured yet — the picker still accepts a typed id
+      }
+    },
+  },
+);

package/src/engines/custom.js

@@ -307,9 +307,17 @@ async function kiroHasStableMcpConfig(command, cwd) {
   return false;
 }
 
+// Hermes keeps MCP servers in its own config; `hermes mcp list` is the one honest way to ask
+// whether ours is already registered (no scopes, unlike kiro).
+async function hermesHasStableMcpConfig(command, cwd) {
+  const out = await commandOutput(command, ['mcp', 'list'], cwd);
+  return out.includes(CHATPANEL_STABLE_MCP_URL) || /chatpanel_browser/i.test(out);
+}
+
 async function hasStableMcpConfig(spec, cwd) {
   if (spec.stableMcpConfigCheck === 'kiro') return kiroHasStableMcpConfig(spec.command || 'kiro-cli', cwd);
   if (spec.stableMcpConfigCheck === 'opencode') return opencodeHasStableMcpConfig();
+  if (spec.stableMcpConfigCheck === 'hermes') return hermesHasStableMcpConfig(spec.command || 'hermes', cwd);
   return false;
 }
 

package/src/engines/stream-formats.js

@@ -86,8 +86,23 @@ function opencodeJson(emit) {
       streamed = true;
       emit({ type: 'delta', text: ev.part.text });
     } else if (ev.type === 'tool' || ev.type === 'tool_use') {
+      // Phase-based where opencode gives us enough to pair a call with its outcome: its tool
+      // parts carry a callID and a state that moves running → completed/error. Without that we
+      // still emit a start, so the step at least appears (the old behaviour).
       const p = ev.part || {};
-      emit({ type: 'tool', name: p.tool || p.name || p.type || 'tool', summary: '' });
+      const name = p.tool || p.name || p.type || 'tool';
+      const callId = p.callID || p.callId || p.id || undefined;
+      const state = p.state || {};
+      const status = String(state.status || '').toLowerCase();
+      if (status === 'completed' || status === 'error') {
+        emit({
+          type: 'tool', name, phase: 'done', callId,
+          status: status === 'error' ? 'error' : 'ok',
+          result: String(state.output || state.error || '').slice(0, 4000),
+        });
+      } else {
+        emit({ type: 'tool', name, phase: 'start', callId, input: state.input || p.input, 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) });

package/src/server.js

@@ -33,7 +33,7 @@ import { join } from 'node:path';
 import * as claude from './engines/claude.js';
 import * as codex from './engines/codex.js';
 import * as antigravity from './engines/antigravity.js';
-import { pi, opencode, kiro, copilot, deepseek } from './engines/cli-agents.js';
+import { pi, opencode, kiro, copilot, deepseek , hermes } from './engines/cli-agents.js';
 import { connectorsFor } from './connectors.js';
 import * as custom from './engines/custom.js';
 import { installService, uninstallService, serviceStatus, restartService } from './service.js';
@@ -67,7 +67,7 @@ import {
 // 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.33';
+const VERSION = '0.10.35';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
 
@@ -77,6 +77,7 @@ const ENGINES = {
   antigravity: { engine: antigravity, label: 'Antigravity' },
   pi: { engine: pi, label: 'Pi' },
   opencode: { engine: opencode, label: 'OpenCode' },
+  hermes: { engine: hermes, label: 'Hermes' },
   kiro: { engine: kiro, label: 'Kiro' },
   copilot: { engine: copilot, label: 'GitHub Copilot' },
   deepseek: { engine: deepseek, label: 'DeepSeek Harness' },