ClaudeMailbox/node/src/db.ts

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),
  };
}