@chatpanel/gateway 0.6.72 → 0.6.73

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.73",
   "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/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.73';
 
 // 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.