@chatpanel/gateway 0.6.31 → 0.6.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.31",
+  "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.",
   "type": "module",
   "bin": {

package/src/backup-decrypt.js

@@ -1,12 +1,12 @@
 // Decrypt a ChatPanel backup envelope — the gateway counterpart to the extension's
 // crypto-backup.js. Same wire format so the gateway can read the user's own daily
 // encrypted backups (with the passphrase they hand off) even when the extension
-// isn't running. WebCrypto (PBKDF2 + AES-GCM) + zlib gunzip; no dependencies.
+// isn't running. WebCrypto (PBKDF2 + AES-GCM) + native zlib codecs; no dependencies.
 //
-// Envelope (v2): { type, version, kdf:{iterations,salt}, cipher:'AES-GCM',
-//   compression:'gzip'|'none'|absent, iv, ct }. v1 (no `compression`) → plaintext.
+// Envelope: { type, version, kdf:{iterations,salt}, cipher:'AES-GCM',
+//   compression:'brotli'|'gzip'|'none'|absent, iv, ct }.
 
-import { gunzipSync } from 'node:zlib';
+import { brotliDecompressSync, gunzipSync } from 'node:zlib';
 
 const ENCRYPTED_TYPE = 'chatpanel-backup-encrypted';
 const b64 = (s) => Buffer.from(String(s || ''), 'base64');
@@ -38,7 +38,8 @@ export async function decryptBackupEnvelope(envelope, passphrase) {
   } catch {
     throw new Error('wrong passphrase, or the backup file is corrupted');
   }
-  // v2 gzips before encrypting; v1 (no `compression` key) is plaintext JSON.
+  // v1 is plaintext, v2 gzip, v3 may use Brotli for a smaller portable file.
   if (envelope.compression === 'gzip') payload = new Uint8Array(gunzipSync(Buffer.from(payload)));
+  else if (envelope.compression === 'brotli') payload = new Uint8Array(brotliDecompressSync(Buffer.from(payload)));
   return JSON.parse(Buffer.from(payload).toString('utf8'));
 }

package/src/backup-ingest.js

@@ -15,7 +15,10 @@ import os from 'node:os';
 import { decryptBackupEnvelope } from './backup-decrypt.js';
 
 const BACKUP_DIR = process.env.CHATPANEL_BACKUP_DIR || join(os.homedir(), 'Downloads', 'ChatPanel Backups');
-const BACKUP_RE = /^chatpanel-backup-[A-Za-z]+\.encrypted\.json$/;
+// Current extension builds scope each weekday slot to a stable per-device id so
+// several machines can share one Drive account without overwriting one another.
+// Keep accepting the seven pre-0.19.4 legacy slots for recovery.
+const BACKUP_RE = /^chatpanel-backup-(?:[a-z0-9]{12,16}-)?(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat)\.encrypted\.json$/;
 
 // Newest chatpanel-backup-*.encrypted.json in the backups dir, or null.
 export function findLatestBackup(dir = BACKUP_DIR) {
@@ -33,6 +36,16 @@ export function findLatestBackup(dir = BACKUP_DIR) {
   }
 }
 
