@chatpanel/gateway 0.6.36 → 0.6.38

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.38",
   "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/history-store.js

@@ -96,6 +96,14 @@ export class HistoryStore {
     return this.records.size;
   }
 
+  // The timestamp of the freshest record, so a client can tell how current this warm copy
+  // is — the difference between "no such meeting" and "not synced yet".
+  get newest() {
+    let max = 0;
+    for (const r of this.records.values()) if ((r.date || 0) > max) max = r.date || 0;
+    return max || null;
+  }
+
   key() {
     if (!this._key) this._key = loadOrCreateKey();
     return this._key;

package/src/mcp.js

@@ -61,7 +61,7 @@ async function bridgeJson(path) {
 const TOOLS = [
   {
     name: 'search_history',
-    description: 'Full-text search the user\'s ChatPanel history — past chats, meeting transcripts, and notes — by keyword relevance. Use this to recall what was discussed or written when the current context does not already contain it.',
+    description: 'Full-text search the user\'s ChatPanel history — past chats, meeting transcripts, and notes — by keyword relevance. This is a LOCAL WARM COPY that syncs from ChatPanel; very recent items (a meeting from the last few hours) may not be here yet — every result reports how current the index is. If the user is sure something exists and it is not found, it likely has not synced; say so rather than concluding it does not exist. Meeting titles are often generic ("Zoom Meeting"), so search by CONTENT (topics, names, decisions), not the meeting title.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -82,7 +82,7 @@ const TOOLS = [
   },
   {
     name: 'list_history',
-    description: 'List history records (newest first) with their id, title, type and date — no bodies. Use to browse or page the corpus.',
+    description: 'List history records (newest first) with their id, title, type and date — no bodies. Reports how current this warm copy is (its newest record). Use to see the index horizon and browse/page the corpus.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -119,6 +119,15 @@ const TOOLS = [
   },
 ];
 
+// A one-line freshness banner from the store's newest record, so every answer states the
+// index horizon — the model can then say "not synced yet" instead of "does not exist".
+function horizonLine(newest, size) {
+  if (!newest) return `Index: ${size} records (warm copy synced from ChatPanel).`;
+  const d = new Date(newest);
+  const iso = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')} ${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+  return `Index: ${size} records, current through ${iso} (local warm copy — items newer than this may not have synced from ChatPanel yet).`;
+}
+
 async function gatewayJson(path, init) {
   let res;
   try {
@@ -142,8 +151,9 @@ async function callTool(name, args = {}) {
       body: JSON.stringify({ query: String(args.query || ''), limit: Number(args.limit) || 10 }),
     });
     const rows = data.results || [];
-    if (!rows.length) return `No matching history for: ${args.query}`;
-    return [`${rows.length} result(s) for "${args.query}" (of ${data.size} indexed):`, ...rows.map((r, i) => `${i + 1}. [${r.id}] ${r.title || '(untitled)'} · ${r.type}${r.date ? ' · ' + new Date(r.date).toISOString().slice(0, 10) : ''} · score ${r.score?.toFixed?.(3) ?? r.score}`)].join('\n') + '\n\nUse get_record with an id for the full text.';
+    const horizon = horizonLine(data.newest, data.size);
+    if (!rows.length) return `No match for "${args.query}".\n${horizon}\nIf you expected a recent item, it may not have synced yet — check ChatPanel directly, or try broader content keywords (titles are often generic).`;
+    return [horizon, '', `${rows.length} result(s) for "${args.query}":`, ...rows.map((r, i) => `${i + 1}. [${r.id}] ${r.title || '(untitled)'} · ${r.type}${r.date ? ' · ' + new Date(r.date).toISOString().slice(0, 10) : ''} · score ${r.score?.toFixed?.(3) ?? r.score}`)].join('\n') + '\n\nUse get_record with an id for the full text.';
   }
   if (name === 'get_record') {
     const data = await gatewayJson(`/v1/history/get?id=${encodeURIComponent(String(args.id || ''))}`);
@@ -154,8 +164,9 @@ async function callTool(name, args = {}) {
     const q = new URLSearchParams({ limit: String(Number(args.limit) || 50), offset: String(Number(args.offset) || 0) });
     const data = await gatewayJson(`/v1/history/list?${q}`);
     const items = data.items || [];
-    if (!items.length) return 'History is empty (or the gateway has not been seeded yet).';
-    return [`${items.length} of ${data.total} records:`, ...items.map((it) => `[${it.id}] ${it.title || '(untitled)'} · ${it.type}${it.date ? ' · ' + new Date(it.date).toISOString().slice(0, 10) : ''} · ${it.chars} chars`)].join('\n');
+    if (!items.length) return 'History is empty (or the gateway has not been seeded yet — open ChatPanel with warm sync enabled).';
+    const newest = items[0]?.date || null;
+    return [horizonLine(newest, data.total), '', `${items.length} of ${data.total} records:`, ...items.map((it) => `[${it.id}] ${it.title || '(untitled)'} · ${it.type}${it.date ? ' · ' + new Date(it.date).toISOString().slice(0, 10) : ''} · ${it.chars} chars`)].join('\n');
   }
   if (name === 'list_skills') {
     let data;

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.38';
 
 // 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.
@@ -579,13 +579,13 @@ export function createGateway(cfg = loadConfig()) {
       try {
         const body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')) || {};
         const results = historyStore.search(String(body.query || ''), { limit: Number(body.limit) || 10 });
-        return sendJson(res, 200, { ok: true, size: historyStore.size, results });
+        return sendJson(res, 200, { ok: true, size: historyStore.size, newest: historyStore.newest, results });
       } catch (e) {
         return sendJson(res, 400, { error: { message: `search failed: ${e.message}`, type: 'search_error' } });
       }
     }
     if (pathname === '/v1/history/status' && req.method === 'GET') {
-      return sendJson(res, 200, { ok: true, size: historyStore.size });
+      return sendJson(res, 200, { ok: true, size: historyStore.size, newest: historyStore.newest });
     }
     if (pathname === '/v1/history/list' && req.method === 'GET') {
       const limit = Math.min(500, Math.max(1, Number(url.searchParams.get('limit')) || 50));