@chatpanel/gateway 0.6.76 → 0.6.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.76",
+  "version": "0.6.77",
   "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/prefs-store.js

@@ -0,0 +1,149 @@
+// CLIENT PREFERENCES — the settings every ChatPanel client shares, held here because the
+// gateway is the one address the extension and the desktop both have.
+//
+// A document of SECTIONS (the MCP server list, the skills, the search engines — see
+// @chatpanel/events/client-prefs.js), each stamped with when it was last written. A client
+// pushes the sections it changed with its own stamps; the store keeps the newer stamp per
+// section and tells the pusher which of its sections lost, so it can take the other side's
+// copy. Per-section last-writer-wins: a section is one screen a person edits, and merging two
+// edits of one list key by key would make a list neither of them made.
+//
+// ENCRYPTED AT REST with the same device key as memory and history — an MCP server entry can
+// carry an Authorization header, and this file must not be the plaintext copy of it.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import os from 'node:os';
+import { randomBytes, createCipheriv, createDecipheriv } from 'node:crypto';
+
+const DIR = join(os.homedir(), '.chatpanel');
+const STORE_PATH = process.env.CHATPANEL_PREFS_STORE || join(DIR, 'prefs-store.enc');
+const KEY_PATH = process.env.CHATPANEL_HISTORY_KEY || join(DIR, 'history-key');
+
+/** A section id is a short word; anything else is refused before it is stored. */
+const SECTION_ID_RE = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+/** One section's JSON, serialized — a list of a thousand MCP servers is not a preference. */
+const MAX_SECTION_BYTES = 512 * 1024;
+
+function loadOrCreateKey() {
+  try {
+    if (existsSync(KEY_PATH)) return Buffer.from(readFileSync(KEY_PATH, 'utf8').trim(), 'base64');
+  } catch { /* regenerate below */ }
+  const key = randomBytes(32);
+  mkdirSync(dirname(KEY_PATH), { recursive: true, mode: 0o700 });
+  writeFileSync(KEY_PATH, key.toString('base64'), { mode: 0o600 });
+  return key;
+}
+
+function encrypt(key, buf) {
+  const iv = randomBytes(12);
+  const cipher = createCipheriv('aes-256-gcm', key, iv);
+  const ct = Buffer.concat([cipher.update(buf), cipher.final()]);
+  return { v: 1, iv: iv.toString('base64'), tag: cipher.getAuthTag().toString('base64'), ct: ct.toString('base64') };
+}
+
+function decrypt(key, env) {
+  const d = createDecipheriv('aes-256-gcm', key, Buffer.from(env.iv, 'base64'));
+  d.setAuthTag(Buffer.from(env.tag, 'base64'));
+  return Buffer.concat([d.update(Buffer.from(env.ct, 'base64')), d.final()]);
+}
+
+export class PrefsStore {
+  constructor({ storePath = STORE_PATH } = {}) {
+    this.path = storePath;
+    this._key = null;
+    this.sections = {}; // id -> { value, updatedAt, by }
+    this.revision = 0;   // bumps on every accepted write, so a client can ask "anything new?"
+  }
+
+  load() {
+    this._key = loadOrCreateKey();
+    try {
+      if (existsSync(this.path)) {
+        const env = JSON.parse(readFileSync(this.path, 'utf8'));
+        const doc = JSON.parse(decrypt(this._key, env).toString('utf8'));
+        this.sections = doc?.sections && typeof doc.sections === 'object' ? doc.sections : {};
+        this.revision = Number(doc?.revision) || 0;
+      }
+    } catch {
+      // An unreadable store is an empty one, never a crash: the clients still hold their own
+      // copies and will push them back on the next change.
+      this.sections = {};
+      this.revision = 0;
+    }
+    return this;
+  }
+
+  save() {
+    mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+    const env = encrypt(this._key, Buffer.from(JSON.stringify({ v: 1, revision: this.revision, sections: this.sections }), 'utf8'));
+    // Write beside, then rename: a crash mid-write leaves the old file, not half of a new one.
+    const tmp = `${this.path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(env), { mode: 0o600 });
+    renameSync(tmp, this.path);
+  }
+
+  /** Every section, or one. Values are the caller's to keep — they are copies. */
+  get(id = '') {
+    if (id) {
+      const s = this.sections[id];
+      return s ? { [id]: { value: clone(s.value), updatedAt: s.updatedAt, by: s.by || '' } } : {};
+    }
+    const out = {};
+    for (const [k, s] of Object.entries(this.sections)) out[k] = { value: clone(s.value), updatedAt: s.updatedAt, by: s.by || '' };
+    return out;
+  }
+
+  /** Just the stamps — enough for a client to decide whether it needs the values. */
+  stamps() {
+    const out = {};
+    for (const [k, s] of Object.entries(this.sections)) out[k] = s.updatedAt;
+    return out;
+  }
+
+  /**
+   * Merge a client's stamped sections in. A section is taken when its stamp is newer than
+   * the one held (or nothing is held); otherwise the client is told it lost and gets the
+   * held copy back. Returns `{ applied, kept, sections }` where `sections` holds the current
+   * copies of everything the client sent — the client writes `kept` ones over its own.
+   */
+  put(incoming, { by = '' } = {}) {
+    const applied = [];
+    const kept = [];
+    const sections = {};
+    for (const [id, entry] of Object.entries(incoming || {})) {
+      if (!SECTION_ID_RE.test(id)) continue;
+      const updatedAt = Number(entry?.updatedAt) || 0;
+      if (!updatedAt || entry?.value === undefined) continue;
+      let bytes;
+      try { bytes = Buffer.byteLength(JSON.stringify(entry.value), 'utf8'); } catch { continue; }
+      if (bytes > MAX_SECTION_BYTES) continue;
+      const held = this.sections[id];
+      if (!held || updatedAt > held.updatedAt) {
+        this.sections[id] = { value: clone(entry.value), updatedAt, by: String(by || '').slice(0, 40) };
+        applied.push(id);
+      } else {
+        kept.push(id);
+      }
+      const cur = this.sections[id];
+      sections[id] = { value: clone(cur.value), updatedAt: cur.updatedAt, by: cur.by || '' };
+    }
+    if (applied.length) { this.revision += 1; this.save(); }
+    return { applied, kept, sections, revision: this.revision };
+  }
+
+  /** Forget one section entirely — the user removed the feature's settings, not just emptied them. */
+  remove(id) {
+    if (!this.sections[id]) return false;
+    delete this.sections[id];
+    this.revision += 1;
+    this.save();
+    return true;
+  }
+}
+
+const clone = (v) => (v === undefined ? undefined : JSON.parse(JSON.stringify(v)));
+
+export function createPrefsStore(opts) {
+  return new PrefsStore(opts).load();
+}

package/src/server.js

@@ -33,6 +33,7 @@ import { startNer, ensureNer } from './ner.js';
 import { installTimestampedConsole } from './log.js';
 import { saveBackupSecret, clearBackupSecret, loadBackupSecret, hasBackupSecret } from './history-store.js';
 import { createMemoryStore } from './memory-store.js';
+import { createPrefsStore } from './prefs-store.js';
 import { createHistoryStore } from './sqlite-store.js';
 import { ingestBackups } from './backup-ingest.js';
 import * as nerEngine from './ner-engine.js';
@@ -56,7 +57,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.76';
+export const VERSION = '0.6.77';
 
 // 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.
@@ -64,6 +65,7 @@ export const VERSION = '0.6.76';
 // See docs/architecture-data-tiers.
 const historyStore = await createHistoryStore();
 const memoryStore = await createMemoryStore();
+const prefsStore = createPrefsStore();
 
 // OBSERVABILITY — a ring of "which agent read what, when", persisted across restarts (the
 // gateway updates often; an empty panel after each restart reads as "nothing is set up").
@@ -128,7 +130,7 @@ function originAllowed(origin, cfg) {
 
 function setCors(res, origin) {
   res.setHeader('Access-Control-Allow-Origin', origin || '*');
-  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
   res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-ChatPanel-Token');
   res.setHeader('Vary', 'Origin');
 }
@@ -693,6 +695,12 @@ export function createGateway(cfg = loadConfig()) {
       && req.method === 'POST' && !isAdminAuthorized(req)) {
       return sendJson(res, 403, { error: { message: 'memory write — extension origin or gateway token required', type: 'forbidden' } });
     }
+    // Client preferences travel between the extension and the desktop through here, and an
+    // MCP server entry can carry an Authorization header — so READS are gated too, unlike
+    // history and memory. A drive-by page must not learn what tools the user connected.
+    if (pathname === '/v1/prefs' && !isAdminAuthorized(req)) {
+      return sendJson(res, 403, { error: { message: 'prefs: extension origin or gateway token required', type: 'forbidden' } });
+    }
     // The access log is who-read-what — sensitive, and writable only by the local MCP
     // process (which sends the gateway token). Extension Origin or token for both the
     // read (dashboard) and the report (MCP child); a drive-by page has neither.
@@ -764,6 +772,29 @@ export function createGateway(cfg = loadConfig()) {
         return sendJson(res, 400, { error: { message: `ingest failed: ${e.message}`, type: 'ingest_error' } });
       }
     }
+    // --- CLIENT PREFERENCES — the settings every client shares (prefs-store.js).
+    //   GET  /v1/prefs[?section=id][&stamps=1] → { ok, revision, sections: { id: { value, updatedAt, by } } }
+    //   POST /v1/prefs { sections: { id: { value, updatedAt } }, by } → { ok, revision, applied, kept, sections }
+    //   DELETE /v1/prefs?section=id → { ok, removed }
+    if (pathname === '/v1/prefs' && req.method === 'GET') {
+      const section = String(url.searchParams.get('section') || '');
+      if (url.searchParams.get('stamps')) return sendJson(res, 200, { ok: true, revision: prefsStore.revision, stamps: prefsStore.stamps() });
+      return sendJson(res, 200, { ok: true, revision: prefsStore.revision, sections: prefsStore.get(section) });
+    }
+    if (pathname === '/v1/prefs' && (req.method === 'POST' || req.method === 'PUT')) {
+      try {
+        const body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')) || {};
+        const out = prefsStore.put(body.sections || {}, { by: body.by || '' });
+        return sendJson(res, 200, { ok: true, ...out });
+      } catch (e) {
+        return sendJson(res, 400, { error: { message: `prefs write failed: ${e.message}`, type: 'prefs_error' } });
+      }
+    }
+    if (pathname === '/v1/prefs' && req.method === 'DELETE') {
+      const section = String(url.searchParams.get('section') || '');
+      return sendJson(res, 200, { ok: true, removed: section ? prefsStore.remove(section) : false });
+    }
+
     // --- MEMORY. Small, durable facts about the user, reachable by every local agent.
     //   GET  /v1/memory/list                      → { memories }
     //   POST /v1/memory/recall  { text, scopes }  → { memories, block }