@chatpanel/bridge 0.10.32 → 0.10.34

package/README.md

@@ -92,11 +92,26 @@ npm start                    # → http://127.0.0.1:4319
 | `POST` | `/v1/completions` | OpenAI-compatible legacy text Completions (streaming and non-streaming) |
 | `POST` | `/v1/responses` | OpenAI-compatible Responses API (streaming and non-streaming) |
 | `POST` | `/v1/messages` | Anthropic-compatible Messages API (streaming and non-streaming) |
+| `GET`  | `/skills` | skills installed on this machine, across every agent harness + configured folders |
+| `GET`  | `/skills/<name>` · `/skills/<name>/file/<path>` | one skill's instructions · one reference file |
+| `POST` | `/mcp` | MCP endpoint — `chatpanel_skill_*` tools any CLI can call (plus browser tools while a ChatPanel chat is driving) |
 
 `/chat` streams Server-Sent Events: `{type:'delta',text}` as the answer is
 generated, `{type:'tool',name,summary}` / `{type:'status'}` for activity, and a
 final `{type:'done'}` (or `{type:'error',error}`).
 
+### Use your skills from any CLI
+
+The bridge discovers the skills installed on your machine — Claude Code, Codex, Copilot,
+Gemini, Hermes, `~/.agents/skills`, and any folder you configure — and exposes them as MCP
+tools (`chatpanel_skill_list` / `_open` / `_read`). Point any MCP client at
+`http://127.0.0.1:4319/mcp` and it can list and load them with no browser open.
+
+For **one** server that adds your local **history** (chats, meetings, notes — redacted)
+*alongside* your skills, add the
+[Privacy Gateway](https://github.com/chatpanel/chatpanel-gateway) instead and point your CLI
+at `chatpanel-gateway mcp`. The gateway proxies these skill tools and puts redaction in front.
+
 `options` per agent (set in ChatPanel Settings):
 
 ```jsonc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.10.32",
+  "version": "0.10.34",
   "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/scripts/install.ps1

@@ -52,3 +52,7 @@ if ($installed) {
   Write-Host "  `"$bin`""
 }
 Write-Host "Manage it:  `"$bin`" --status  |  --uninstall"
+Write-Host ""
+Write-Host "Optional upgrade - the Privacy Gateway adds PII redaction, model routing and voice," -ForegroundColor Gray
+Write-Host "and lets any CLI reach your history + skills through one MCP server:" -ForegroundColor Gray
+Write-Host "  irm https://dl.chatpanel.net/gateway/install.ps1 | iex"

package/scripts/install.sh

@@ -4,10 +4,23 @@
 #
 #   curl -fsSL https://raw.githubusercontent.com/chatpanel/chatpanel-bridge/main/scripts/install.sh | bash
 #
+# Add the optional privacy gateway (redaction, model routing, voice) in the same flow:
+#   curl -fsSL https://dl.chatpanel.net/bridge/install.sh | bash -s -- --gateway
+#
 # Downloading via curl means the file is NOT quarantined, so macOS won't show the
 # "damaged / unidentified developer" prompt that browser downloads trigger.
 set -euo pipefail
 
+# --gateway also installs the ChatPanel Privacy Gateway — the optional upgrade that adds
+# PII redaction, model routing and voice in front of everything the bridge does. The bridge
+# is the common case and is always installed; the gateway is opt-in and heavier.
+WITH_GATEWAY=0
+for a in "$@"; do
+  case "$a" in
+    --gateway|--with-gateway) WITH_GATEWAY=1 ;;
+  esac
+done
+
 os="$(uname -s)"
 arch="$(uname -m)"
 asset=""
@@ -59,3 +72,23 @@ case ":${PATH}:" in
   *":${dest}:"*) : ;;
   *) echo "Tip: add it to your PATH ->  export PATH=\"\$HOME/.local/bin:\$PATH\"" ;;
 esac
+
+if [ "$WITH_GATEWAY" = "1" ]; then
+  echo
+  echo "Adding the ChatPanel Privacy Gateway (optional upgrade)..."
+  # One download story: the gateway installer lives at the same dl host. A gateway failure
+  # must not fail the bridge install — the bridge is already up.
+  if curl -fsSL https://dl.chatpanel.net/gateway/install.sh | bash; then
+    echo "Gateway installed. One MCP config now gives any CLI your history + skills, redacted:"
+    echo "    chatpanel-gateway mcp"
+  else
+    echo "Gateway install didn't complete — the bridge is unaffected. Retry any time:"
+    echo "    curl -fsSL https://dl.chatpanel.net/gateway/install.sh | bash"
+  fi
+else
+  echo
+  echo "Optional upgrade — the Privacy Gateway adds PII redaction, model routing and voice,"
+  echo "and lets any CLI (Codex, Claude Code) reach your history + skills through one MCP server:"
+  echo "    curl -fsSL https://dl.chatpanel.net/gateway/install.sh | bash"
+  echo "  (or re-run this with --gateway to add it now.)"
+fi

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/codex.js

@@ -151,6 +151,10 @@ export async function chat({ messages, system, options, images }, emit, { signal
     args.push('-s', sandbox, '-c', 'approval_policy=never');
   }
   if (REASONING) args.push('-c', `model_reasoning_effort=${REASONING}`);
+  // Ask Codex to emit reasoning SUMMARIES so the panel can stream the model's thinking.
+  // Additive + safe: a no-op for models/providers that don't produce summaries (e.g. some
+  // hosted models expose none), and cheap at the default effort. forwardEvent renders them.
+  args.push('-c', 'model_reasoning_summary=auto');
   // 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.
@@ -182,6 +186,9 @@ export async function chat({ messages, system, options, images }, emit, { signal
 
     let stdout = '';
     let stderr = '';
+    // Per-run event state: correlate a command's started/completed events and emit each
+    // reasoning summary once (Codex sends the same item id across item.started/updated/completed).
+    const evState = { started: new Set(), reasoned: new Set(), n: 0 };
     let idleTimer;
     const armIdle = () => {
       clearTimeout(idleTimer);
@@ -201,7 +208,7 @@ export async function chat({ messages, system, options, images }, emit, { signal
         stdout = stdout.slice(nl + 1);
         if (!line.startsWith('{')) continue;
         try {
-          forwardEvent(JSON.parse(line), emit);
+          forwardEvent(JSON.parse(line), emit, evState);
         } catch {
           /* not a JSON event line */
         }
@@ -240,16 +247,58 @@ export async function chat({ messages, system, options, images }, emit, { signal
   });
 }
 
-function forwardEvent(ev, emit) {
+// Translate Codex `exec --json` events into the bridge's streaming vocabulary the panel
+// renders richly. Codex sends item.started (in_progress) then item.completed for each item,
+// reusing the item id — so we correlate a tool's start/done by that id and show its command,
+// its output, and its exit status, the way Codex's own CLI does. Schema (codex-cli 0.15x):
+//   command_execution: { id, command, aggregated_output, exit_code, status }
+//   reasoning:         { id, text }            (only some models/efforts emit it)
+//   file_change:       { id, changes:[{path}] }
+//   agent_message:     { id, text }            (the answer — read from -o outFile at close)
+export function forwardEvent(ev, emit, state = { started: new Set(), reasoned: new Set(), n: 0 }) {
   const t = ev.type || '';
   const item = ev.item || {};
-  if (item.type === 'command_execution' || t.includes('command')) {
-    emit({ type: 'tool', name: 'shell', summary: (item.command || '').slice(0, 60) });
-  } else if (item.type === 'reasoning' || t.includes('reasoning')) {
-    emit({ type: 'reasoning' });
-  } else if (item.type === 'file_change' || t.includes('patch')) {
-    emit({ type: 'tool', name: 'edit', summary: '' });
-  } else if (t === 'turn.started' || t === 'thread.started') {
-    emit({ type: 'status', text: 'Codex working' });
+  const itype = item.type || '';
+  const completed = t === 'item.completed' || item.status === 'completed' || item.status === 'failed';
+
+  if (itype === 'command_execution' || (!itype && t.includes('command'))) {
+    const id = item.id || `cmd_${state.n++}`;
+    if (!state.started.has(id)) {
+      state.started.add(id);
+      emit({ type: 'tool', name: 'shell', phase: 'start', callId: id, input: { command: item.command || '' } });
+    }
+    if (completed) {
+      const ok = item.exit_code === 0 || item.exit_code == null;
+      emit({
+        type: 'tool', name: 'shell', phase: 'done', callId: id,
+        status: ok ? 'ok' : `exit ${item.exit_code}`,
+        result: String(item.aggregated_output || '').slice(0, 4000),
+      });
+    }
+    return;
+  }
+
+  if (itype === 'file_change' || (!itype && t.includes('patch'))) {
+    const id = item.id || `edit_${state.n++}`;
+    const files = Array.isArray(item.changes) ? item.changes.map((c) => c.path || c.file).filter(Boolean) : [];
+    if (!state.started.has(id)) {
+      state.started.add(id);
+      emit({ type: 'tool', name: 'edit', phase: 'start', callId: id, input: { files } });
+    }
+    if (completed) emit({ type: 'tool', name: 'edit', phase: 'done', callId: id, status: 'ok' });
+    return;
   }
+
+  if (itype === 'reasoning' || (!itype && t.includes('reasoning'))) {
+    // Emit each reasoning summary once (dedup the started/updated/completed repeats).
+    const id = item.id || `r_${state.n++}`;
+    const text = item.text || item.summary || '';
+    if (text && !state.reasoned.has(id)) {
+      state.reasoned.add(id);
+      emit({ type: 'reasoning', text: `${text}\n` });
+    }
+    return;
+  }
+
+  if (t === 'turn.started' || t === 'thread.started') emit({ type: 'status', text: 'Codex working' });
 }

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

@@ -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.32';
+const VERSION = '0.10.34';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;