cli-chat-mcp 0.2.0 → 0.3.1

package/README.md

@@ -17,9 +17,12 @@ agent surfaces the message and helps them reply.
 See [PLAN.md](./PLAN.md) for the full concept and roadmap.
 
 ## Requirements
-Node 22.6+ (uses built-in `node:sqlite`). That's all an end user needs — `npx`
-fetches the rest. State (identity, contacts, inbox cache) lives in `~/.cli-chat`,
-not next to the code, so it survives across `npx` runs.
+Node 22+ (uses the native global `WebSocket` for push). The inbox cache picks its
+SQLite driver automatically: native `node:sqlite` on Node 24+ (one shared WAL
+handle), falling back to `node-sqlite3-wasm` — WebAssembly SQLite, no native build
+— on Node 22/23. That's all an end user needs — `npx` fetches the rest. State
+(identity, contacts, inbox cache) lives in `~/.cli-chat`, not next to the code, so
+it survives across `npx` runs.
 
 ## Set up to message someone (no clone)
 

package/dist/check-inbox.js

@@ -52,62 +52,163 @@ function displayNameByKey(book, signPub) {
 }
 
 // src/db.ts
-import { DatabaseSync } from "node:sqlite";
-function openMailbox(path) {
-  const db = new DatabaseSync(path);
+import { createRequire } from "node:module";
+import sqlite from "node-sqlite3-wasm";
+var { Database: WasmDatabase } = sqlite;
+var nodeMajor = Number(process.versions.node.split(".")[0]);
+var forcedDriver = process.env.MESSENGER_DB_DRIVER?.trim().toLowerCase();
+function loadNative() {
   try {
-    db.exec(`PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 3000;`);
+    return createRequire(import.meta.url)("node:sqlite").DatabaseSync;
   } catch {
+    return void 0;
   }
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS messages (
-      id          TEXT PRIMARY KEY,
-      recipient   TEXT NOT NULL,
-      sender      TEXT NOT NULL,
-      body        TEXT NOT NULL,
-      tags        TEXT,
-      created_at  INTEGER NOT NULL,
-      fetched_at  INTEGER,
-      read_at     INTEGER,
-      in_reply_to TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_recipient ON messages (recipient, created_at);
-  `);
+}
+var NativeDatabase = nodeMajor >= 24 || forcedDriver === "native" ? loadNative() : void 0;
+function chooseDriver() {
+  if (forcedDriver === "wasm") return "wasm";
+  if (forcedDriver === "native") return NativeDatabase ? "native" : "wasm";
+  return NativeDatabase ? "native" : "wasm";
+}
+var SCHEMA = `
+  CREATE TABLE IF NOT EXISTS messages (
+    id          TEXT PRIMARY KEY,
+    recipient   TEXT NOT NULL,
+    sender      TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    tags        TEXT,
+    created_at  INTEGER NOT NULL,
+    fetched_at  INTEGER,
+    read_at     INTEGER,
+    in_reply_to TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_recipient ON messages (recipient, created_at);
+`;
+var NativeStore = class {
+  #db;
+  constructor(path) {
+    const Db = NativeDatabase;
+    this.#db = new Db(path);
+    try {
+      this.#db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+    } catch {
+    }
+    this.#db.exec(SCHEMA);
+  }
+  run(sql, params = []) {
+    this.#db.prepare(sql).run(...params);
+  }
+  all(sql, params = []) {
+    return this.#db.prepare(sql).all(...params);
+  }
+  get(sql, params = []) {
+    return this.#db.prepare(sql).get(...params) ?? void 0;
+  }
+  close() {
+    this.#db.close();
+  }
+};
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function withRetry(fn, attempts = 6) {
+  let delay = 15;
+  for (let i = 0; ; i++) {
+    try {
+      return fn();
+    } catch (e) {
+      const msg = String(e?.message ?? e);
+      const retriable = /unable to open|database is locked|database table is locked|is busy/i.test(msg);
+      if (!retriable || i >= attempts) throw e;
+      sleepSync(delay);
+      delay = Math.min(delay * 2, 200);
+    }
+  }
+}
+function openWasm(path) {
+  const db = new WasmDatabase(path);
+  try {
+    db.exec("PRAGMA busy_timeout = 4000;");
+  } catch {
+  }
+  db.exec(SCHEMA);
   return db;
 }
+var WasmMemoryStore = class {
+  #db;
+  constructor(path) {
+    this.#db = openWasm(path);
+  }
+  run(sql, params = []) {
+    this.#db.run(sql, params);
+  }
+  all(sql, params = []) {
+    return this.#db.all(sql, params);
+  }
+  get(sql, params = []) {
+    return this.#db.get(sql, params) ?? void 0;
+  }
+  close() {
+    this.#db.close();
+  }
+};
+var WasmPerOpStore = class {
+  #path;
+  constructor(path) {
+    this.#path = path;
+  }
+  #with(fn) {
+    return withRetry(() => {
+      const db = openWasm(this.#path);
+      try {
+        return fn(db);
+      } finally {
+        db.close();
+      }
+    });
+  }
+  run(sql, params = []) {
+    this.#with((db) => db.run(sql, params));
+  }
+  all(sql, params = []) {
+    return this.#with((db) => db.all(sql, params));
+  }
+  get(sql, params = []) {
+    return this.#with((db) => db.get(sql, params)) ?? void 0;
+  }
+  close() {
+  }
+};
+function openMailbox(path) {
+  if (chooseDriver() === "native") return new NativeStore(path);
+  if (path === ":memory:") return new WasmMemoryStore(path);
+  return new WasmPerOpStore(path);
+}
 function insertMessage(db, m) {
-  db.prepare(
+  db.run(
     `INSERT INTO messages
        (id, recipient, sender, body, tags, created_at, fetched_at, read_at, in_reply_to)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    m.id,
-    m.recipient,
-    m.sender,
-    m.body,
-    m.tags,
-    m.created_at,
-    m.fetched_at,
-    m.read_at,
-    m.in_reply_to
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [m.id, m.recipient, m.sender, m.body, m.tags, m.created_at, m.fetched_at, m.read_at, m.in_reply_to]
   );
 }
 function unreadFor(db, me) {
-  return db.prepare(
+  return db.all(
     `SELECT * FROM messages
        WHERE recipient = ? AND read_at IS NULL
-       ORDER BY created_at ASC`
-  ).all(me);
+       ORDER BY created_at ASC`,
+    [me]
+  );
 }
 function getMessage(db, id) {
-  return db.prepare(`SELECT * FROM messages WHERE id = ?`).get(id);
+  return db.get(`SELECT * FROM messages WHERE id = ?`, [id]) ?? void 0;
 }
 function markRead(db, id, now) {
-  db.prepare(`UPDATE messages SET read_at = ?, fetched_at = COALESCE(fetched_at, ?) WHERE id = ?`).run(
+  db.run(`UPDATE messages SET read_at = ?, fetched_at = COALESCE(fetched_at, ?) WHERE id = ?`, [
     now,
     now,
     id
-  );
+  ]);
 }
 
 // src/canonical.ts

package/dist/server-net.js

@@ -89,62 +89,163 @@ function contactByKey(book, signPub) {
 }
 
 // src/db.ts
-import { DatabaseSync } from "node:sqlite";
-function openMailbox(path) {
-  const db = new DatabaseSync(path);
+import { createRequire } from "node:module";
+import sqlite from "node-sqlite3-wasm";
+var { Database: WasmDatabase } = sqlite;
+var nodeMajor = Number(process.versions.node.split(".")[0]);
+var forcedDriver = process.env.MESSENGER_DB_DRIVER?.trim().toLowerCase();
+function loadNative() {
   try {
-    db.exec(`PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 3000;`);
+    return createRequire(import.meta.url)("node:sqlite").DatabaseSync;
   } catch {
+    return void 0;
   }
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS messages (
-      id          TEXT PRIMARY KEY,
-      recipient   TEXT NOT NULL,
-      sender      TEXT NOT NULL,
-      body        TEXT NOT NULL,
-      tags        TEXT,
-      created_at  INTEGER NOT NULL,
-      fetched_at  INTEGER,
-      read_at     INTEGER,
-      in_reply_to TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_recipient ON messages (recipient, created_at);
-  `);
+}
+var NativeDatabase = nodeMajor >= 24 || forcedDriver === "native" ? loadNative() : void 0;
+function chooseDriver() {
+  if (forcedDriver === "wasm") return "wasm";
+  if (forcedDriver === "native") return NativeDatabase ? "native" : "wasm";
+  return NativeDatabase ? "native" : "wasm";
+}
+var SCHEMA = `
+  CREATE TABLE IF NOT EXISTS messages (
+    id          TEXT PRIMARY KEY,
+    recipient   TEXT NOT NULL,
+    sender      TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    tags        TEXT,
+    created_at  INTEGER NOT NULL,
+    fetched_at  INTEGER,
+    read_at     INTEGER,
+    in_reply_to TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_recipient ON messages (recipient, created_at);
+`;
+var NativeStore = class {
+  #db;
+  constructor(path) {
+    const Db = NativeDatabase;
+    this.#db = new Db(path);
+    try {
+      this.#db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+    } catch {
+    }
+    this.#db.exec(SCHEMA);
+  }
+  run(sql, params = []) {
+    this.#db.prepare(sql).run(...params);
+  }
+  all(sql, params = []) {
+    return this.#db.prepare(sql).all(...params);
+  }
+  get(sql, params = []) {
+    return this.#db.prepare(sql).get(...params) ?? void 0;
+  }
+  close() {
+    this.#db.close();
+  }
+};
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function withRetry(fn, attempts = 6) {
+  let delay = 15;
+  for (let i = 0; ; i++) {
+    try {
+      return fn();
+    } catch (e) {
+      const msg = String(e?.message ?? e);
+      const retriable = /unable to open|database is locked|database table is locked|is busy/i.test(msg);
+      if (!retriable || i >= attempts) throw e;
+      sleepSync(delay);
+      delay = Math.min(delay * 2, 200);
+    }
+  }
+}
+function openWasm(path) {
+  const db = new WasmDatabase(path);
+  try {
+    db.exec("PRAGMA busy_timeout = 4000;");
+  } catch {
+  }
+  db.exec(SCHEMA);
   return db;
 }
+var WasmMemoryStore = class {
+  #db;
+  constructor(path) {
+    this.#db = openWasm(path);
+  }
+  run(sql, params = []) {
+    this.#db.run(sql, params);
+  }
+  all(sql, params = []) {
+    return this.#db.all(sql, params);
+  }
+  get(sql, params = []) {
+    return this.#db.get(sql, params) ?? void 0;
+  }
+  close() {
+    this.#db.close();
+  }
+};
+var WasmPerOpStore = class {
+  #path;
+  constructor(path) {
+    this.#path = path;
+  }
+  #with(fn) {
+    return withRetry(() => {
+      const db = openWasm(this.#path);
+      try {
+        return fn(db);
+      } finally {
+        db.close();
+      }
+    });
+  }
+  run(sql, params = []) {
+    this.#with((db) => db.run(sql, params));
+  }
+  all(sql, params = []) {
+    return this.#with((db) => db.all(sql, params));
+  }
+  get(sql, params = []) {
+    return this.#with((db) => db.get(sql, params)) ?? void 0;
+  }
+  close() {
+  }
+};
+function openMailbox(path) {
+  if (chooseDriver() === "native") return new NativeStore(path);
+  if (path === ":memory:") return new WasmMemoryStore(path);
+  return new WasmPerOpStore(path);
+}
 function insertMessage(db, m) {
-  db.prepare(
+  db.run(
     `INSERT INTO messages
        (id, recipient, sender, body, tags, created_at, fetched_at, read_at, in_reply_to)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    m.id,
-    m.recipient,
-    m.sender,
-    m.body,
-    m.tags,
-    m.created_at,
-    m.fetched_at,
-    m.read_at,
-    m.in_reply_to
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [m.id, m.recipient, m.sender, m.body, m.tags, m.created_at, m.fetched_at, m.read_at, m.in_reply_to]
   );
 }
 function unreadFor(db, me) {
-  return db.prepare(
+  return db.all(
     `SELECT * FROM messages
        WHERE recipient = ? AND read_at IS NULL
-       ORDER BY created_at ASC`
-  ).all(me);
+       ORDER BY created_at ASC`,
+    [me]
+  );
 }
 function getMessage(db, id) {
-  return db.prepare(`SELECT * FROM messages WHERE id = ?`).get(id);
+  return db.get(`SELECT * FROM messages WHERE id = ?`, [id]) ?? void 0;
 }
 function markRead(db, id, now2) {
-  db.prepare(`UPDATE messages SET read_at = ?, fetched_at = COALESCE(fetched_at, ?) WHERE id = ?`).run(
+  db.run(`UPDATE messages SET read_at = ?, fetched_at = COALESCE(fetched_at, ?) WHERE id = ?`, [
     now2,
     now2,
     id
-  );
+  ]);
 }
 
 // src/canonical.ts
@@ -353,6 +454,9 @@ function resolveDir(sel) {
   }
   return null;
 }
+function resolveIdentity(sel) {
+  return resolveDir(sel);
+}
 function currentUser() {
   const env = process.env.MESSENGER_USER?.trim();
   if (env) return resolveDir(env) ?? env;
@@ -375,6 +479,9 @@ function resolveMailboxUrl() {
   return process.env.MESSENGER_MAILBOX_URL?.trim() || DEFAULT_MAILBOX_URL;
 }
 
+// src/warmer.ts
+import { execFile } from "node:child_process";
+
 // src/core-net.ts
 import { randomUUID } from "node:crypto";
 import { writeFileSync as writeFileSync2 } from "node:fs";
@@ -510,6 +617,113 @@ async function draftReply(ctx, args) {
   return { ok: true, id, to: { name: c.name, signPub: c.signPub } };
 }
 
+// src/warmer.ts
+var PING_MS = 3e4;
+var POLL_MS = 6e4;
+var BACKOFF_START_MS = 1e3;
+var BACKOFF_MAX_MS = 3e4;
+function startWarmer(ctx, opts) {
+  const wsUrl = opts.mailboxUrl.replace(/^http/, "ws").replace(/\/$/, "") + "/connect";
+  let ws = null;
+  let stopped = false;
+  let backoff = BACKOFF_START_MS;
+  let pingTimer = null;
+  let reconnectTimer = null;
+  let draining = false;
+  async function drain() {
+    if (draining || stopped) return;
+    draining = true;
+    try {
+      const added = await sync(ctx);
+      if (added > 0) notifyNewMail(ctx);
+    } catch {
+    } finally {
+      draining = false;
+    }
+  }
+  function clearPing() {
+    if (pingTimer) {
+      clearInterval(pingTimer);
+      pingTimer = null;
+    }
+  }
+  function connect() {
+    if (stopped) return;
+    const h = makeAuthHeaders(ctx.me.signPub, ctx.me.signSec, "GET", "/connect", "", opts.now());
+    const u = new URL(wsUrl);
+    u.searchParams.set("x-pubkey", h["x-pubkey"]);
+    u.searchParams.set("x-timestamp", h["x-timestamp"]);
+    u.searchParams.set("x-signature", h["x-signature"]);
+    ws = new WebSocket(u.toString());
+    ws.addEventListener("open", () => {
+      backoff = BACKOFF_START_MS;
+      void drain();
+      clearPing();
+      pingTimer = setInterval(() => {
+        try {
+          ws?.send("ping");
+        } catch {
+        }
+      }, PING_MS);
+    });
+    ws.addEventListener("message", (ev) => {
+      if (String(ev.data) === "pong") return;
+      void drain();
+    });
+    ws.addEventListener("close", scheduleReconnect);
+    ws.addEventListener("error", () => {
+      try {
+        ws?.close();
+      } catch {
+      }
+    });
+  }
+  function scheduleReconnect() {
+    clearPing();
+    if (stopped) return;
+    const jitter = Math.floor(backoff * 0.3 * Math.random());
+    reconnectTimer = setTimeout(connect, backoff + jitter);
+    backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+  }
+  connect();
+  const pollTimer = setInterval(() => void drain(), POLL_MS);
+  return function stop() {
+    stopped = true;
+    clearInterval(pollTimer);
+    clearPing();
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    try {
+      ws?.close();
+    } catch {
+    }
+  };
+}
+function notifyNewMail(ctx) {
+  if (process.env.MESSENGER_NOTIFY !== "1") return;
+  const unread = unreadFor(ctx.cache, ctx.me.signPub);
+  const latest = unread[unread.length - 1];
+  if (!latest) return;
+  const from = displayNameByKey(ctx.book, latest.sender);
+  const title = "New message";
+  const body = `${from}: ${latest.body.slice(0, 80)}`;
+  try {
+    process.stdout.write("\x07");
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    const safe = (s2) => s2.replace(/["\\]/g, " ");
+    execFile(
+      "osascript",
+      ["-e", `display notification "${safe(body)}" with title "${safe(title)}"`],
+      () => {
+      }
+    );
+  } else if (process.platform === "linux") {
+    execFile("notify-send", [title, body], () => {
+    });
+  }
+}
+
 // src/server-net.ts
 var mailboxUrl = resolveMailboxUrl();
 var now = () => Date.now();
@@ -520,7 +734,15 @@ function buildSession(user) {
   const contactsPath = contactsFile(user);
   const me = loadIdentity(identityFile(user));
   const book = loadContacts(contactsPath);
-  const cache = openMailbox(inboxFile(user));
+  let cache;
+  try {
+    cache = openMailbox(inboxFile(user));
+  } catch (e) {
+    console.error(
+      `Inbox cache for "${user}" is unavailable (${e.message}); using a temporary in-memory cache for this session.`
+    );
+    cache = openMailbox(":memory:");
+  }
   const ctx = {
     me,
     book,
@@ -540,6 +762,16 @@ if (existing) {
     console.error(`Found user "${existing}" but couldn't load identity: ${e.message}`);
   }
 }
+var stopWarmer = null;
+function ensureWarmer() {
+  if (process.env.MESSENGER_PUSH === "0") return;
+  if (stopWarmer) {
+    stopWarmer();
+    stopWarmer = null;
+  }
+  if (S) stopWarmer = startWarmer(S.ctx, { mailboxUrl, now });
+}
+ensureWarmer();
 async function claimHandle(client) {
   for (let i = 0; i < 8; i++) {
     const candidate = randomHandle(randomBytes(8));
@@ -655,6 +887,23 @@ server.registerTool(
       });
     }
     const display = (name ?? process.env.MESSENGER_USER ?? userInfo().username ?? "me").trim() || "me";
+    const pin = process.env.MESSENGER_USER?.trim();
+    for (const sel of [name?.trim(), pin].filter((s2) => !!s2)) {
+      const dir = resolveIdentity(sel);
+      if (dir) {
+        S = buildSession(dir);
+        if (!pin) setCurrentUser(dir);
+        ensureWarmer();
+        return ok({
+          ok: true,
+          created: false,
+          name: S.me.name,
+          handle: S.me.handle,
+          fullKey: encodeKey(S.me.signPub, S.me.boxPub),
+          note: "You already have an account \u2014 this is your code to share."
+        });
+      }
+    }
     const id = generateIdentity();
     id.name = display;
     id.handle = await claimHandle(createMailboxClient(mailboxUrl, id, now));
@@ -664,8 +913,9 @@ server.registerTool(
       contactsFile(id.handle),
       JSON.stringify({ me: id.signPub, contacts: [] }, null, 2) + "\n"
     );
-    setCurrentUser(id.handle);
+    if (!process.env.MESSENGER_USER?.trim()) setCurrentUser(id.handle);
     S = buildSession(id.handle);
+    ensureWarmer();
     return ok({
       ok: true,
       created: true,
@@ -752,9 +1002,10 @@ server.registerTool(
     const deadline = now() + WATCH_MS;
     const progressToken = extra?._meta?.progressToken;
     let ticks = 0;
+    await sync(S.ctx);
+    let sinceSync = 0;
     for (; ; ) {
       if (extra?.signal?.aborted) return ok({ status: "idle", count: 0, note: "Watch cancelled." });
-      await sync(S.ctx);
       const rows = unreadFor(S.cache, S.me.signPub);
       if (rows.length > 0) {
         const messages = rows.map((m) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-chat-mcp",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "Headless cross-CLI messenger for coding agents (MCP)",
   "bin": {
@@ -11,7 +11,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=22.6.0"
+    "node": ">=22"
   },
   "scripts": {
     "build": "node build.mjs",
@@ -22,19 +22,21 @@
     "test:coverage": "node --test --experimental-test-coverage \"test/unit/*.test.ts\" \"test/integration/*.test.ts\"",
     "test:e2e": "node test/e2e/live-net.ts",
     "test:mcp": "node test/e2e/live-net-mcp.ts",
+    "test:push": "node test/e2e/live-push.ts",
     "init": "node src/init-identity.ts",
     "migrate": "node src/migrate.ts",
     "install-clis": "node src/install.ts",
     "add-contact": "node src/add-contact.ts",
     "mailbox": "node server-mailbox/node.ts",
     "server": "node src/server-net.ts",
-    "deploy": "wrangler deploy"
+    "deploy": "npx wrangler deploy"
   },
   "dependencies": {
     "@hono/node-server": "^2.0.5",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "hono": "^4.12.25",
     "libsodium-wrappers": "^0.8.4",
+    "node-sqlite3-wasm": "^0.8.58",
     "zod": "^3.23.8"
   },
   "devDependencies": {