@chatpanel/gateway 0.6.13 → 0.6.15

package/bin/chatpanel-gateway.js

@@ -2,40 +2,49 @@
 // CLI entry for the ChatPanel Privacy Gateway.
 //
 //   chatpanel-gateway              start the gateway (foreground)
+//   chatpanel-gateway mcp          stdio MCP server exposing warm history as tools
 //   chatpanel-gateway --install    register login auto-start + start now
 //   chatpanel-gateway --uninstall  remove login auto-start
 //   chatpanel-gateway --status     is auto-start registered?
 //   chatpanel-gateway --version    print version
 //
 // Config comes from gateway.config.json / env (see src/config.js).
-import { start, VERSION } from '../src/server.js';
-import { installService, uninstallService, serviceStatus } from '../src/service.js';
+export {}; // mark as an ES module (all imports below are dynamic)
 
 const arg = process.argv[2];
 
 try {
-  switch (arg) {
-    case '--version':
-    case '-v':
-      console.log(VERSION);
-      break;
-    case '--install':
-      installService();
-      console.log('ChatPanel Privacy Gateway: installed login auto-start and started it.');
-      break;
-    case '--uninstall':
-      uninstallService();
-      console.log('ChatPanel Privacy Gateway: removed login auto-start.');
-      break;
-    case '--status':
-      console.log(serviceStatus() ? 'installed (auto-start registered)' : 'not installed');
-      break;
-    case undefined:
-      start();
-      break;
-    default:
-      console.error(`unknown option: ${arg}\nUsage: chatpanel-gateway [--install|--uninstall|--status|--version]`);
-      process.exit(2);
+  if (arg === 'mcp') {
+    // Its own path: proxies to the running gateway over HTTP and must NOT import
+    // server.js (which would open a second handle on the warm SQLite store).
+    const { runMcpServer } = await import('../src/mcp.js');
+    await runMcpServer();
+  } else {
+    const { start, VERSION } = await import('../src/server.js');
+    const { installService, uninstallService, serviceStatus } = await import('../src/service.js');
+    switch (arg) {
+      case '--version':
+      case '-v':
+        console.log(VERSION);
+        break;
+      case '--install':
+        installService();
+        console.log('ChatPanel Privacy Gateway: installed login auto-start and started it.');
+        break;
+      case '--uninstall':
+        uninstallService();
+        console.log('ChatPanel Privacy Gateway: removed login auto-start.');
+        break;
+      case '--status':
+        console.log(serviceStatus() ? 'installed (auto-start registered)' : 'not installed');
+        break;
+      case undefined:
+        start();
+        break;
+      default:
+        console.error(`unknown option: ${arg}\nUsage: chatpanel-gateway [mcp|--install|--uninstall|--status|--version]`);
+        process.exit(2);
+    }
   }
 } catch (e) {
   console.error(`error: ${e.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "Local privacy gateway — 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.js

@@ -0,0 +1,148 @@
+// `chatpanel-gateway mcp` — a stdio MCP server that exposes the WARM history store
+// (chats · meetings · notes) as agent tools. Point any MCP client (Codex, OpenCode,
+// Claude Desktop, …) at `chatpanel-gateway mcp` and it gets search/get/list over the
+// full local corpus — the reliable fallback when an agent's own context holds only
+// hot/recent data.
+//
+// It PROXIES to the already-running gateway's HTTP API (127.0.0.1:<port>), so there
+// is exactly one warm store (the service's) and this process never opens the DB.
+// JSON-RPC 2.0 over stdio, newline-delimited — implemented directly (zero deps).
+
+import { loadConfig } from './config.js';
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER = { name: 'chatpanel-history', version: '1.0.0' };
+
+function baseUrl() {
+  const env = process.env.CHATPANEL_GATEWAY_URL;
+  if (env) return env.replace(/\/+$/, '');
+  let port = 4320;
+  try {
+    port = loadConfig().port || 4320;
+  } catch {
+    /* default */
+  }
+  return `http://127.0.0.1:${port}`;
+}
+
+const TOOLS = [
+  {
+    name: 'search_history',
+    description: 'Full-text search the user\'s ChatPanel history (past chats and meeting transcripts) by keyword relevance. Use this to recall what was discussed when the current context does not already contain it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Natural-language / keyword query.' },
+        limit: { type: 'number', description: 'Max results (default 10).' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_record',
+    description: 'Fetch one full history record (its complete text) by id, e.g. chat:<id> or meeting:<id> returned by search_history.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Record id such as chat:abc or meeting:imp_123.' } },
+      required: ['id'],
+    },
+  },
+  {
+    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.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max items (default 50).' },
+        offset: { type: 'number', description: 'Skip N items for paging (default 0).' },
+      },
+    },
+  },
+];
+
+async function gatewayJson(path, init) {
+  const res = await fetch(baseUrl() + path, init);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data?.error?.message || `gateway ${res.status}`);
+  return data;
+}
+
+// Run a tool → a plain-text result an agent can read.
+async function callTool(name, args = {}) {
+  if (name === 'search_history') {
+    const data = await gatewayJson('/v1/history/search', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      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.';
+  }
+  if (name === 'get_record') {
+    const data = await gatewayJson(`/v1/history/get?id=${encodeURIComponent(String(args.id || ''))}`);
+    const r = data.record;
+    return `[${r.id}] ${r.title || '(untitled)'} · ${r.type}${r.date ? ' · ' + new Date(r.date).toISOString().slice(0, 10) : ''}\n\n${r.text || '(empty)'}`;
+  }
+  if (name === 'list_history') {
+    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');
+  }
+  throw new Error(`unknown tool: ${name}`);
+}
+
+// Dispatch a JSON-RPC request → a response object (or null for a notification).
+export async function handleRpc(msg) {
+  const { id, method, params } = msg || {};
+  const ok = (result) => ({ jsonrpc: '2.0', id, result });
+  const err = (code, message) => ({ jsonrpc: '2.0', id, error: { code, message } });
+  try {
+    switch (method) {
+      case 'initialize':
+        return ok({ protocolVersion: PROTOCOL_VERSION, capabilities: { tools: {} }, serverInfo: SERVER });
+      case 'tools/list':
+        return ok({ tools: TOOLS });
+      case 'tools/call': {
+        const text = await callTool(params?.name, params?.arguments || {});
+        return ok({ content: [{ type: 'text', text }] });
+      }
+      case 'ping':
+        return ok({});
+      default:
+        if (typeof method === 'string' && method.startsWith('notifications/')) return null; // notification: no reply
+        if (id === undefined) return null; // other notification
+        return err(-32601, `method not found: ${method}`);
+    }
+  } catch (e) {
+    // Tool failures come back as a tool result with isError so the agent can react.
+    if (method === 'tools/call') return ok({ content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true });
+    return err(-32603, e.message);
+  }
+}
+
+// Read newline-delimited JSON-RPC from stdin, write responses to stdout.
+export async function runMcpServer() {
+  let buf = '';
+  process.stdin.setEncoding('utf8');
+  const write = (obj) => process.stdout.write(JSON.stringify(obj) + '\n');
+  for await (const chunk of process.stdin) {
+    buf += chunk;
+    let nl;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue; // ignore malformed lines
+      }
+      const reply = await handleRpc(msg);
+      if (reply) write(reply);
+    }
+  }
+}