+export function findBackups(dir = BACKUP_DIR) {
+  try {
+    return readdirSync(dir)
+      .filter((f) => BACKUP_RE.test(f))
+      .map((f) => ({ path: join(dir, f), mtime: statSync(join(dir, f)).mtimeMs }))
+      .sort((a, b) => a.mtime - b.mtime)
+      .map((x) => x.path);
+  } catch { return []; }
+}
+
 // Decrypted backup data → warm records [{ id, text, title, type, date }].
 export function backupToRecords(data) {
   const out = [];
@@ -74,7 +87,7 @@ export function backupToRecords(data) {
 // Decrypt the latest (or given) backup and upsert its records into the store.
 // Returns { ok, ingested, size } or { ok:false, reason }. Never throws on a missing
 // file / passphrase; surfaces a decrypt failure as reason:'decrypt'.
-export async function ingestBackup(store, passphrase, { path } = {}) {
+export async function ingestBackup(store, passphrase, { path = '' } = {}) {
   const file = path || findLatestBackup();
   if (!file || !existsSync(file)) return { ok: false, reason: 'no-backup' };
   if (!passphrase) return { ok: false, reason: 'no-passphrase' };
@@ -88,3 +101,23 @@ export async function ingestBackup(store, passphrase, { path } = {}) {
   store.bulk({ upserts: records });
   return { ok: true, file, ingested: records.length, size: store.size };
 }
+
+export async function ingestBackups(store, passphrase, { dir = BACKUP_DIR } = {}) {
+  if (!passphrase) return { ok: false, reason: 'no-passphrase' };
+  const files = findBackups(dir);
+  if (!files.length) return { ok: false, reason: 'no-backup' };
+  const byId = new Map();
+  const accepted = [];
+  const errors = [];
+  for (const file of files) {
+    try {
+      const data = await decryptBackupEnvelope(JSON.parse(readFileSync(file, 'utf8')), passphrase);
+      for (const record of backupToRecords(data)) byId.set(record.id, record);
+      accepted.push(file);
+    } catch (e) { errors.push({ file, error: String(e?.message || e) }); }
+  }
+  if (!accepted.length) return { ok: false, reason: 'decrypt', error: errors[0]?.error || 'no backup matched the stored passphrase' };
+  const records = [...byId.values()];
+  store.bulk({ upserts: records });
+  return { ok: true, file: accepted.at(-1), files: accepted.length, skippedFiles: errors.length, ingested: records.length, size: store.size };
+}

package/src/configstore.js

@@ -66,6 +66,17 @@ export function publicConfig(cfg, { proUnlocked = false } = {}) {
   };
 }
 
+// Selecting a bundled NER model is an explicit request to use that detector, not
+// merely to remember its name. Older configs can carry autostart:false; leaving it
+// untouched makes the selected model work only until restart and then silently
+// falls back to deterministic-only redaction.
+export function applyNerModelSelection(cfg, id) {
+  cfg.ner = cfg.ner || { allowDownload: true, enableFullTier: true };
+  cfg.ner.model = id;
+  cfg.ner.autostart = true;
+  return cfg.ner;
+}
+
 // Merge an editable patch into the live cfg. Only known fields; ignores the rest.
 export function applyConfigPatch(cfg, patch = {}) {
   if (patch.backend === 'bridge' || patch.backend === 'api') cfg.backend = patch.backend;

package/src/history-store.js

@@ -13,7 +13,7 @@
 // tier, not this one. The file on disk is useless without the local key.
 
 import { randomBytes, createCipheriv, createDecipheriv } from 'node:crypto';
-import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import os from 'node:os';
 import { SearchIndex } from './search-index.js';
@@ -57,11 +57,16 @@ function decrypt(key, env) {
 // Kept separate from the records file: it's a credential, not corpus data, and the
 // gateway needs it before the store is even loaded (startup backup-ingest).
 export function saveBackupSecret(passphrase) {
+  if (!String(passphrase || '')) return clearBackupSecret();
   const env = encrypt(loadOrCreateKey(), Buffer.from(String(passphrase || ''), 'utf8'));
   mkdirSync(dirname(SECRET_PATH), { recursive: true });
   writeFileSync(SECRET_PATH, JSON.stringify(env), { mode: 0o600 });
 }
 
+export function clearBackupSecret() {
+  try { if (existsSync(SECRET_PATH)) unlinkSync(SECRET_PATH); } catch { /* best effort */ }
+}
+
 export function loadBackupSecret() {
   try {
     if (!existsSync(SECRET_PATH)) return '';
@@ -72,7 +77,7 @@ export function loadBackupSecret() {
 }
 
 export function hasBackupSecret() {
-  return existsSync(SECRET_PATH);
+  return !!loadBackupSecret();
 }
 
 // Records-plus-index with lazy, debounced encrypted persistence.

package/src/server.js

@@ -30,22 +30,22 @@ import { createRelaySession, getRelaySession, endRelaySession, pumpBridgeStream,
 import { shaperFor } from './shape.js';
 import { startNer } from './ner.js';
 import { installTimestampedConsole } from './log.js';
-import { saveBackupSecret, loadBackupSecret, hasBackupSecret } from './history-store.js';
+import { saveBackupSecret, clearBackupSecret, loadBackupSecret, hasBackupSecret } from './history-store.js';
 import { createHistoryStore } from './sqlite-store.js';
-import { ingestBackup } from './backup-ingest.js';
+import { ingestBackups } from './backup-ingest.js';
 import * as nerEngine from './ner-engine.js';
 import * as sttEngine from './stt-engine.js';
 import * as diarizeEngine from './diarize-engine.js';
 import { MODEL_CATALOG, isKnownModel, isValidCustomModelId } from './models.js';
 import { STT_MODEL_CATALOG, isKnownSttModel, isValidCustomSttId, DEFAULT_STT_MODEL, STT_DTYPES, isValidDtype } from './stt-models.js';
 import { resolvePro, checkQuota, consume, usage } from './freegate.js';
-import { publicConfig, applyConfigPatch, persistConfig, configPath } from './configstore.js';
+import { publicConfig, applyConfigPatch, applyNerModelSelection, persistConfig, configPath } from './configstore.js';
 import { resolveDestination, aggregateModelsAsync } from './router.js';
 import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.31';
+export const VERSION = '0.6.33';
 
 // 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.
@@ -518,6 +518,10 @@ export function createGateway(cfg = loadConfig()) {
     if ((pathname === '/config' || pathname === '/logs') && !isAdminAuthorized(req)) {
       return sendJson(res, 403, { error: 'admin route: extension origin or gateway token required' });
     }
+    if ((pathname === '/v1/history/key' || pathname === '/v1/history/ingest-backup')
+      && req.method === 'POST' && !isAdminAuthorized(req)) {
+      return sendJson(res, 403, { error: { message: 'history key route: extension origin or gateway token required', type: 'forbidden' } });
+    }
 
     if (req.method === 'GET' && pathname === '/health') {
       // `stt` is ADDITIVE (Tesla rule): old clients ignore it, new clients use it
@@ -603,19 +607,18 @@ export function createGateway(cfg = loadConfig()) {
     if (pathname === '/v1/history/key' && req.method === 'POST') {
       try {
         const body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')) || {};
-        saveBackupSecret(String(body.passphrase || ''));
-        const result = body.passphrase ? await ingestBackup(historyStore, String(body.passphrase)) : { ok: true, ingested: 0 };
+        if (body.passphrase) saveBackupSecret(String(body.passphrase)); else clearBackupSecret();
+        const result = body.passphrase ? await ingestBackups(historyStore, String(body.passphrase)) : { ok: true, ingested: 0 };
         return sendJson(res, 200, { ok: true, hasKey: !!body.passphrase, ...result });
       } catch (e) {
         return sendJson(res, 400, { error: { message: `key handoff failed: ${e.message}`, type: 'key_error' } });
       }
     }
-    // Trigger a backup-ingest now (uses the stored key). Optional { path } overrides
-    // which backup file to read. Returns how many records were seeded.
+    // Trigger an encrypted archive refresh now using the stored key. Every rotating
+    // weekday snapshot that matches the key contributes records; newest values win.
     if (pathname === '/v1/history/ingest-backup' && req.method === 'POST') {
       try {
-        const body = JSON.parse((await readBody(req, cfg.maxBodyBytes) || '{}').toString('utf8') || '{}') || {};
-        const result = await ingestBackup(historyStore, loadBackupSecret(), { path: body.path });
+        const result = await ingestBackups(historyStore, loadBackupSecret());
         return sendJson(res, result.ok ? 200 : 409, result);
       } catch (e) {
         return sendJson(res, 400, { error: { message: `backup ingest failed: ${e.message}`, type: 'ingest_error' } });
@@ -684,7 +687,7 @@ export function createGateway(cfg = loadConfig()) {
         if (!id || !(isKnownModel(id) || isValidCustomModelId(id))) return sendJson(res, 400, { error: { message: 'unknown or invalid model id', type: 'bad_model' } });
         // Persist first so a restart keeps the choice, then (re)load. Don't block the
         // response on a possibly-long download — the client polls GET for progress.
-        if (cfg.ner) cfg.ner.model = id; else cfg.ner = { autostart: true, model: id, allowDownload: true, enableFullTier: true };
+        applyNerModelSelection(cfg, id);
         try { persistConfig(cfg, configPath()); } catch { /* best effort */ }
         nerEngine.setModel(id, { onLog: (m) => console.log(m) }).then((ok) => {
           if (ok && cfg.ner?.enableFullTier && cfg.redaction.tier !== 'full') cfg.redaction.tier = 'full';
@@ -1019,11 +1022,11 @@ export function start(cfg = loadConfig()) {
       console.error(`⚠ SECURITY: gateway bound to NON-LOOPBACK host ${cfg.host}. It is reachable off-machine, and the loopback Host-header check is spoofable from the LAN. Admin routes still need the token/extension, but prefer binding 127.0.0.1 unless you intend LAN exposure on a trusted network.`);
     }
   });
-  // If the user handed off a backup key, refresh the warm store from the latest
-  // daily backup in the background — so the gateway stays current even when the
+  // If the user handed off a backup key, refresh the warm store from the encrypted
+  // rotating archive in the background — so the gateway stays current even when the
   // extension never runs. Best-effort; never blocks startup or crashes it.
   if (hasBackupSecret()) {
-    ingestBackup(historyStore, loadBackupSecret())
+    ingestBackups(historyStore, loadBackupSecret())
       .then((r) => { if (r?.ok) console.log(`  warm     : seeded ${r.ingested} records from ${r.file}`); })
       .catch(() => {});
   }

package/src/sqlite-store.js

@@ -15,7 +15,7 @@
 // via history-store.js's saveBackupSecret.
 
 import { join } from 'node:path';
-import { mkdirSync } from 'node:fs';
+import { mkdirSync, chmodSync, existsSync } from 'node:fs';
 import os from 'node:os';
 import { HistoryStore } from './history-store.js';
 
@@ -67,11 +67,19 @@ export class SqliteHistoryStore {
   }
 
   async init() {
-    if (this.path !== ':memory:') mkdirSync(DIR, { recursive: true });
+    if (this.path !== ':memory:') {
+      mkdirSync(DIR, { recursive: true, mode: 0o700 });
+      try { chmodSync(DIR, 0o700); } catch { /* non-POSIX */ }
+    }
     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')");
+    if (this.path !== ':memory:') {
+      for (const path of [this.path, this.path + '-wal', this.path + '-shm']) {
+        try { if (existsSync(path)) chmodSync(path, 0o600); } catch { /* best effort */ }
+      }
+    }
     return this;
   }