@chatpanel/gateway 0.6.36 → 0.6.37

package/README.md

@@ -191,6 +191,29 @@ command = "chatpanel-gateway"
 args = ["mcp"]
 ```
 
+> **Corporate Codex with an approval guardian?** If a tool call is rejected with
+> *"Automatic approval review failed"* (an `approvals_reviewer = "auto_review"` policy
+> can't assess a tool it doesn't know), pre-approve ChatPanel's read-only tools the same
+> way you would any other server — one block per tool:
+>
+> ```toml
+> [mcp_servers.chatpanel.tools.search_history]
+> approval_mode = "approve"
+> [mcp_servers.chatpanel.tools.get_record]
+> approval_mode = "approve"
+> [mcp_servers.chatpanel.tools.list_history]
+> approval_mode = "approve"
+> [mcp_servers.chatpanel.tools.list_skills]
+> approval_mode = "approve"
+> [mcp_servers.chatpanel.tools.open_skill]
+> approval_mode = "approve"
+> [mcp_servers.chatpanel.tools.read_skill_file]
+> approval_mode = "approve"
+> ```
+>
+> All six only read local data (your redacted history and your installed skills), so
+> approving them carries no write or network risk.
+
 **Claude Code** — one command (`--scope user` makes it available in every project):
 
 ```bash

package/bin/chatpanel-gateway.js

@@ -4,6 +4,7 @@
 //   chatpanel-gateway              start the gateway (foreground)
 //   chatpanel-gateway mcp          stdio MCP server exposing warm history as tools
 //   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
 //   chatpanel-gateway --uninstall  remove login auto-start
 //   chatpanel-gateway --status     is auto-start registered?
