@chatpanel/gateway 0.6.72 → 0.6.74

package/bin/chatpanel-gateway.js

@@ -3,6 +3,9 @@
 //
 //   chatpanel-gateway              start the gateway (foreground)
 //   chatpanel-gateway mcp          stdio MCP server exposing warm history as tools
+//   chatpanel-gateway tools list   the same tools, from a shell — names and one-liners
+//   chatpanel-gateway tools schema <tool>   one tool's full schema
+//   chatpanel-gateway call <tool> '<json>'  run one tool (exit 0 ok · 1 tool error · 2 usage)
 //   chatpanel-gateway local        show the local runtime — bridge + gateway, one view
 //   chatpanel-gateway connect      point your CLI agents (Codex, Claude Code, …) at this server
 //   chatpanel-gateway --install    register login auto-start + start now
@@ -21,6 +24,11 @@ try {
     // server.js (which would open a second handle on the warm SQLite store).
     const { runMcpServer } = await import('../src/mcp.js');
     await runMcpServer();
+  } else if (arg === 'tools' || arg === 'call') {
+    // MCP2CLI: the MCP tools as shell verbs, for agents that only have a shell. Same
+    // in-process dispatcher as `mcp`, same no-server.js rule.
+    const { runMcpCli } = await import('../src/mcp-cli.js');
+    process.exit(await runMcpCli(process.argv.slice(2)));
   } else if (arg === 'local') {
     // Read-only unified view of both services. No server.js import — just HTTP probes.
     const { localStatus, formatLocalStatus } = await import('../src/local-status.js');
@@ -52,7 +60,7 @@ try {
         start();
         break;
       default:
-        console.error(`unknown option: ${arg}\nUsage: chatpanel-gateway [mcp|--install|--uninstall|--status|--version]`);
+        console.error(`unknown option: ${arg}\nUsage: chatpanel-gateway [mcp|tools list|tools schema <tool>|call <tool> '<json>'|local|connect|--install|--uninstall|--status|--version]`);
         process.exit(2);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.72",
+  "version": "0.6.74",
   "description": "Local privacy gateway \u2014 redacts PII out of OpenAI/Anthropic API traffic before it reaches a model, then restores it in the reply. Point opencode, codex, aider, Claude Code, etc. at it.",
   "type": "module",
   "bin": {

package/src/bridge.js

@@ -58,14 +58,76 @@ export async function resolveBridgeUrl(cfg, { fallback, timeoutMs = 1500, now =
 /** Test seam. */
 export function resetBridgeResolution() { bridgeResolved = { at: 0, cfgUrl: '', url: '', fell: false }; }
 
-export function readBridgeToken(cfgToken, tokenPath = DEFAULT_TOKEN_PATH) {
-  if (cfgToken) return cfgToken;
+// Once the bridge has REJECTED the configured token while the file held a different one,
+// the file is what every later call presents. Set by `bridgeTokenRejected`, below.
+let preferFileToken = false;
+
+function fileToken(tokenPath) {
   try {
     if (existsSync(tokenPath)) return readFileSync(tokenPath, 'utf8').trim();
   } catch { /* ignore */ }
   return '';
 }
 
+/**
+ * The bridge token: the config's value first, the file otherwise — until the bridge says
+ * the config's value is wrong.
+ *
+ * `bridge.token` in gateway.config.json is a COPY: the extension's Gateway tab writes its
+ * own setting there, and a bridge that regenerates its token leaves the copy behind. The
+ * desktop then relayed every Codex turn with the stale copy and got 403 from a bridge ten
+ * milliseconds away — an empty streaming bubble, forever. The file is written by the
+ * bridge itself, so when the configured token is rejected and the file differs, the file
+ * is tried once and, if it works, kept. Nothing is second-guessed before the bridge has
+ * actually said no: a pinned token on a loopback bridge stays a pinned token.
+ */
+export function readBridgeToken(cfgToken, tokenPath = DEFAULT_TOKEN_PATH) {
+  const file = fileToken(tokenPath);
+  if (!cfgToken) return file;
+  if (preferFileToken && file && file !== cfgToken) return file;
+  return cfgToken;
+}
+
+/**
+ * Called with the token the bridge just refused. Returns the file's token when it is a
+ * different one worth trying — and from then on `readBridgeToken` prefers it — or '' when
+ * there is nothing else to try.
+ */
+export function bridgeTokenRejected(rejected, tokenPath = DEFAULT_TOKEN_PATH) {
+  const file = fileToken(tokenPath);
+  if (!file || file === rejected) return '';
+  if (!preferFileToken) {
+    preferFileToken = true;
+    console.warn('[gateway] the bridge rejected bridge.token from gateway.config.json; using ~/.chatpanel/bridge-token (the bridge wrote it). Clear the config value to silence this.');
+  }
+  return file;
+}
+
+/** Test seam. */
+export function resetBridgeTokenPreference() { preferFileToken = false; }
+
+const isAuthFailure = (status) => status === 401 || status === 403;
+
+// One POST to /chat, retried once with the file's token when the bridge refuses the one
+// it was given — the stale-copy case above.
+async function postChat(bridgeUrl, token, body, signal, tokenPath) {
+  const send = (t) => fetch(`${bridgeUrl.replace(/\/$/, '')}/chat`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', ...(t ? { authorization: `Bearer ${t}` } : {}) },
+    body,
+    signal,
+  });
+  // A caller hands over the token it resolved; once a rejection has flipped the
+  // preference, the file's token goes first here too.
+  const first = readBridgeToken(token, tokenPath);
+  let res = await send(first);
+  if (isAuthFailure(res.status)) {
+    const alt = bridgeTokenRejected(first, tokenPath);
+    if (alt) { await res.text().catch(() => {}); res = await send(alt); }
+  }
+  return res;
+}
+
 // Flatten an OpenAI/Anthropic message's content (string | parts[]) to plain text
 // for the bridge, which expects string content. Image parts are dropped here (the
 // bridge takes images separately; wire that later if needed).
@@ -88,19 +150,14 @@ export function toBridgeMessages(messages) {
 
 // Open a bridge /chat stream WITH tool specs (pageTools), returning the raw fetch
 // Response so the tool-relay can hold the reader open across the OpenAI round-trip.
-export async function openBridgeChat({ bridgeUrl, agent, token, messages, system, specs, options, signal }) {
-  const res = await fetch(`${bridgeUrl.replace(/\/$/, '')}/chat`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', ...(token ? { authorization: `Bearer ${token}` } : {}) },
-    body: JSON.stringify({
-      agent,
-      messages: toBridgeMessages(messages),
-      system: system || '',
-      options: options || {},
-      ...(Array.isArray(specs) && specs.length ? { pageTools: { specs } } : {}),
-    }),
-    signal,
-  });
+export async function openBridgeChat({ bridgeUrl, agent, token, messages, system, specs, options, signal, tokenPath }) {
+  const res = await postChat(bridgeUrl, token, JSON.stringify({
+    agent,
+    messages: toBridgeMessages(messages),
+    system: system || '',
+    options: options || {},
+    ...(Array.isArray(specs) && specs.length ? { pageTools: { specs } } : {}),
+  }), signal, tokenPath);
   if (!res.ok || !res.body) {
     const detail = await res.text().catch(() => '');
     throw new Error(`bridge /chat HTTP ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
@@ -112,21 +169,13 @@ export async function openBridgeChat({ bridgeUrl, agent, token, messages, system
 // onActivity(event) for everything else the agent reports — status lines, the working
 // directory, tool calls, reasoning.
 // of model text and returns the full (un-restored) text. Throws on bridge error.
-export async function streamBridgeChat({ bridgeUrl, agent, token, messages, system, options, signal }, onText, onActivity = null) {
-  const res = await fetch(`${bridgeUrl.replace(/\/$/, '')}/chat`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      ...(token ? { authorization: `Bearer ${token}` } : {}),
-    },
-    body: JSON.stringify({
-      agent,
-      messages: toBridgeMessages(messages),
-      system: system || '',
-      options: options || {},
-    }),
-    signal,
-  });
+export async function streamBridgeChat({ bridgeUrl, agent, token, messages, system, options, signal, tokenPath }, onText, onActivity = null) {
+  const res = await postChat(bridgeUrl, token, JSON.stringify({
+    agent,
+    messages: toBridgeMessages(messages),
+    system: system || '',
+    options: options || {},
+  }), signal, tokenPath);
 
   if (!res.ok || !res.body) {
     const detail = await res.text().catch(() => '');

package/src/mcp-cli.js

@@ -0,0 +1,113 @@
+// `chatpanel-gateway tools list | tools schema <tool> | call <tool> '<json>'` — the same
+// tools the MCP server offers, reached from a shell.
+//
+// An MCP connection is a standing cost: every tool's schema sits in the agent's context on
+// every turn, called or not. A shell verb costs nothing until it is used — `tools list`
+// prints names and one-liners, `tools schema` pulls ONE schema at the moment of calling,
+// `call` runs the tool. So an agent that has only a shell (a skill's `scripts/`, a CI job,
+// a CLI with no MCP support) reaches history, memory and briefs at a cost that scales with
+// use rather than with how many tools exist. The daemon's secrets never move: the CLI
+// talks to the gateway exactly as the MCP server does, over loopback with the gateway
+// token, and prints results.
+//
+// Exit codes, so a script can tell them apart: 0 the tool answered; 1 the tool itself
+// reported an error (a real tool-level failure — the record was not found); 2 a usage or
+// transport failure (bad JSON, unknown verb, gateway unreachable).
+
+import { readFileSync } from 'node:fs';
+import { handleRpc } from './mcp.js';
+
+const USAGE = [
+  'Usage:',
+  '  chatpanel-gateway tools list                 names and one-liners (no schemas)',
+  '  chatpanel-gateway tools schema <tool>        one tool\'s full input schema',
+  '  chatpanel-gateway call <tool> [\'<json>\']     run a tool; arguments as a JSON object',
+  '  chatpanel-gateway call <tool> --file <path>  arguments from a JSON file (no shell quoting)',
+  '',
+  'Exit codes: 0 ok · 1 the tool reported an error · 2 usage or transport failure',
+].join('\n');
+
+/** First sentence, whitespace collapsed, capped — enough to choose a tool, not to call it. */
+export function oneLiner(description, max = 100) {
+  const s = String(description || '').replace(/\s+/g, ' ').trim();
+  const cut = s.search(/[.!?]\s/);
+  const first = cut > 20 ? s.slice(0, cut + 1) : s;
+  return first.length > max ? `${first.slice(0, max - 1).trimEnd()}…` : first;
+}
+
+export function formatToolsList(tools) {
+  const width = Math.min(24, Math.max(...tools.map((t) => t.name.length), 4));
+  return tools.map((t) => {
+    const req = Array.isArray(t.inputSchema?.required) && t.inputSchema.required.length ? `(${t.inputSchema.required.join(', ')})` : '()';
+    return `${t.name.padEnd(width)}  ${req.padEnd(22)} ${oneLiner(t.description)}`;
+  }).join('\n');
+}
+
+function parseArgs(argv) {
+  const rest = [...argv];
+  let file = null;
+  const i = rest.indexOf('--file');
+  if (i >= 0) { file = rest[i + 1]; rest.splice(i, 2); }
+  return { rest, file };
+}
+
+/**
+ * Run one CLI invocation. Returns the exit code; writes through `out`/`err` so a test can
+ * capture without a process. `rpc` is the MCP dispatcher — `handleRpc` in production.
+ */
+export async function runMcpCli(argv, { out = (s) => process.stdout.write(s), err = (s) => process.stderr.write(s), rpc = handleRpc } = {}) {
+  const [verb, ...more] = argv;
+  const list = async () => (await rpc({ jsonrpc: '2.0', id: 1, method: 'tools/list' }))?.result?.tools || [];
+
+  if (verb === 'tools') {
+    const [sub, name] = more;
+    if (sub === 'list') {
+      out(`${formatToolsList(await list())}\n`);
+      return 0;
+    }
+    if (sub === 'schema') {
+      if (!name) { err(`tools schema: which tool?\n${USAGE}\n`); return 2; }
+      const tool = (await list()).find((t) => t.name === name);
+      if (!tool) { err(`no tool named "${name}". Run: chatpanel-gateway tools list\n`); return 2; }
+      out(`${JSON.stringify({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema }, null, 2)}\n`);
+      return 0;
+    }
+    err(`${USAGE}\n`);
+    return 2;
+  }
+
+  if (verb === 'call') {
+    const { rest, file } = parseArgs(more);
+    const [name, inline] = rest;
+    if (!name) { err(`call: which tool?\n${USAGE}\n`); return 2; }
+    let args = {};
+    try {
+      const text = file ? readFileSync(file, 'utf8') : (inline ?? '{}');
+      args = JSON.parse(text);
+    } catch (e) {
+      err(`call: arguments must be a JSON object (${e.message})\n`);
+      return 2;
+    }
+    if (!args || typeof args !== 'object' || Array.isArray(args)) { err('call: arguments must be a JSON object\n'); return 2; }
+    let reply;
+    try {
+      reply = await rpc({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name, arguments: args } });
+    } catch (e) {
+      err(`call: ${e.message}\n`);
+      return 2;
+    }
+    if (reply?.error) { err(`call: ${reply.error.message}\n`); return 2; }
+    const text = (reply?.result?.content || []).filter((c) => c.type === 'text').map((c) => c.text).join('\n');
+    if (reply?.result?.isError) {
+      // The gateway being down looks like a tool error from the MCP layer; it is transport.
+      const transport = /fetch failed|ECONNREFUSED|not running|unreachable/i.test(text);
+      err(`${text}\n`);
+      return transport ? 2 : 1;
+    }
+    out(`${text}\n`);
+    return 0;
+  }
+
+  err(`${USAGE}\n`);
+  return 2;
+}

package/src/server.js

@@ -56,7 +56,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.72';
+export const VERSION = '0.6.74';
 
 // WARM search tier — SQLite + FTS5 record store (falls back to an encrypted-JSON
 // store if SQLite can't load), fed by the extension's ingest sync + backup-ingest.