feat(node): add TypeScript sibling project for npm-based install

Introduces @kuns/claude-mailbox under node/, a wire-compatible TypeScript
port of the .NET daemon that distributes via the public Gitea npm registry.
The .NET project stays in src/ClaudeMailbox/ untouched; users pick whichever
flavor they prefer.

- node/ project: fastify + @modelcontextprotocol/sdk StreamableHTTPServerTransport
  + better-sqlite3, schema and wire surface match the C# version (port 47822,
  X-Mailbox header, MCP tool names, snake_case SQLite columns)
- Cross-platform autostart: Scheduled Task (Win, no admin) / Windows Service
  (Win, --service) / launchd (mac) / systemd --user (linux)
- 9/9 vitest tests pass; end-to-end /health + send/check round-trip verified
- CI split: existing ci.yml/release.yml renamed to *-dotnet.yml with path
  filters, new ci-node.yml and release-node.yml publish to Gitea npm registry
- install.ps1 / install.sh bootstrap one-liners at repo root; homebrew/
  contains a tap formula template
- README install section reordered: npm path primary, dotnet publish secondary

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

node/src/db.ts

@@ -0,0 +1,182 @@
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+export interface MailboxRow {
+  name: string;
+  created_at: string;
+  last_seen_at: string;
+}
+
+export interface MessageRow {
+  id: number;
+  to_mailbox: string;
+  from_mailbox: string;
+  body: string;
+  created_at: string;
+  delivered_at: string | null;
+}
+
+export interface InboxStatus {
+  pending: number;
+  oldestAt: Date | null;
+}
+
+export interface MailboxInfo {
+  name: string;
+  lastSeenAt: Date;
+  pendingForYou: number;
+}
+
+const DDL_STATEMENTS: string[] = [
+  `CREATE TABLE IF NOT EXISTS mailboxes (
+     name          TEXT NOT NULL PRIMARY KEY,
+     created_at    TEXT NOT NULL,
+     last_seen_at  TEXT NOT NULL
+   )`,
+  `CREATE TABLE IF NOT EXISTS messages (
+     id            INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+     to_mailbox    TEXT NOT NULL REFERENCES mailboxes(name) ON DELETE RESTRICT,
+     from_mailbox  TEXT NOT NULL REFERENCES mailboxes(name) ON DELETE RESTRICT,
+     body          TEXT NOT NULL,
+     created_at    TEXT NOT NULL,
+     delivered_at  TEXT NULL
+   )`,
+  `CREATE INDEX IF NOT EXISTS ix_messages_to_delivered
+     ON messages (to_mailbox, delivered_at)`,
+];
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function parseDate(s: string | null | undefined): Date | null {
+  if (!s) return null;
+  const normalized = s.includes("T") ? s : s.replace(" ", "T") + (s.endsWith("Z") ? "" : "Z");
+  const d = new Date(normalized);
+  return isNaN(d.getTime()) ? null : d;
+}
+
+export class MailboxStore {
+  private readonly db: Database.Database;
+
+  private readonly stmts: {
+    findMailbox: Database.Statement;
+    insertMailbox: Database.Statement;
+    touchMailbox: Database.Statement;
+    listMailboxes: Database.Statement;
+    insertMessage: Database.Statement;
+    countPending: Database.Statement;
+    oldestPending: Database.Statement;
+    selectPending: Database.Statement;
+    markDelivered: Database.Statement;
+    pendingByRecipient: Database.Statement;
+  };
+
+  constructor(public readonly dbPath: string) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    for (const sql of DDL_STATEMENTS) this.db.prepare(sql).run();
+
+    this.stmts = {
+      findMailbox: this.db.prepare("SELECT * FROM mailboxes WHERE name = ?"),
+      insertMailbox: this.db.prepare(
+        "INSERT INTO mailboxes (name, created_at, last_seen_at) VALUES (?, ?, ?)",
+      ),
+      touchMailbox: this.db.prepare("UPDATE mailboxes SET last_seen_at = ? WHERE name = ?"),
+      listMailboxes: this.db.prepare("SELECT * FROM mailboxes ORDER BY name"),
+      insertMessage: this.db.prepare(
+        "INSERT INTO messages (to_mailbox, from_mailbox, body, created_at, delivered_at) VALUES (?, ?, ?, ?, NULL)",
+      ),
+      countPending: this.db.prepare(
+        "SELECT COUNT(*) AS n FROM messages WHERE to_mailbox = ? AND delivered_at IS NULL",
+      ),
+      oldestPending: this.db.prepare(
+        "SELECT created_at FROM messages WHERE to_mailbox = ? AND delivered_at IS NULL ORDER BY id LIMIT 1",
+      ),
+      selectPending: this.db.prepare(
+        "SELECT * FROM messages WHERE to_mailbox = ? AND delivered_at IS NULL ORDER BY id",
+      ),
+      markDelivered: this.db.prepare(
+        "UPDATE messages SET delivered_at = ? WHERE id IN (SELECT value FROM json_each(?))",
+      ),
+      pendingByRecipient: this.db.prepare(
+        "SELECT to_mailbox, COUNT(*) AS n FROM messages WHERE delivered_at IS NULL GROUP BY to_mailbox",
+      ),
+    };
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  upsertMailbox(name: string): void {
+    const now = nowIso();
+    const existing = this.stmts.findMailbox.get(name) as MailboxRow | undefined;
+    if (existing) {
+      this.stmts.touchMailbox.run(now, name);
+    } else {
+      this.stmts.insertMailbox.run(name, now, now);
+    }
+  }
+
+  send(from: string, to: string, body: string): { id: number; queuedAt: Date } {
+    const tx = this.db.transaction(() => {
+      this.upsertMailbox(from);
+      this.upsertMailbox(to);
+      const createdAt = nowIso();
+      const result = this.stmts.insertMessage.run(to, from, body, createdAt);
+      return { id: Number(result.lastInsertRowid), queuedAt: new Date(createdAt) };
+    });
+    return tx();
+  }
+
+  peek(name: string): InboxStatus {
+    const row = this.stmts.countPending.get(name) as { n: number };
+    if (row.n === 0) return { pending: 0, oldestAt: null };
+    const oldest = this.stmts.oldestPending.get(name) as { created_at: string } | undefined;
+    return { pending: row.n, oldestAt: parseDate(oldest?.created_at) };
+  }
+
+  checkInbox(name: string): MessageRow[] {
+    const tx = this.db.transaction(() => {
+      const pending = this.stmts.selectPending.all(name) as MessageRow[];
+      if (pending.length > 0) {
+        const ids = pending.map((m) => m.id);
+        this.stmts.markDelivered.run(nowIso(), JSON.stringify(ids));
+      }
+      return pending;
+    });
+    return tx();
+  }
+
+  listMailboxes(forName?: string): MailboxInfo[] {
+    const rows = this.stmts.listMailboxes.all() as MailboxRow[];
+    const pendingMap = new Map<string, number>();
+    if (forName) {
+      const counts = this.stmts.pendingByRecipient.all() as { to_mailbox: string; n: number }[];
+      for (const c of counts) pendingMap.set(c.to_mailbox, c.n);
+    }
+    return rows.map((r) => ({
+      name: r.name,
+      lastSeenAt: parseDate(r.last_seen_at) ?? new Date(0),
+      pendingForYou: forName ? (pendingMap.get(forName) ?? 0) : 0,
+    }));
+  }
+}
+
+export function rowToMessage(r: MessageRow): {
+  id: number;
+  from: string;
+  body: string;
+  sentAt: Date;
+} {
+  return {
+    id: r.id,
+    from: r.from_mailbox,
+    body: r.body,
+    sentAt: parseDate(r.created_at) ?? new Date(0),
+  };
+}