opencode-mailbox 0.0.0 → 0.0.2

package/README.md

@@ -4,7 +4,9 @@ A simple mailbox system for sending and receiving messages between sessions.
 
 ## Description
 
-This OpenCode plugin provides a lightweight mailbox system that allows sessions to send messages to each other asynchronously. Messages are stored efficiently, indexed first by recipient and then by timestamp.
+This OpenCode plugin provides a lightweight mailbox system that allows sessions to send messages to each other asynchronously. Messages are stored in a SQLite database with proper indexing for fast lookups.
+
+**NOTE: Mail is stored in `~/.config/opencode/mailbox.db`**
 
 ## Installation
 
@@ -58,9 +60,10 @@ Stop all mail watching for the current session.
 
 ## Storage
 
-Mail data is persisted in the OpenCode config directory as `mailbox.json`. The storage is optimized with an index structure:
-- First index: recipient (who the mail is to)
-- Second index: timestamp (when the mail was received)
+Mail data is persisted in a SQLite database at `~/.config/opencode/mailbox.db`. The database includes:
+- Indexed `recipient` column for fast recipient lookups
+- Indexed `read` status for efficient watch queries
+- WAL (Write-Ahead Logging) mode for better concurrency
 
 ## Session Management
 

package/dist/index.js

@@ -12677,30 +12677,68 @@ var init_dist = __esm(() => {
 });
 
 // index.ts
-import * as fs from "fs";
 import * as path from "path";
-var mailboxFile = null;
+import Database from "better-sqlite3";
+var dbFile = null;
+var db = null;
 var activeWatches = new Map;
-async function getMailboxFile(client) {
-  if (!mailboxFile) {
+async function getDbFile(client) {
+  if (!dbFile) {
     const result = await client.path.get();
-    mailboxFile = path.join(result.data.config, "mailbox.json");
-  }
-  return mailboxFile;
-}
-async function loadMailbox(client) {
-  const file2 = await getMailboxFile(client);
-  try {
-    if (fs.existsSync(file2)) {
-      const data = JSON.parse(fs.readFileSync(file2, "utf-8"));
-      return data;
-    }
-  } catch {}
-  return {};
-}
-async function saveMailbox(client, mailbox) {
-  const file2 = await getMailboxFile(client);
-  fs.writeFileSync(file2, JSON.stringify(mailbox, null, 2));
+    dbFile = path.join(result.data.config, "mailbox.db");
+  }
+  return dbFile;
+}
+async function getDatabase(client) {
+  if (!db) {
+    const file2 = await getDbFile(client);
+    db = new Database(file2);
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        recipient TEXT NOT NULL,
+        sender TEXT NOT NULL,
+        message TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        read INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_messages_recipient ON messages(recipient)
+    `);
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_messages_read ON messages(recipient, read)
+    `);
+  }
+  return db;
+}
+async function addMessage(client, recipient, sender, message, timestamp) {
+  const database = await getDatabase(client);
+  const stmt = database.prepare(`
+    INSERT INTO messages (recipient, sender, message, timestamp, read)
+    VALUES (?, ?, ?, ?, 0)
+  `);
+  stmt.run(recipient.toLowerCase(), sender.toLowerCase(), message, timestamp);
+}
+async function getUnreadMessages(client, recipient) {
+  const database = await getDatabase(client);
+  const stmt = database.prepare(`
+    SELECT sender as from, message, timestamp, read
+    FROM messages
+    WHERE recipient = ? AND read = 0
+    ORDER BY timestamp ASC
+  `);
+  return stmt.all(recipient.toLowerCase());
+}
+async function markMessageAsRead(client, recipient, timestamp) {
+  const database = await getDatabase(client);
+  const stmt = database.prepare(`
+    UPDATE messages
+    SET read = 1
+    WHERE recipient = ? AND timestamp = ?
+  `);
+  stmt.run(recipient.toLowerCase(), timestamp);
 }
 function startMailWatch(client, recipient, sessionId, instructions) {
   if (activeWatches.has(recipient)) {
@@ -12708,25 +12746,16 @@ function startMailWatch(client, recipient, sessionId, instructions) {
   }
   const interval = setInterval(async () => {
     try {
-      const mailbox = await loadMailbox(client);
       const watch = activeWatches.get(recipient);
       if (!watch) {
         return;
       }
-      const recipientMailbox = mailbox[recipient];
-      if (!recipientMailbox) {
+      const unreadMessages = await getUnreadMessages(client, recipient);
+      if (unreadMessages.length === 0) {
         return;
       }
-      const unreadMessages = [];
-      for (const [timestamp, message] of Object.entries(recipientMailbox)) {
-        if (!message.read) {
-          unreadMessages.push(message);
-        }
-      }
-      unreadMessages.sort((a, b) => a.timestamp - b.timestamp);
       for (const message of unreadMessages) {
-        recipientMailbox[message.timestamp].read = true;
-        await saveMailbox(client, mailbox);
+        await markMessageAsRead(client, recipient, message.timestamp);
         await injectMailMessage(client, sessionId, recipient, message, instructions);
       }
     } catch (error45) {
@@ -12793,20 +12822,10 @@ var mailboxPlugin = async (ctx) => {
       message: z.string().describe("Message content to send")
     },
     async execute(args) {
-      const mailbox = await loadMailbox(client);
       const to = args.to.toLowerCase();
       const from = args.from.toLowerCase();
       const timestamp = Date.now();
-      if (!mailbox[to]) {
-        mailbox[to] = {};
-      }
-      mailbox[to][timestamp] = {
-        from,
-        message: args.message,
-        timestamp,
-        read: false
-      };
-      await saveMailbox(client, mailbox);
+      await addMessage(client, to, from, args.message, timestamp);
       return `Mail sent to "${args.to}" from "${args.from}" at ${new Date(timestamp).toISOString()}`;
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mailbox",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "A simple mailbox system for sending and receiving messages between sessions",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,12 +16,13 @@
     "README.md"
   ],
   "scripts": {
-    "build": "bun build ./index.ts --outdir ./dist --target bun && bun run build:types",
+    "build": "bun build ./index.ts --outdir ./dist --target bun --external better-sqlite3 && bun run build:types",
     "build:types": "tsc --emitDeclarationOnly",
     "start": "bun run build",
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^25.0.10",
     "electron": "^28.0.0",
     "typescript": "^5.9.3"
@@ -30,6 +31,7 @@
     "@opencode-ai/plugin": "^1.1.25"
   },
   "dependencies": {
+    "better-sqlite3": "^12.1.0",
     "dotenv": "^17.2.3"
   },
   "keywords": [