@chatpanel/gateway 0.6.33 → 0.6.35

package/bin/chatpanel-gateway.js

@@ -3,6 +3,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 --install    register login auto-start + start now
 //   chatpanel-gateway --uninstall  remove login auto-start
 //   chatpanel-gateway --status     is auto-start registered?
@@ -19,6 +20,10 @@ 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 === 'local') {
+    // 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 {
     const { start, VERSION } = await import('../src/server.js');
     const { installService, uninstallService, serviceStatus } = await import('../src/service.js');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.33",
-  "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.",
+  "version": "0.6.35",
+  "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": {
     "chatpanel-gateway": "bin/chatpanel-gateway.js"

package/src/local-status.js

@@ -0,0 +1,104 @@
+// local-status.js — one view of ChatPanel's local runtime: the bridge and the gateway.
+//
+// U3 of docs/bridge-gateway-unification.md: a person should be able to ask "what's running
+// locally?" once and get a straight answer, without knowing there are two services on two
+// ports. This is the read side of that — it probes both over HTTP and reports. It does NOT
+// control either service (start/stop stays with each module's own installer, which owns its
+// launchd/systemd unit); managing another module's service from here would duplicate the
+// knowledge of how to do it and drift.
+//
+// The bridge is OPTIONAL from the gateway's side and the gateway is OPTIONAL from the
+// bridge's — so a missing one is reported plainly, never as an error.
+
+import { loadConfig } from './config.js';
+
+function gatewayUrl() {
+  try {
+    return `http://127.0.0.1:${loadConfig().port || 4320}`;
+  } catch {
+    return 'http://127.0.0.1:4320';
+  }
+}
+
+function bridgeUrl() {
+  try {
+    return String(loadConfig().bridge?.url || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+  } catch {
+    return 'http://127.0.0.1:4319';
+  }
+}
+
+async function probe(url, path = '/health') {
+  try {
+    const res = await fetch(url + path, { signal: AbortSignal.timeout(2500) });
+    if (!res.ok) return { ok: false, reason: `HTTP ${res.status}` };
+    return { ok: true, data: await res.json().catch(() => ({})) };
+  } catch (e) {
+    return { ok: false, reason: e?.name === 'TimeoutError' ? 'no response' : (e?.message || 'unreachable') };
+  }
+}
+
+/**
+ * A structured picture of the local runtime — for the `local` command and for the gateway
+ * to log at startup. Pure except the two probes; the caller decides how to render it.
+ */
+export async function localStatus() {
+  const gwUrl = gatewayUrl();
+  const brUrl = bridgeUrl();
+  const [gw, br] = await Promise.all([probe(gwUrl), probe(brUrl)]);
+  const skills = br.ok ? await probe(brUrl, '/skills').then((r) => (r.ok ? (r.data.skills || []).length : null)).catch(() => null) : null;
+  return {
+    gateway: {
+      url: gwUrl,
+      running: gw.ok,
+      version: gw.ok ? gw.data.version : null,
+      tier: gw.ok ? gw.data.tier : null,
+      reason: gw.ok ? null : gw.reason,
+    },
+    bridge: {
+      url: brUrl,
+      running: br.ok,
+      version: br.ok ? br.data.version : null,
+      agents: br.ok ? (br.data.agents || []).filter((a) => a.available).length : null,
+      skills: skills ?? (br.ok ? br.data.skills?.count ?? null : null),
+      reason: br.ok ? null : br.reason,
+    },
+  };
+}
+
+/** Human-readable block for the CLI. */
+export function formatLocalStatus(s) {
+  const line = (name, m, extra) => {
+    const dot = m.running ? '●' : '○';
+    const head = m.running ? `${name}  running · v${m.version}` : `${name}  not running${m.reason ? ` (${m.reason})` : ''}`;
+    return `  ${dot} ${head}\n      ${extra}`;
+  };
+  const gw = line('Gateway', s.gateway, s.gateway.running
+    ? `Privacy layer: redaction, routing, voice. ${s.gateway.url}`
+    : `Optional upgrade (redaction, routing, voice). Start with: chatpanel-gateway --install`);
+  const brExtra = s.bridge.running
+    ? `Local agents & skills${s.bridge.agents != null ? ` · ${s.bridge.agents} agent(s)` : ''}${s.bridge.skills != null ? ` · ${s.bridge.skills} skill(s)` : ''}. ${s.bridge.url}`
+    : `Runs your local coding agents and skills. Start with: curl -fsSL https://dl.chatpanel.net/bridge/install.sh | bash`;
+  const br = line('Bridge', s.bridge, brExtra);
+  const summary = s.bridge.running && s.gateway.running
+    ? 'Both running — local traffic can route through the gateway\'s privacy layer.'
+    : s.bridge.running
+      ? 'Bridge up. The gateway is an optional upgrade.'
+      : s.gateway.running
+        ? 'Gateway up. Start the bridge to use local agents and skills.'
+        : 'Neither running.';
+  return `ChatPanel local\n\n${gw}\n\n${br}\n\n  ${summary}\n`;
+}
+
+/**
+ * One-line note for the gateway to log at startup, so the operator sees the unified picture
+ * without running anything. Never throws; a probe failure just says "not detected".
+ */
+export async function bridgePresenceNote() {
+  const br = await probe(bridgeUrl());
+  if (br.ok) {
+    const n = (br.data.skills?.count ?? null);
+    return `bridge detected at ${bridgeUrl()} (v${br.data.version}${n != null ? `, ${n} skills` : ''}) — its agents and skills are available through this gateway.`;
+  }
+  return `bridge not detected at ${bridgeUrl()} — local agents/skills are unavailable until it runs (curl -fsSL https://dl.chatpanel.net/bridge/install.sh | bash). The gateway runs fine without it.`;
+}

package/src/mcp.js

@@ -7,8 +7,15 @@
 // 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).
+//
+// The gateway is the SUPERSET (docs/bridge-gateway-unification.md, U2): this one MCP
+// server exposes both the gateway's warm history (chats/meetings/notes, redacted) AND the
+// bridge's on-disk skills — so a CLI adds ONE server and gets everything ChatPanel local
+// can do. History tools proxy to the gateway; skill tools proxy to the bridge. The bridge
+// is optional: if it is not running, the skill tools say so instead of failing the connect.
 
 import { loadConfig } from './config.js';
+import { readBridgeToken } from './bridge.js';
 
 const PROTOCOL_VERSION = '2024-11-05';
 const SERVER = { name: 'chatpanel-history', version: '1.0.0' };
@@ -25,6 +32,32 @@ function baseUrl() {
   return `http://127.0.0.1:${port}`;
 }
 
+// The bridge the gateway fronts. Its skills live on disk, so the skill tools proxy here
+// rather than through the gateway's history API.
+function bridgeBase() {
+  try {
+    return String(loadConfig().bridge?.url || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+  } catch {
+    return 'http://127.0.0.1:4319';
+  }
+}
+function bridgeToken() {
+  try {
+    return readBridgeToken(loadConfig().bridge?.token || '');
+  } catch {
+    return readBridgeToken('');
+  }
+}
+async function bridgeJson(path) {
+  const token = bridgeToken();
+  const res = await fetch(bridgeBase() + path, {
+    headers: { Accept: 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || data.ok === false) throw new Error(data?.error || `bridge ${res.status}`);
+  return data;
+}
+
 const TOOLS = [
   {
     name: 'search_history',
@@ -58,6 +91,32 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'list_skills',
+    description: 'List the reusable skills installed on this machine (via the ChatPanel bridge) — across every agent harness (Claude Code, Codex, Copilot, Gemini, Hermes) and any configured folder. Returns each skill\'s name and one-line description. Call open_skill to load the one that fits the task.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'open_skill',
+    description: 'Load one skill\'s full instructions by name (from list_skills), then follow them. If the instructions point at reference files, read one with read_skill_file.',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string', description: 'The skill name from list_skills.' } },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'read_skill_file',
+    description: 'Read one reference file a skill\'s instructions point at (any path inside the skill\'s own folder). Use only when the task needs it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'The skill name.' },
+        path: { type: 'string', description: 'The reference path as written in the instructions, e.g. references/auth.md.' },
+      },
+      required: ['name', 'path'],
+    },
+  },
 ];
 
 async function gatewayJson(path, init) {
@@ -91,6 +150,28 @@ async function callTool(name, args = {}) {
     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 (name === 'list_skills') {
+    let data;
+    try { data = await bridgeJson('/skills'); }
+    catch (e) { return `The ChatPanel bridge is not reachable (${e.message}), so installed skills are unavailable. Start it to use skills.`; }
+    const rows = data.skills || [];
+    if (!rows.length) return 'No skills installed on this machine yet.';
+    return [`${rows.length} skill(s) installed:`, ...rows.map((r) => `- ${r.command || r.id}: ${r.description || r.name}${r.origin?.source ? ` (from ${r.origin.source})` : ''}`)].join('\n') + '\n\nUse open_skill with a name to load its instructions.';
+  }
+  if (name === 'open_skill') {
+    let data;
+    try { data = await bridgeJson(`/skills/${encodeURIComponent(String(args.name || '').trim())}`); }
+    catch (e) { return `Could not open "${args.name}": ${e.message}`; }
+    return data.skill?.prompt || '(this skill has no extra instructions — just apply it.)';
+  }
+  if (name === 'read_skill_file') {
+    const skill = encodeURIComponent(String(args.name || '').trim());
+    const path = String(args.path || '').trim().split('/').map(encodeURIComponent).join('/');
+    let data;
+    try { data = await bridgeJson(`/skills/${skill}/file/${path}`); }
+    catch (e) { return `Could not read ${args.path}: ${e.message}`; }
+    return data.text || '(empty)';
+  }
   throw new Error(`unknown tool: ${name}`);
 }
 

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.33';
+export const VERSION = '0.6.35';
 
 // 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.
@@ -1013,6 +1013,13 @@ export function start(cfg = loadConfig()) {
   server.listen(cfg.port, cfg.host, () => {
     console.log(`ChatPanel Privacy Gateway v${VERSION} on http://${cfg.host}:${cfg.port}`);
     console.log(`  backend  : ${cfg.backend}` + (cfg.backend === 'bridge' ? ` (agent: ${cfg.bridge.agent}, via ${cfg.bridge.url})` : ''));
+    // U3: report the bridge at startup so the operator sees the unified picture without
+    // running anything. Detect only — never force-spawn a managed service. Best-effort and
+    // non-fatal: a probe failure just logs "not detected".
+    import('./local-status.js')
+      .then((m) => m.bridgePresenceNote())
+      .then((note) => console.log(`  bridge   : ${note}`))
+      .catch(() => {});
     console.log(`  redaction: ${cfg.redaction.tier}` + (cfg.redaction.detection?.backend && cfg.redaction.detection.backend !== 'off'
       ? ` + ${cfg.redaction.detection.backend} detector` : (cfg.ner?.autostart ? ' (+ NER starting…)' : '')));
     // M7: a non-loopback bind exposes the gateway on the LAN, where the per-request