@bobfrankston/mailx 1.0.1

package/packages/mailx-store/db.js

@@ -0,0 +1,461 @@
+/**
+ * SQLite metadata index for mailx.
+ * Stores message headers, folder structure, sync state.
+ * Message bodies are NOT here -- they live in the MessageStore backend.
+ */
+import Database from "better-sqlite3";
+import * as path from "node:path";
+import * as fs from "node:fs";
+const SCHEMA = `
+    CREATE TABLE IF NOT EXISTS accounts (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL,
+        config_json TEXT NOT NULL,
+        last_sync INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS folders (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        account_id TEXT NOT NULL REFERENCES accounts(id),
+        path TEXT NOT NULL,
+        name TEXT NOT NULL,
+        special_use TEXT,
+        delimiter TEXT DEFAULT '/',
+        total_count INTEGER DEFAULT 0,
+        unread_count INTEGER DEFAULT 0,
+        uidvalidity INTEGER DEFAULT 0,
+        highest_modseq TEXT DEFAULT '0',
+        UNIQUE(account_id, path)
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        account_id TEXT NOT NULL,
+        folder_id INTEGER NOT NULL REFERENCES folders(id),
+        uid INTEGER NOT NULL,
+        message_id TEXT,
+        in_reply_to TEXT,
+        refs TEXT,
+        date INTEGER NOT NULL,
+        subject TEXT DEFAULT '',
+        from_address TEXT DEFAULT '',
+        from_name TEXT DEFAULT '',
+        to_json TEXT DEFAULT '[]',
+        cc_json TEXT DEFAULT '[]',
+        flags_json TEXT DEFAULT '[]',
+        size INTEGER DEFAULT 0,
+        has_attachments INTEGER DEFAULT 0,
+        preview TEXT DEFAULT '',
+        body_path TEXT,
+        cached_at INTEGER NOT NULL,
+        UNIQUE(account_id, folder_id, uid)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_folder_date
+        ON messages(account_id, folder_id, date DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_message_id
+        ON messages(message_id);
+
+    CREATE TABLE IF NOT EXISTS queue (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at INTEGER NOT NULL,
+        send_after INTEGER NOT NULL,
+        attempts INTEGER DEFAULT 0,
+        last_attempt INTEGER DEFAULT 0,
+        error TEXT,
+        from_account TEXT NOT NULL,
+        to_json TEXT NOT NULL,
+        cc_json TEXT DEFAULT '[]',
+        bcc_json TEXT DEFAULT '[]',
+        subject TEXT DEFAULT '',
+        body_html TEXT DEFAULT '',
+        body_text TEXT DEFAULT '',
+        in_reply_to TEXT,
+        refs TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS contacts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source TEXT NOT NULL DEFAULT 'sent',
+        google_id TEXT,
+        name TEXT DEFAULT '',
+        email TEXT NOT NULL,
+        organization TEXT DEFAULT '',
+        last_used INTEGER DEFAULT 0,
+        use_count INTEGER DEFAULT 0,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(email)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_contacts_email ON contacts(email);
+    CREATE INDEX IF NOT EXISTS idx_contacts_name ON contacts(name);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+        subject, from_name, from_address, to_text, cc_text, body_text,
+        content=messages, content_rowid=id
+    );
+
+    CREATE TABLE IF NOT EXISTS sync_actions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        account_id TEXT NOT NULL,
+        action TEXT NOT NULL,
+        uid INTEGER,
+        folder_id INTEGER,
+        target_folder_id INTEGER,
+        flags_json TEXT,
+        raw_message TEXT,
+        created_at INTEGER NOT NULL,
+        attempts INTEGER DEFAULT 0,
+        last_error TEXT,
+        UNIQUE(account_id, action, uid, folder_id)
+    );
+`;
+export class MailxDB {
+    db;
+    constructor(dbDir) {
+        fs.mkdirSync(dbDir, { recursive: true });
+        const dbPath = path.join(dbDir, "mailx.db");
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.db.exec(SCHEMA);
+    }
+    close() {
+        this.db.close();
+    }
+    // ── Accounts ──
+    upsertAccount(id, name, email, configJson) {
+        this.db.prepare(`
+            INSERT INTO accounts (id, name, email, config_json)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET name=?, email=?, config_json=?
+        `).run(id, name, email, configJson, name, email, configJson);
+    }
+    getAccounts() {
+        return this.db.prepare("SELECT id, name, email, last_sync as lastSync FROM accounts").all();
+    }
+    updateLastSync(accountId, timestamp) {
+        this.db.prepare("UPDATE accounts SET last_sync = ? WHERE id = ?").run(timestamp, accountId);
+    }
+    // ── Folders ──
+    upsertFolder(accountId, folderPath, name, specialUse, delimiter) {
+        const existing = this.db.prepare("SELECT id FROM folders WHERE account_id = ? AND path = ?").get(accountId, folderPath);
+        if (existing) {
+            this.db.prepare("UPDATE folders SET name = ?, special_use = ?, delimiter = ? WHERE id = ?").run(name, specialUse, delimiter, existing.id);
+            return existing.id;
+        }
+        const result = this.db.prepare("INSERT INTO folders (account_id, path, name, special_use, delimiter) VALUES (?, ?, ?, ?, ?)").run(accountId, folderPath, name, specialUse, delimiter);
+        return Number(result.lastInsertRowid);
+    }
+    getFolders(accountId) {
+        const rows = this.db.prepare("SELECT * FROM folders WHERE account_id = ? ORDER BY path").all(accountId);
+        return rows.map(r => ({
+            id: r.id,
+            accountId: r.account_id,
+            path: r.path,
+            name: r.name,
+            specialUse: r.special_use,
+            delimiter: r.delimiter,
+            totalCount: r.total_count,
+            unreadCount: r.unread_count,
+            children: []
+        }));
+    }
+    deleteFolder(folderId) {
+        this.db.prepare("DELETE FROM messages WHERE folder_id = ?").run(folderId);
+        this.db.prepare("DELETE FROM folders WHERE id = ?").run(folderId);
+    }
+    updateFolderCounts(folderId, total, unread) {
+        this.db.prepare("UPDATE folders SET total_count = ?, unread_count = ? WHERE id = ?").run(total, unread, folderId);
+    }
+    updateFolderSync(folderId, uidvalidity, highestModseq) {
+        this.db.prepare("UPDATE folders SET uidvalidity = ?, highest_modseq = ? WHERE id = ?").run(uidvalidity, highestModseq, folderId);
+    }
+    getFolderSync(folderId) {
+        const row = this.db.prepare("SELECT uidvalidity, highest_modseq as highestModseq FROM folders WHERE id = ?").get(folderId);
+        return row || { uidvalidity: 0, highestModseq: "0" };
+    }
+    // ── Messages ──
+    upsertMessage(msg) {
+        const existing = this.db.prepare("SELECT id FROM messages WHERE account_id = ? AND folder_id = ? AND uid = ?").get(msg.accountId, msg.folderId, msg.uid);
+        if (existing) {
+            this.db.prepare(`
+                UPDATE messages SET flags_json = ?, preview = ?, body_path = ?, cached_at = ?
+                WHERE id = ?
+            `).run(JSON.stringify(msg.flags), msg.preview, msg.bodyPath, Date.now(), existing.id);
+            return existing.id;
+        }
+        const toText = msg.to.map(a => `${a.name} ${a.address}`).join(" ");
+        const ccText = msg.cc.map(a => `${a.name} ${a.address}`).join(" ");
+        const result = this.db.prepare(`
+            INSERT INTO messages (
+                account_id, folder_id, uid, message_id, in_reply_to, refs,
+                date, subject, from_address, from_name, to_json, cc_json,
+                flags_json, size, has_attachments, preview, body_path, cached_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(msg.accountId, msg.folderId, msg.uid, msg.messageId, msg.inReplyTo, JSON.stringify(msg.references), msg.date, msg.subject, msg.from.address, msg.from.name, JSON.stringify(msg.to), JSON.stringify(msg.cc), JSON.stringify(msg.flags), msg.size, msg.hasAttachments ? 1 : 0, msg.preview, msg.bodyPath, Date.now());
+        const rowId = Number(result.lastInsertRowid);
+        // Index for full-text search
+        try {
+            this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, ?)").run(rowId, msg.subject, msg.from.name, msg.from.address, toText, ccText, msg.preview);
+        }
+        catch { /* FTS insert may fail on rebuild, non-fatal */ }
+        return rowId;
+    }
+    getMessages(query) {
+        const page = query.page || 1;
+        const pageSize = query.pageSize || 50;
+        const offset = (page - 1) * pageSize;
+        const sort = query.sort || "date";
+        const sortDir = query.sortDir || "desc";
+        const sortCol = sort === "from" ? "from_name" : sort === "subject" ? "subject" : "date";
+        let where = "account_id = ? AND folder_id = ?";
+        const params = [query.accountId, query.folderId];
+        if (query.search) {
+            where += " AND (subject LIKE ? OR from_name LIKE ? OR from_address LIKE ?)";
+            const term = `%${query.search}%`;
+            params.push(term, term, term);
+        }
+        const total = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages WHERE ${where}`).get(...params).cnt;
+        const rows = this.db.prepare(`SELECT * FROM messages WHERE ${where} ORDER BY ${sortCol} ${sortDir} LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
+        const items = rows.map(r => ({
+            id: r.id,
+            accountId: r.account_id,
+            folderId: r.folder_id,
+            uid: r.uid,
+            messageId: r.message_id || "",
+            inReplyTo: r.in_reply_to || "",
+            references: JSON.parse(r.refs || "[]"),
+            date: r.date,
+            subject: r.subject,
+            from: { name: r.from_name, address: r.from_address },
+            to: JSON.parse(r.to_json),
+            cc: JSON.parse(r.cc_json),
+            flags: JSON.parse(r.flags_json),
+            size: r.size,
+            hasAttachments: !!r.has_attachments,
+            preview: r.preview
+        }));
+        return { items, total, page, pageSize };
+    }
+    getMessageByUid(accountId, uid) {
+        const r = this.db.prepare("SELECT * FROM messages WHERE account_id = ? AND uid = ?").get(accountId, uid);
+        if (!r)
+            return null;
+        return {
+            id: r.id,
+            accountId: r.account_id,
+            folderId: r.folder_id,
+            uid: r.uid,
+            messageId: r.message_id || "",
+            inReplyTo: r.in_reply_to || "",
+            references: JSON.parse(r.refs || "[]"),
+            date: r.date,
+            subject: r.subject,
+            from: { name: r.from_name, address: r.from_address },
+            to: JSON.parse(r.to_json),
+            cc: JSON.parse(r.cc_json),
+            flags: JSON.parse(r.flags_json),
+            size: r.size,
+            hasAttachments: !!r.has_attachments,
+            preview: r.preview
+        };
+    }
+    getMessageBodyPath(accountId, uid) {
+        const r = this.db.prepare("SELECT body_path FROM messages WHERE account_id = ? AND uid = ?").get(accountId, uid);
+        return r?.body_path || "";
+    }
+    updateMessageFlags(accountId, uid, flags) {
+        this.db.prepare("UPDATE messages SET flags_json = ? WHERE account_id = ? AND uid = ?").run(JSON.stringify(flags), accountId, uid);
+    }
+    getHighestUid(accountId, folderId) {
+        const r = this.db.prepare("SELECT MAX(uid) as maxUid FROM messages WHERE account_id = ? AND folder_id = ?").get(accountId, folderId);
+        return r?.maxUid || 0;
+    }
+    /** Get all UIDs for a folder */
+    getUidsForFolder(accountId, folderId) {
+        const rows = this.db.prepare("SELECT uid FROM messages WHERE account_id = ? AND folder_id = ?").all(accountId, folderId);
+        return rows.map(r => r.uid);
+    }
+    /** Delete a message by account + UID */
+    deleteMessage(accountId, uid) {
+        this.db.prepare("DELETE FROM messages WHERE account_id = ? AND uid = ?").run(accountId, uid);
+    }
+    /** Bulk insert within a transaction for sync performance */
+    beginTransaction() { this.db.exec("BEGIN"); }
+    commitTransaction() { this.db.exec("COMMIT"); }
+    rollbackTransaction() { this.db.exec("ROLLBACK"); }
+    // ── Contacts ──
+    /** Record an address used in sent mail */
+    recordSentAddress(name, email) {
+        const now = Date.now();
+        const existing = this.db.prepare("SELECT id FROM contacts WHERE email = ?").get(email);
+        if (existing) {
+            this.db.prepare("UPDATE contacts SET name = CASE WHEN ? != '' THEN ? ELSE name END, last_used = ?, use_count = use_count + 1, updated_at = ? WHERE email = ?").run(name, name, now, now, email);
+        }
+        else {
+            this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('sent', ?, ?, ?, 1, ?)").run(name, email, now, now);
+        }
+    }
+    /** Seed contacts from all message senders in the DB */
+    seedContactsFromMessages() {
+        const now = Date.now();
+        const rows = this.db.prepare(`SELECT from_name, from_address, COUNT(*) as cnt, MAX(date) as last
+             FROM messages
+             WHERE from_address != ''
+             GROUP BY from_address`).all();
+        let added = 0;
+        for (const r of rows) {
+            const existing = this.db.prepare("SELECT id FROM contacts WHERE email = ?").get(r.from_address);
+            if (!existing) {
+                this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('received', ?, ?, ?, ?, ?)").run(r.from_name || "", r.from_address, r.last, r.cnt, now);
+                added++;
+            }
+        }
+        return added;
+    }
+    /** Search contacts by name or email prefix */
+    searchContacts(query, limit = 10) {
+        const q = `%${query}%`;
+        const rows = this.db.prepare(`SELECT name, email, source, use_count FROM contacts
+             WHERE email LIKE ? OR name LIKE ?
+             ORDER BY use_count DESC, last_used DESC
+             LIMIT ?`).all(q, q, limit);
+        return rows.map(r => ({ name: r.name, email: r.email, source: r.source, useCount: r.use_count }));
+    }
+    // ── Search ──
+    /** Full-text search across all messages. Supports qualifiers: from:, to:, subject: */
+    searchMessages(query, page = 1, pageSize = 50) {
+        // Parse qualifiers
+        let ftsQuery = "";
+        const parts = query.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+        for (const part of parts) {
+            const fromMatch = part.match(/^from:(.+)$/i);
+            const toMatch = part.match(/^to:(.+)$/i);
+            const subjectMatch = part.match(/^subject:(.+)$/i);
+            if (fromMatch) {
+                const term = fromMatch[1].replace(/"/g, "");
+                ftsQuery += `(from_name:${term} OR from_address:${term}) `;
+            }
+            else if (toMatch) {
+                const term = toMatch[1].replace(/"/g, "");
+                ftsQuery += `(to_text:${term} OR cc_text:${term}) `;
+            }
+            else if (subjectMatch) {
+                const term = subjectMatch[1].replace(/"/g, "");
+                ftsQuery += `subject:${term} `;
+            }
+            else {
+                // Unqualified — search everything
+                ftsQuery += `${part}* `;
+            }
+        }
+        ftsQuery = ftsQuery.trim();
+        if (!ftsQuery)
+            return { items: [], total: 0, page, pageSize };
+        const offset = (page - 1) * pageSize;
+        try {
+            const countRow = this.db.prepare("SELECT COUNT(*) as cnt FROM messages_fts WHERE messages_fts MATCH ?").get(ftsQuery);
+            const total = countRow?.cnt || 0;
+            const rows = this.db.prepare(`SELECT m.* FROM messages m
+                 JOIN messages_fts fts ON m.id = fts.rowid
+                 WHERE messages_fts MATCH ?
+                 ORDER BY m.date DESC
+                 LIMIT ? OFFSET ?`).all(ftsQuery, pageSize, offset);
+            const items = rows.map(r => ({
+                id: r.id,
+                accountId: r.account_id,
+                folderId: r.folder_id,
+                uid: r.uid,
+                messageId: r.message_id || "",
+                inReplyTo: r.in_reply_to || "",
+                references: JSON.parse(r.refs || "[]"),
+                date: r.date,
+                subject: r.subject,
+                from: { name: r.from_name, address: r.from_address },
+                to: JSON.parse(r.to_json),
+                cc: JSON.parse(r.cc_json),
+                flags: JSON.parse(r.flags_json),
+                size: r.size,
+                hasAttachments: !!r.has_attachments,
+                preview: r.preview
+            }));
+            return { items, total, page, pageSize };
+        }
+        catch (e) {
+            console.error(`Search error: ${e.message}`);
+            return { items: [], total: 0, page, pageSize };
+        }
+    }
+    /** Rebuild FTS index from existing messages */
+    rebuildSearchIndex() {
+        // Drop and recreate in case schema changed
+        try {
+            this.db.exec("DROP TABLE IF EXISTS messages_fts");
+        }
+        catch { /* ignore */ }
+        this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+            subject, from_name, from_address, to_text, cc_text, body_text,
+            content=messages, content_rowid=id
+        )`);
+        const rows = this.db.prepare("SELECT id, subject, from_name, from_address, to_json, cc_json, preview FROM messages").all();
+        let count = 0;
+        for (const r of rows) {
+            const to = JSON.parse(r.to_json || "[]");
+            const cc = JSON.parse(r.cc_json || "[]");
+            const toText = to.map((a) => `${a.name} ${a.address}`).join(" ");
+            const ccText = cc.map((a) => `${a.name} ${a.address}`).join(" ");
+            try {
+                this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, ?)").run(r.id, r.subject, r.from_name, r.from_address, toText, ccText, r.preview);
+                count++;
+            }
+            catch { /* skip duplicates */ }
+        }
+        return count;
+    }
+    // ── Sync Actions ──
+    /** Queue a local action for later sync to IMAP */
+    queueSyncAction(accountId, action, uid, folderId, extra) {
+        try {
+            this.db.prepare(`INSERT OR REPLACE INTO sync_actions (account_id, action, uid, folder_id, target_folder_id, flags_json, raw_message, created_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(accountId, action, uid, folderId, extra?.targetFolderId || null, extra?.flags ? JSON.stringify(extra.flags) : null, extra?.rawMessage || null, Date.now());
+        }
+        catch { /* UNIQUE constraint — already queued */ }
+    }
+    /** Get all pending sync actions for an account */
+    getPendingSyncActions(accountId) {
+        const rows = this.db.prepare("SELECT * FROM sync_actions WHERE account_id = ? ORDER BY created_at").all(accountId);
+        return rows.map(r => ({
+            id: r.id,
+            action: r.action,
+            uid: r.uid,
+            folderId: r.folder_id,
+            targetFolderId: r.target_folder_id,
+            flags: r.flags_json ? JSON.parse(r.flags_json) : [],
+            rawMessage: r.raw_message,
+            attempts: r.attempts,
+        }));
+    }
+    /** Remove a completed sync action */
+    completeSyncAction(id) {
+        this.db.prepare("DELETE FROM sync_actions WHERE id = ?").run(id);
+    }
+    /** Mark a sync action as failed */
+    failSyncAction(id, error) {
+        this.db.prepare("UPDATE sync_actions SET attempts = attempts + 1, last_error = ? WHERE id = ?").run(error, id);
+    }
+    /** Count pending sync actions for an account */
+    getPendingSyncCount(accountId) {
+        const r = this.db.prepare("SELECT COUNT(*) as cnt FROM sync_actions WHERE account_id = ?").get(accountId);
+        return r?.cnt || 0;
+    }
+    /** Count total pending sync actions across all accounts */
+    getTotalPendingSyncCount() {
+        const r = this.db.prepare("SELECT COUNT(*) as cnt FROM sync_actions").get();
+        return r?.cnt || 0;
+    }
+}
+//# sourceMappingURL=db.js.map

package/packages/mailx-store/file-store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * File-per-message body storage backend.
+ * Messages stored as: {basePath}/{accountId}/{folderName}/{uid}.eml
+ * Legacy: also checks {basePath}/{accountId}/{folderId}/{uid}.eml
+ */
+import type { MessageStore } from "@bobfrankston/mailx-types";
+export declare class FileMessageStore implements MessageStore {
+    private basePath;
+    private folderNames;
+    constructor(basePath: string);
+    /** Register folder ID → path mapping for human-readable directory names */
+    registerFolder(folderId: number, folderPath: string): void;
+    private folderDir;
+    private messagePath;
+    /** Check legacy path (numeric folder ID) */
+    private legacyPath;
+    putMessage(accountId: string, folderId: number, uid: number, raw: Buffer): Promise<string>;
+    getMessage(accountId: string, folderId: number, uid: number): Promise<Buffer>;
+    deleteMessage(accountId: string, folderId: number, uid: number): Promise<void>;
+    hasMessage(accountId: string, folderId: number, uid: number): Promise<boolean>;
+}
+//# sourceMappingURL=file-store.d.ts.map

package/packages/mailx-store/file-store.js

@@ -0,0 +1,59 @@
+/**
+ * File-per-message body storage backend.
+ * Messages stored as: {basePath}/{accountId}/{folderName}/{uid}.eml
+ * Legacy: also checks {basePath}/{accountId}/{folderId}/{uid}.eml
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** Sanitize folder path for use as directory name — replace delimiters with _ */
+function sanitizeFolderName(folderPath) {
+    return folderPath.replace(/[\/\\.:]/g, "_");
+}
+export class FileMessageStore {
+    basePath;
+    folderNames = new Map();
+    constructor(basePath) {
+        this.basePath = basePath;
+        fs.mkdirSync(basePath, { recursive: true });
+    }
+    /** Register folder ID → path mapping for human-readable directory names */
+    registerFolder(folderId, folderPath) {
+        this.folderNames.set(folderId, sanitizeFolderName(folderPath));
+    }
+    folderDir(accountId, folderId) {
+        const name = this.folderNames.get(folderId) || String(folderId);
+        return path.join(this.basePath, accountId, name);
+    }
+    messagePath(accountId, folderId, uid) {
+        return path.join(this.folderDir(accountId, folderId), `${uid}.eml`);
+    }
+    /** Check legacy path (numeric folder ID) */
+    legacyPath(accountId, folderId, uid) {
+        return path.join(this.basePath, accountId, String(folderId), `${uid}.eml`);
+    }
+    async putMessage(accountId, folderId, uid, raw) {
+        const filePath = this.messagePath(accountId, folderId, uid);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, raw);
+        return filePath;
+    }
+    async getMessage(accountId, folderId, uid) {
+        const filePath = this.messagePath(accountId, folderId, uid);
+        if (fs.existsSync(filePath))
+            return fs.readFileSync(filePath);
+        // Fallback to legacy path
+        const legacy = this.legacyPath(accountId, folderId, uid);
+        return fs.readFileSync(legacy);
+    }
+    async deleteMessage(accountId, folderId, uid) {
+        for (const p of [this.messagePath(accountId, folderId, uid), this.legacyPath(accountId, folderId, uid)]) {
+            if (fs.existsSync(p))
+                fs.unlinkSync(p);
+        }
+    }
+    async hasMessage(accountId, folderId, uid) {
+        return fs.existsSync(this.messagePath(accountId, folderId, uid)) ||
+            fs.existsSync(this.legacyPath(accountId, folderId, uid));
+    }
+}
+//# sourceMappingURL=file-store.js.map

package/packages/mailx-store/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @bobfrankston/mailx-store
+ * Two-layer storage: SQLite metadata index + pluggable body backend.
+ */
+export { MailxDB } from "./db.js";
+export { FileMessageStore } from "./file-store.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/mailx-store/index.js

@@ -0,0 +1,7 @@
+/**
+ * @bobfrankston/mailx-store
+ * Two-layer storage: SQLite metadata index + pluggable body backend.
+ */
+export { MailxDB } from "./db.js";
+export { FileMessageStore } from "./file-store.js";
+//# sourceMappingURL=index.js.map

package/packages/mailx-store/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@bobfrankston/mailx-store",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@bobfrankston/mailx-types": "file:../mailx-types",
+    "@bobfrankston/mailx-settings": "file:../mailx-settings",
+    "better-sqlite3": "^11.7.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12"
+  }
+}

package/packages/mailx-store/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./db.ts","./file-store.ts","./index.ts"],"version":"5.9.2"}