package/src/server.js

@@ -28,7 +28,8 @@ import { createRelaySession, getRelaySession, endRelaySession, pumpBridgeStream,
 import { shaperFor } from './shape.js';
 import { startNer } from './ner.js';
 import { installTimestampedConsole } from './log.js';
-import { HistoryStore, saveBackupSecret, loadBackupSecret, hasBackupSecret } from './history-store.js';
+import { saveBackupSecret, loadBackupSecret, hasBackupSecret } from './history-store.js';
+import { createHistoryStore } from './sqlite-store.js';
 import { ingestBackup } from './backup-ingest.js';
 import * as nerEngine from './ner-engine.js';
 import { MODEL_CATALOG, isKnownModel } from './models.js';
@@ -39,12 +40,13 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.13';
+export const VERSION = '0.6.15';
 
-// WARM search tier — one record store + BM25 index per gateway process, fed by the
-// extension's ingest sync. Encrypted at rest under ~/.chatpanel, loaded on start so a
-// restart doesn't need a full re-ingest (no cold start). See docs/architecture-data-tiers.
-const historyStore = new HistoryStore().load();
+// 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.
+// Persistent + memory-mapped, so a restart needs no re-ingest (no cold start).
+// See docs/architecture-data-tiers.
+const historyStore = await createHistoryStore();
 
 const KNOWN_AGENTS = new Set(['codex', 'claude', 'opencode', 'pi', 'kiro', 'antigravity']);
 

package/src/sqlite-store.js

@@ -0,0 +1,143 @@
+// WARM store — SQLite + FTS5 backend (the scale engine behind the same interface
+// as history-store.js's HistoryStore). SQLite is memory-mapped, so a year of
+// chats/meetings is searchable without loading the whole corpus into RAM, with
+// battle-tested BM25 full-text search and O(1) record lookups.
+//
+// Dual runtime: the npm gateway runs on Node (node:sqlite, built in since 22); the
+// standalone binary is compiled with Bun (bun:sqlite). Both ship FTS5. The
+// specifier is computed so neither bundler tries to resolve the other runtime's
+// module. createHistoryStore() falls back to the encrypted-JSON HistoryStore if
+// SQLite can't load at all, so this can never break a gateway.
+//
+// AT REST: a local .db file (0600) under ~/.chatpanel, protected by OS disk
+// encryption — the on-device warm tier. Zero-knowledge encryption is the COLD/cloud
+// tier's job, not this one. The backup passphrase (a credential) stays encrypted
+// via history-store.js's saveBackupSecret.
+
+import { join } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import os from 'node:os';
+import { HistoryStore } from './history-store.js';
+
+const DIR = join(os.homedir(), '.chatpanel');
+const DB_PATH = process.env.CHATPANEL_HISTORY_DB || join(DIR, 'history.db');
+
+// Silence node:sqlite's one-time "experimental" warning for a clean CLI; pass
+// every other warning through untouched.
+if (typeof Bun === 'undefined') {
+  const emit = process.emitWarning.bind(process);
+  process.emitWarning = (w, ...a) => (typeof w === 'string' && w.includes('SQLite is an experimental') ? undefined : emit(w, ...a));
+}
+
+// Normalize node:sqlite (DatabaseSync) and bun:sqlite (Database) to one tiny API.
+async function openDb(path) {
+  if (typeof Bun !== 'undefined') {
+    const { Database } = await import('bun:sqlite');
+    const db = new Database(path, { create: true });
+    return {
+      exec: (sql) => db.run(sql),
+      run: (sql, p = []) => db.prepare(sql).run(...p),
+      all: (sql, p = []) => db.query(sql).all(...p),
+      get: (sql, p = []) => db.query(sql).get(...p),
+    };
+  }
+  const spec = 'node' + ':sqlite'; // computed so the Bun bundler won't touch it
+  const { DatabaseSync } = await import(spec);
+  const db = new DatabaseSync(path);
+  return {
+    exec: (sql) => db.exec(sql),
+    run: (sql, p = []) => db.prepare(sql).run(...p),
+    all: (sql, p = []) => db.prepare(sql).all(...p),
+    get: (sql, p = []) => db.prepare(sql).get(...p),
+  };
+}
+
+// query text → a safe FTS5 MATCH string. Each term is quoted (so FTS5 operators in
+// user text can't inject), joined with OR for recall — bm25 handles the ranking.
+function ftsMatch(query) {
+  const terms = String(query || '').toLowerCase().match(/[a-z0-9][a-z0-9'_+-]*/g);
+  if (!terms || !terms.length) return null;
+  return terms.map((t) => `"${t.replace(/"/g, '""')}"`).join(' OR ');
+}
+
+export class SqliteHistoryStore {
+  constructor({ path = DB_PATH } = {}) {
+    this.path = path;
+    this.db = null;
+  }
+
+  async init() {
+    if (this.path !== ':memory:') mkdirSync(DIR, { recursive: true });
+    this.db = await openDb(this.path);
+    this.db.exec('PRAGMA journal_mode=WAL');
+    this.db.exec('CREATE TABLE IF NOT EXISTS records(id TEXT PRIMARY KEY, title TEXT, type TEXT, date INTEGER, chars INTEGER)');
+    this.db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS fts USING fts5(id UNINDEXED, title, text, tokenize='unicode61')");
+    return this;
+  }
+
+  // Kept for interface-compatibility with HistoryStore (SQLite is already loaded).
+  load() {
+    return this;
+  }
+
+  get size() {
+    return this.db.get('SELECT COUNT(*) c FROM records')?.c || 0;
+  }
+
+  bulk({ upserts = [], removes = [] } = {}) {
+    this.db.exec('BEGIN');
+    try {
+      for (const id of removes) {
+        this.db.run('DELETE FROM records WHERE id = ?', [id]);
+        this.db.run('DELETE FROM fts WHERE id = ?', [id]);
+      }
+      for (const d of upserts) {
+        if (!d || !d.id) continue;
+        const text = String(d.text || '');
+        this.db.run('DELETE FROM fts WHERE id = ?', [d.id]); // FTS5 has no UPSERT on UNINDEXED id
+        this.db.run('INSERT INTO fts(id, title, text) VALUES(?, ?, ?)', [d.id, d.title || '', text]);
+        this.db.run('INSERT OR REPLACE INTO records(id, title, type, date, chars) VALUES(?, ?, ?, ?, ?)', [d.id, d.title || '', d.type || '', d.date || 0, text.length]);
+      }
+      this.db.exec('COMMIT');
+    } catch (e) {
+      this.db.exec('ROLLBACK');
+      throw e;
+    }
+    return this.size;
+  }
+
+  // [{ id, score, title, type, date }] — score higher = better (bm25 is negated).
+  search(query, { limit = 10 } = {}) {
+    const match = ftsMatch(query);
+    if (!match) return [];
+    const rows = this.db.all(
+      'SELECT r.id id, r.title title, r.type type, r.date date, bm25(fts) b FROM fts JOIN records r ON r.id = fts.id WHERE fts MATCH ? ORDER BY b LIMIT ?',
+      [match, limit],
+    );
+    return rows.map((r) => ({ id: r.id, score: -r.b, title: r.title, type: r.type, date: r.date }));
+  }
+
+  list({ limit = 50, offset = 0 } = {}) {
+    const total = this.db.get('SELECT COUNT(*) c FROM records')?.c || 0;
+    const items = this.db.all('SELECT id, title, type, date, chars FROM records ORDER BY date DESC LIMIT ? OFFSET ?', [limit, offset]);
+    return { total, items };
+  }
+
+  get(id) {
+    const meta = this.db.get('SELECT id, title, type, date FROM records WHERE id = ?', [id]);
+    if (!meta) return null;
+    const body = this.db.get('SELECT text FROM fts WHERE id = ?', [id]);
+    return { ...meta, text: body?.text || '' };
+  }
+}
+
+// Pick the best available warm engine. SQLite when it loads; otherwise the
+// encrypted-JSON HistoryStore — so a gateway is never left without a warm store.
+export async function createHistoryStore(opts = {}) {
+  try {
+    return await new SqliteHistoryStore(opts).init();
+  } catch (e) {
+    console.log(`[warm] SQLite unavailable (${e.message}); using the encrypted file store`);
+    return new HistoryStore(opts).load();
+  }
+}