@@ -24,6 +25,10 @@ try {
     // Read-only unified view of both services. No server.js import — just HTTP probes.
     const { localStatus, formatLocalStatus } = await import('../src/local-status.js');
     process.stdout.write(formatLocalStatus(await localStatus()));
+  } else if (arg === 'connect') {
+    const { connectAgents, formatConnect } = await import('../src/connect-agents.js');
+    const dryRun = process.argv.includes('--dry-run') || process.argv.includes('-n');
+    process.stdout.write(formatConnect(connectAgents({ dryRun }), { dryRun }));
   } else {
     const { start, VERSION } = await import('../src/server.js');
     const { installService, uninstallService, serviceStatus } = await import('../src/service.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.36",
+  "version": "0.6.37",
   "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/connect-agents.js

@@ -0,0 +1,173 @@
+// connect-agents.js — wire the local CLI agents to the ChatPanel MCP server in one step.
+//
+// `chatpanel-gateway connect` detects the agent CLIs installed on this machine and points
+// each at `chatpanel-gateway mcp`, so a person gets their history + skills in every agent
+// without hand-editing four different config files in four different formats.
+//
+// Two rules keep this safe to run unattended:
+//   • BACK UP then EDIT, and be IDEMPOTENT — running it twice changes nothing the second
+//     time. A user's existing MCP servers are never touched.
+//   • Only auto-write a format we can write CORRECTLY. Codex (TOML append), Claude Code
+//     (its own CLI) and Gemini (plain JSON) are safe. For agents whose config is JSONC with
+//     comments, or whose format we cannot verify, we PRINT the exact snippet instead of
+//     risking a corrupted config. Guessing a format and clobbering a config is worse than
+//     asking the user to paste four lines.
+
+import { readFileSync, writeFileSync, existsSync, copyFileSync, mkdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+import os from 'node:os';
+
+// The six read-only tools the ChatPanel MCP server exposes (history + skills). Named here so
+// the Codex approval blocks stay in step with what the server actually advertises.
+const TOOLS = ['search_history', 'get_record', 'list_history', 'list_skills', 'open_skill', 'read_skill_file'];
+
+// Resolve the command a config should launch. A bare name works when the client inherits a
+// normal PATH; an absolute path is the safe fallback when it does not.
+export function resolveServerCommand(which = whichSync) {
+  const abs = which('chatpanel-gateway');
+  return abs || 'chatpanel-gateway';
+}
+
+function whichSync(bin) {
+  try {
+    return execFileSync('which', [bin], { encoding: 'utf8' }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function backup(path) {
+  const b = `${path}.bak.chatpanel`;
+  try { copyFileSync(path, b); return b; } catch { return null; }
+}
+
+// ── Codex ──────────────────────────────────────────────────────────────────────────────
+// ~/.codex/config.toml. TOML, and Node has no TOML writer — but the change is a pure
+// APPEND of a server block plus per-tool approval blocks, so a text append (guarded by a
+// presence check) is correct and non-destructive. The approval blocks matter: a corporate
+// Codex with `approvals_reviewer = "auto_review"` rejects a tool it cannot assess, and this
+// is how every other server on such a setup is pre-approved.
+function connectCodex({ cmd, dryRun, home }) {
+  const dir = join(home, '.codex');
+  const path = join(dir, 'config.toml');
+  if (!existsSync(dir)) return { id: 'codex', status: 'absent' };
+  const cur = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  if (/\[mcp_servers\.chatpanel\]/.test(cur)) return { id: 'codex', status: 'already', path };
+
+  let block = '\n# ChatPanel — local history (redacted) + your installed skills, via one MCP server.\n';
+  block += `[mcp_servers.chatpanel]\ncommand = ${JSON.stringify(cmd)}\nargs = ["mcp"]\n\n`;
+  block += '# Read-only tools — pre-approved so a corporate auto_review guardian does not reject them.\n';
+  for (const t of TOOLS) block += `[mcp_servers.chatpanel.tools.${t}]\napproval_mode = "approve"\n\n`;
+
+  if (dryRun) return { id: 'codex', status: 'would', path, preview: block.trim() };
+  const bak = backup(path);
+  writeFileSync(path, `${cur.replace(/\s*$/, '')}\n${block}`);
+  return { id: 'codex', status: 'configured', path, backup: bak };
+}
+
+// ── Claude Code ────────────────────────────────────────────────────────────────────────
+// Its own CLI owns ~/.claude.json, so use `claude mcp add` rather than editing it. --scope
+// user makes it available in every project.
+function connectClaude({ cmd, dryRun, which }) {
+  const claude = which('claude');
+  if (!claude) return { id: 'claude-code', status: 'absent' };
+  // Already added? `claude mcp get` exits non-zero when it is not there.
+  try { execFileSync(claude, ['mcp', 'get', 'chatpanel'], { stdio: 'ignore' }); return { id: 'claude-code', status: 'already' }; } catch { /* not present */ }
+  if (dryRun) return { id: 'claude-code', status: 'would', preview: `claude mcp add --scope user chatpanel ${cmd} mcp` };
+  try {
+    execFileSync(claude, ['mcp', 'add', '--scope', 'user', 'chatpanel', cmd, 'mcp'], { stdio: 'ignore' });
+    return { id: 'claude-code', status: 'configured' };
+  } catch (e) {
+    return { id: 'claude-code', status: 'error', message: e.message };
+  }
+}
+
+// ── Gemini CLI / Antigravity ─────────────────────────────────────────────────────────────
+// ~/.gemini/settings.json — plain JSON, safe to parse and merge.
+function connectGemini({ cmd, dryRun, home }) {
+  const dir = join(home, '.gemini');
+  const path = join(dir, 'settings.json');
+  if (!existsSync(dir)) return { id: 'gemini', status: 'absent' };
+  let cfg = {};
+  if (existsSync(path)) {
+    try { cfg = JSON.parse(readFileSync(path, 'utf8')); } catch { return { id: 'gemini', status: 'error', message: 'settings.json is not valid JSON — left untouched', path }; }
+  }
+  cfg.mcpServers = cfg.mcpServers || {};
+  if (cfg.mcpServers.chatpanel) return { id: 'gemini', status: 'already', path };
+  const entry = { command: cmd, args: ['mcp'] };
+  if (dryRun) return { id: 'gemini', status: 'would', path, preview: JSON.stringify({ mcpServers: { chatpanel: entry } }, null, 2) };
+  const bak = existsSync(path) ? backup(path) : null;
+  cfg.mcpServers.chatpanel = entry;
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path, `${JSON.stringify(cfg, null, 2)}\n`);
+  return { id: 'gemini', status: 'configured', path, backup: bak };
+}
+
+// ── Agents we do NOT auto-write (JSONC with comments, or a format we can't verify) ───────
+// Detected and given the exact snippet, rather than risking a clobbered config.
+function manualAgent(id, present, snippet) {
+  return present ? { id, status: 'manual', snippet } : { id, status: 'absent' };
+}
+
+function otherAgents({ cmd, home, which }) {
+  const out = [];
+  // OpenCode — opencode.json / .jsonc. JSONC keeps comments; we won't rewrite and drop them.
+  out.push(manualAgent('opencode', existsSync(join(home, '.opencode')) || existsSync(join(home, '.config', 'opencode')),
+    `Add to your opencode config (opencode.json):\n  "mcp": { "chatpanel": { "type": "local", "command": [${JSON.stringify(cmd)}, "mcp"], "enabled": true } }`));
+  // GitHub Copilot CLI.
+  out.push(manualAgent('copilot', existsSync(join(home, '.copilot')),
+    `Copilot CLI: add an MCP server named "chatpanel" running:  ${cmd} mcp`));
+  // Hermes.
+  out.push(manualAgent('hermes', existsSync(join(home, '.hermes')) || !!which('hermes'),
+    `Hermes: register an MCP server "chatpanel" with command  ${cmd} mcp  (see Hermes' MCP docs).`));
+  // Pi.
+  out.push(manualAgent('pi', existsSync(join(home, '.pi')) || !!which('pi'),
+    `Pi: add an MCP server "chatpanel" running:  ${cmd} mcp`));
+  return out;
+}
+
+/**
+ * Detect and (unless dryRun) configure every agent found. Returns one result per agent so a
+ * caller can render a summary. Pure-ish: the only side effects are the config writes, and
+ * dryRun suppresses them.
+ */
+export function connectAgents({ dryRun = false, cmd, home = os.homedir(), which = whichSync } = {}) {
+  const serverCmd = cmd || resolveServerCommand(which);
+  const results = [
+    connectCodex({ cmd: serverCmd, dryRun, home }),
+    connectClaude({ cmd: serverCmd, dryRun, which }),
+    connectGemini({ cmd: serverCmd, dryRun, home }),
+    ...otherAgents({ cmd: serverCmd, home, which }),
+  ];
+  return { cmd: serverCmd, results };
+}
+
+const LABEL = {
+  codex: 'Codex', 'claude-code': 'Claude Code', gemini: 'Gemini / Antigravity',
+  opencode: 'OpenCode', copilot: 'GitHub Copilot', hermes: 'Hermes', pi: 'Pi',
+};
+
+/** Human summary for the CLI. */
+export function formatConnect({ cmd, results }, { dryRun = false } = {}) {
+  const lines = [`ChatPanel MCP — connecting your agents to:  ${cmd} mcp`, ''];
+  const icon = { configured: '✓', already: '•', would: '→', manual: '✎', absent: '·', error: '✕' };
+  for (const r of results) {
+    const name = LABEL[r.id] || r.id;
+    if (r.status === 'absent') continue; // don't list agents that aren't installed
+    const head = `  ${icon[r.status] || '?'} ${name}`;
+    if (r.status === 'configured') lines.push(`${head} — configured${r.backup ? ` (backup: ${r.backup})` : ''}`);
+    else if (r.status === 'already') lines.push(`${head} — already connected`);
+    else if (r.status === 'would') lines.push(`${head} — would configure:\n      ${(r.preview || '').split('\n').join('\n      ')}`);
+    else if (r.status === 'manual') lines.push(`${head} — add it yourself:\n      ${r.snippet.split('\n').join('\n      ')}`);
+    else if (r.status === 'error') lines.push(`${head} — ${r.message}`);
+  }
+  const configured = results.filter((r) => r.status === 'configured').length;
+  lines.push('');
+  if (dryRun) lines.push('  (dry run — nothing was written. Re-run without --dry-run to apply.)');
+  else if (configured) lines.push(`  Done. Restart the configured agent(s) to pick up the new server.`);
+  else lines.push('  Nothing to change.');
+  const anyManual = results.some((r) => r.status === 'manual');
+  if (anyManual) lines.push('  Agents marked ✎ use a config format best edited by hand — the snippet above is exact.');
+  return `${lines.join('\n')}\n`;
+}

package/src/server.js

@@ -45,7 +45,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.36';
+export const VERSION = '0.6.37';
 
 // 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.