@bobfrankston/mailx 1.0.12 → 1.0.14

package/packages/mailx-api/index.js

@@ -3,7 +3,7 @@
  * Express Router with all REST endpoints for the mailx client.
  */
 import { Router } from "express";
-import { loadSettings, saveSettings, loadAllowlist, saveAllowlist } from "@bobfrankston/mailx-settings";
+import { loadSettings, saveSettings, loadAllowlist, saveAllowlist, getStorePath } from "@bobfrankston/mailx-settings";
 import { simpleParser } from "mailparser";
 /** Sanitize HTML email body — strip remote content (images, CSS, scripts, event handlers) */
 function sanitizeHtml(html) {
@@ -42,7 +42,13 @@ export function createApiRouter(db, imapManager) {
     // ── Accounts ──
     router.get("/accounts", (req, res) => {
         const accounts = db.getAccounts();
-        res.json(accounts);
+        const settings = loadSettings();
+        // Merge settings flags
+        const enriched = accounts.map(a => {
+            const cfg = settings.accounts.find(s => s.id === a.id);
+            return { ...a, label: cfg?.label, defaultSend: cfg?.defaultSend || false };
+        });
+        res.json(enriched);
     });
     // ── Folders ──
     router.get("/folders/:accountId", (req, res) => {
@@ -54,22 +60,8 @@ export function createApiRouter(db, imapManager) {
     router.get("/messages/unified/inbox", (req, res) => {
         const page = Number(req.query.page) || 1;
         const pageSize = Number(req.query.pageSize) || 50;
-        const accounts = db.getAccounts();
-        let allItems = [];
-        for (const account of accounts) {
-            const folders = db.getFolders(account.id);
-            const inbox = folders.find(f => f.specialUse === "inbox");
-            if (!inbox)
-                continue;
-            const result = db.getMessages({ accountId: account.id, folderId: inbox.id, page: 1, pageSize: 10000 });
-            allItems.push(...result.items);
-        }
-        // Sort by date descending
-        allItems.sort((a, b) => b.date - a.date);
-        const total = allItems.length;
-        const offset = (page - 1) * pageSize;
-        const items = allItems.slice(offset, offset + pageSize);
-        res.json({ items, total, page, pageSize });
+        const result = db.getUnifiedInbox(page, pageSize);
+        res.json(result);
     });
     // Per-folder messages (after unified to avoid route conflict)
     router.get("/messages/:accountId/:folderId", (req, res) => {
@@ -88,7 +80,8 @@ export function createApiRouter(db, imapManager) {
         try {
             const { accountId, uid } = req.params;
             let allowRemote = req.query.allowRemote === "true";
-            const envelope = db.getMessageByUid(accountId, Number(uid));
+            const folderId = req.query.folderId ? Number(req.query.folderId) : undefined;
+            const envelope = db.getMessageByUid(accountId, Number(uid), folderId);
             if (!envelope)
                 return res.status(404).json({ error: "Message not found" });
             // Load body from store or fetch on demand from IMAP
@@ -132,12 +125,42 @@ export function createApiRouter(db, imapManager) {
                     hasRemoteContent = result.hasRemoteContent;
                 }
             }
+            // Build .eml file path
+            const storePath = getStorePath();
+            const emlPath = `${storePath}/${accountId}/${envelope.folderId}/${envelope.uid}.eml`;
+            // Extract useful headers (values may be strings or structured objects)
+            let deliveredTo = "";
+            let returnPath = "";
+            let listUnsubscribe = "";
+            if (raw) {
+                const parsed2 = await simpleParser(raw);
+                const hdr = (key) => {
+                    const v = parsed2.headers.get(key);
+                    if (!v)
+                        return "";
+                    if (typeof v === "string")
+                        return v;
+                    if (typeof v === "object" && "text" in v)
+                        return v.text || "";
+                    if (typeof v === "object" && "value" in v)
+                        return String(v.value);
+                    return String(v);
+                };
+                deliveredTo = hdr("delivered-to");
+                returnPath = hdr("return-path").replace(/[<>]/g, "");
+                listUnsubscribe = hdr("list-unsubscribe");
+            }
             const message = {
                 ...envelope,
                 bodyHtml,
                 bodyText,
                 hasRemoteContent,
-                attachments
+                remoteAllowed: allowRemote,
+                attachments,
+                emlPath,
+                deliveredTo,
+                returnPath,
+                listUnsubscribe,
             };
             res.json(message);
         }
@@ -174,14 +197,57 @@ export function createApiRouter(db, imapManager) {
         res.json({ ok: true });
     });
     // ── Search ──
-    router.get("/search", (req, res) => {
+    router.get("/search", async (req, res) => {
         const q = req.query.q || "";
         const page = Number(req.query.page) || 1;
         const pageSize = Number(req.query.pageSize) || 50;
+        const scope = req.query.scope || "all";
+        const accountId = req.query.accountId || "";
+        const folderId = Number(req.query.folderId) || 0;
         if (!q.trim())
             return res.json({ items: [], total: 0, page, pageSize });
-        const result = db.searchMessages(q, page, pageSize);
-        res.json(result);
+        try {
+            if (scope === "server" && accountId) {
+                // IMAP server search
+                const folders = db.getFolders(accountId);
+                const folder = folderId ? folders.find(f => f.id === folderId) : folders.find(f => f.specialUse === "inbox");
+                if (!folder)
+                    return res.json({ items: [], total: 0, page, pageSize });
+                const criteria = {};
+                // Parse qualifiers
+                const fromMatch = q.match(/from:(\S+)/i);
+                const toMatch = q.match(/to:(\S+)/i);
+                const subjectMatch = q.match(/subject:(.+?)(?:\s+\w+:|$)/i);
+                const bodyText = q.replace(/(?:from|to|subject):\S+/gi, "").trim();
+                if (fromMatch)
+                    criteria.from = fromMatch[1];
+                if (toMatch)
+                    criteria.to = toMatch[1];
+                if (subjectMatch)
+                    criteria.subject = subjectMatch[1].trim();
+                if (bodyText)
+                    criteria.body = bodyText;
+                const uids = await imapManager.searchOnServer(accountId, folder.path, criteria);
+                // Fetch envelopes for matching UIDs from local DB
+                const items = uids.slice((page - 1) * pageSize, page * pageSize)
+                    .map(uid => db.getMessageByUid(accountId, uid, folderId))
+                    .filter(Boolean);
+                res.json({ items, total: uids.length, page, pageSize });
+            }
+            else if (scope === "current" && accountId && folderId) {
+                // Search within current folder only
+                const result = db.searchMessages(q, page, pageSize, accountId, folderId);
+                res.json(result);
+            }
+            else {
+                // All folders (default)
+                const result = db.searchMessages(q, page, pageSize);
+                res.json(result);
+            }
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
     });
     router.post("/search/rebuild", (req, res) => {
         const count = db.rebuildSearchIndex();
@@ -237,12 +303,16 @@ export function createApiRouter(db, imapManager) {
             const account = settings.accounts.find(a => a.id === msg.from);
             if (!account)
                 return res.status(400).json({ error: `Unknown account: ${msg.from}` });
+            // Use custom From address if provided, otherwise account default
+            const fromHeader = msg.fromAddress || `${account.name} <${account.email}>`;
             // Build RFC 822 message
-            const to = msg.to.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
-            const cc = msg.cc?.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
-            const bcc = msg.bcc?.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+            const to = msg.to.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+            const cc = msg.cc?.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+            const bcc = msg.bcc?.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+            const body = msg.bodyHtml || msg.bodyText || "";
+            const bodyBase64 = Buffer.from(body, "utf-8").toString("base64").replace(/(.{76})/g, "$1\r\n");
             const headers = [
-                `From: ${account.name} <${account.email}>`,
+                `From: ${fromHeader}`,
                 `To: ${to}`,
                 cc ? `Cc: ${cc}` : null,
                 bcc ? `Bcc: ${bcc}` : null,
@@ -252,11 +322,12 @@ export function createApiRouter(db, imapManager) {
                 msg.references?.length ? `References: ${msg.references.join(" ")}` : null,
                 `MIME-Version: 1.0`,
                 `Content-Type: text/html; charset=UTF-8`,
+                `Content-Transfer-Encoding: base64`,
             ].filter(h => h !== null).join("\r\n");
-            const rawMessage = `${headers}\r\n\r\n${msg.bodyHtml || msg.bodyText || ""}`;
+            const rawMessage = `${headers}\r\n\r\n${bodyBase64}`;
             // Local-first: save to sync queue, worker will APPEND to Outbox and send
             imapManager.queueOutgoingLocal(account.id, rawMessage);
-            console.log(`  Queued locally: ${msg.subject} via ${account.id}`);
+            console.log(`  Queued locally: ${msg.subject} via ${account.id} from ${fromHeader}`);
             // Record recipient addresses for autocomplete
             for (const addr of msg.to)
                 db.recordSentAddress(addr.name, addr.address);
@@ -288,6 +359,31 @@ export function createApiRouter(db, imapManager) {
             res.status(500).json({ error: e.message });
         }
     });
+    // ── Move message to another folder ──
+    router.post("/message/:accountId/:uid/move", async (req, res) => {
+        try {
+            const { accountId, uid } = req.params;
+            const { targetFolderId, targetAccountId } = req.body;
+            if (targetFolderId == null)
+                return res.status(400).json({ error: "targetFolderId required" });
+            const envelope = db.getMessageByUid(accountId, Number(uid));
+            if (!envelope)
+                return res.status(404).json({ error: "Message not found" });
+            if (targetAccountId && targetAccountId !== accountId) {
+                // Cross-account move via iflow
+                await imapManager.moveMessageCrossAccount(accountId, envelope.uid, envelope.folderId, targetAccountId, targetFolderId);
+            }
+            else {
+                // Same-account move
+                await imapManager.moveMessage(accountId, envelope.uid, envelope.folderId, targetFolderId);
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error(`  Move error: ${e.message}`);
+            res.status(500).json({ error: e.message });
+        }
+    });
     // ── Undelete (move from Trash back to original folder) ──
     router.post("/message/:accountId/:uid/undelete", async (req, res) => {
         try {

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

@@ -0,0 +1,129 @@
+/**
+ * @bobfrankston/mailx-core
+ * Core mail functions — callable directly via IPC or wrapped by Express.
+ * No HTTP, no Express, no WebSocket. Just plain async functions.
+ */
+import { MailxDB } from "@bobfrankston/mailx-store";
+import { ImapManager } from "@bobfrankston/mailx-imap";
+import type { ComposeMessage } from "@bobfrankston/mailx-types";
+declare let db: MailxDB;
+declare let imapManager: ImapManager;
+export declare function onEvent(handler: (event: any) => void): void;
+export declare function initialize(): Promise<void>;
+export declare function shutdown(): Promise<void>;
+export declare function getAccounts(): {
+    id: string;
+    name: string;
+    email: string;
+    lastSync: number;
+}[];
+export declare function getFolders(params: {
+    accountId: string;
+}): import("@bobfrankston/mailx-types").Folder[];
+export declare function getMessages(params: {
+    accountId: string;
+    folderId: number;
+    page?: number;
+    pageSize?: number;
+    sort?: string;
+    sortDir?: string;
+    search?: string;
+}): import("@bobfrankston/mailx-types").PagedResult<import("@bobfrankston/mailx-types").MessageEnvelope>;
+export declare function getUnifiedInbox(params: {
+    page?: number;
+    pageSize?: number;
+}): import("@bobfrankston/mailx-types").PagedResult<import("@bobfrankston/mailx-types").MessageEnvelope>;
+export declare function getMessage(params: {
+    accountId: string;
+    uid: number;
+    allowRemote?: boolean;
+    folderId?: number;
+}): Promise<{
+    bodyHtml: string;
+    bodyText: string;
+    hasRemoteContent: boolean;
+    remoteAllowed: boolean;
+    attachments: any[];
+    deliveredTo: string;
+    returnPath: string;
+    listUnsubscribe: string;
+    emlPath: string;
+    id: number;
+    accountId: string;
+    folderId: number;
+    uid: number;
+    messageId: string;
+    inReplyTo: string;
+    references: string[];
+    date: number;
+    subject: string;
+    from: import("@bobfrankston/mailx-types").EmailAddress;
+    to: import("@bobfrankston/mailx-types").EmailAddress[];
+    cc: import("@bobfrankston/mailx-types").EmailAddress[];
+    flags: string[];
+    size: number;
+    hasAttachments: boolean;
+    preview: string;
+}>;
+export declare function updateFlags(params: {
+    accountId: string;
+    uid: number;
+    flags: string[];
+}): Promise<void>;
+export declare function deleteMessage(params: {
+    accountId: string;
+    uid: number;
+}): Promise<void>;
+export declare function undeleteMessage(params: {
+    accountId: string;
+    uid: number;
+    folderId: number;
+}): Promise<void>;
+export declare function sendMessage(params: ComposeMessage): Promise<void>;
+export declare function saveDraft(params: {
+    accountId: string;
+    subject: string;
+    bodyHtml: string;
+    bodyText: string;
+    to: string;
+    cc: string;
+    previousDraftUid?: number;
+}): Promise<number>;
+export declare function deleteDraft(params: {
+    accountId: string;
+    draftUid: number;
+}): Promise<void>;
+export declare function searchMessages(params: {
+    query: string;
+    page?: number;
+    pageSize?: number;
+}): import("@bobfrankston/mailx-types").PagedResult<import("@bobfrankston/mailx-types").MessageEnvelope>;
+export declare function searchContacts(params: {
+    query: string;
+}): {
+    name: string;
+    email: string;
+    source: string;
+    useCount: number;
+}[];
+export declare function syncAll(): Promise<void>;
+export declare function getSyncPending(): {
+    pending: number;
+};
+export declare function allowRemoteContent(params: {
+    type: string;
+    value: string;
+}): void;
+export declare function getSettings(): import("@bobfrankston/mailx-types").MailxSettings;
+export declare function saveSettingsData(data: any): void;
+export declare function rebuildSearchIndex(): number;
+export declare function seedContacts(): number;
+export declare function syncGoogleContacts(): Promise<void>;
+export declare function getVersion(): {
+    server: string;
+    client: string;
+};
+/** Dispatch an action by name — used by IPC and Express wrapper */
+export declare function dispatch(action: string, params?: any): Promise<any>;
+export { db, imapManager };
+//# sourceMappingURL=index.d.ts.map

package/packages/mailx-core/index.js

@@ -0,0 +1,323 @@
+/**
+ * @bobfrankston/mailx-core
+ * Core mail functions — callable directly via IPC or wrapped by Express.
+ * No HTTP, no Express, no WebSocket. Just plain async functions.
+ */
+import { MailxDB } from "@bobfrankston/mailx-store";
+import { ImapManager } from "@bobfrankston/mailx-imap";
+import { loadSettings, saveSettings, loadAllowlist, saveAllowlist, getConfigDir, getStorePath, initLocalConfig } from "@bobfrankston/mailx-settings";
+import { simpleParser } from "mailparser";
+// ── Initialization ──
+let db;
+let imapManager;
+const eventHandlers = [];
+export function onEvent(handler) {
+    eventHandlers.push(handler);
+}
+function emit(event) {
+    for (const h of eventHandlers) {
+        try {
+            h(event);
+        }
+        catch { /* ignore handler errors */ }
+    }
+}
+export async function initialize() {
+    initLocalConfig();
+    const dbDir = getConfigDir();
+    db = new MailxDB(dbDir);
+    imapManager = new ImapManager(db);
+    // Seed contacts
+    const seeded = db.seedContactsFromMessages();
+    if (seeded > 0)
+        console.log(`  Seeded ${seeded} contacts`);
+    // Search index — only if empty
+    let ftsCount = 0;
+    try {
+        ftsCount = db.db.prepare("SELECT COUNT(*) as cnt FROM messages_fts").get()?.cnt || 0;
+    }
+    catch { /* */ }
+    if (ftsCount === 0) {
+        const indexed = db.rebuildSearchIndex();
+        if (indexed > 0)
+            console.log(`  Search index: ${indexed} messages`);
+    }
+    // Add accounts
+    const settings = loadSettings();
+    for (const account of settings.accounts) {
+        if (!account.enabled)
+            continue;
+        try {
+            await imapManager.addAccount(account);
+            console.log(`  Account added: ${account.name} (${account.id})`);
+        }
+        catch (e) {
+            console.error(`  Failed to add account ${account.id}: ${e.message}`);
+        }
+    }
+    // Wire events to push notifications
+    imapManager.on("syncProgress", (accountId, phase, progress) => {
+        emit({ type: "syncProgress", accountId, phase, progress });
+    });
+    imapManager.on("folderCountsChanged", (accountId, counts) => {
+        emit({ type: "folderCountsChanged", accountId, counts });
+    });
+    // Initial sync + IDLE
+    if (settings.accounts.some(a => a.enabled)) {
+        console.log("  Starting initial sync...");
+        imapManager.syncAll().then(async () => {
+            console.log("  Initial sync complete");
+            await imapManager.startWatching();
+            imapManager.syncAllContacts().catch(e => console.error(`  Google Contacts sync error: ${e.message}`));
+        }).catch(e => {
+            console.error(`  Initial sync error: ${e.message}`);
+        });
+    }
+    imapManager.startPeriodicSync(settings.sync.intervalMinutes);
+    imapManager.startOutboxWorker();
+}
+export async function shutdown() {
+    imapManager?.stopPeriodicSync();
+    imapManager?.stopOutboxWorker();
+    await imapManager?.shutdown();
+    db?.close();
+}
+// ── HTML Sanitization ──
+function sanitizeHtml(html) {
+    let hasRemoteContent = false;
+    let clean = html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
+    clean = clean.replace(/\s+on\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+    clean = clean.replace(/<img\b([^>]*)\bsrc\s*=\s*("[^"]*"|'[^']*')/gi, (match, before, src) => {
+        const url = src.slice(1, -1);
+        if (url.startsWith("data:") || url.startsWith("cid:"))
+            return match;
+        hasRemoteContent = true;
+        return `<img${before}src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='20' height='20'%3E%3Crect fill='%23888' width='20' height='20' rx='3'/%3E%3Ctext x='10' y='14' text-anchor='middle' fill='white' font-size='12'%3E⊘%3C/text%3E%3C/svg%3E" data-blocked-src=${src} title="Remote image blocked"`;
+    });
+    clean = clean.replace(/<link\b[^>]*rel\s*=\s*["']stylesheet["'][^>]*>/gi, (match) => {
+        hasRemoteContent = true;
+        return `<!-- blocked: ${match.replace(/--/g, "")} -->`;
+    });
+    clean = clean.replace(/url\s*\(\s*(['"]?)(https?:\/\/[^)]+)\1\s*\)/gi, (_match, _q, url) => {
+        hasRemoteContent = true;
+        return `url("") /* blocked: ${url} */`;
+    });
+    clean = clean.replace(/<\/?form\b[^>]*>/gi, "");
+    clean = clean.replace(/<iframe\b[^>]*>[\s\S]*?<\/iframe>/gi, "");
+    return { html: clean, hasRemoteContent };
+}
+// ── API Functions ──
+export function getAccounts() {
+    return db.getAccounts();
+}
+export function getFolders(params) {
+    return db.getFolders(params.accountId);
+}
+export function getMessages(params) {
+    return db.getMessages({
+        accountId: params.accountId,
+        folderId: params.folderId,
+        page: params.page || 1,
+        pageSize: params.pageSize || 50,
+        sort: params.sort || "date",
+        sortDir: params.sortDir || "desc",
+        search: params.search,
+    });
+}
+export function getUnifiedInbox(params) {
+    return db.getUnifiedInbox(params.page, params.pageSize);
+}
+export async function getMessage(params) {
+    const { accountId, uid } = params;
+    let allowRemote = params.allowRemote || false;
+    const envelope = db.getMessageByUid(accountId, uid, params.folderId);
+    if (!envelope)
+        throw new Error("Message not found");
+    let bodyHtml = "";
+    let bodyText = "";
+    let hasRemoteContent = false;
+    let attachments = [];
+    let deliveredTo = "";
+    let returnPath = "";
+    let listUnsubscribe = "";
+    const raw = await imapManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
+    if (raw) {
+        const parsed = await simpleParser(raw);
+        bodyHtml = parsed.html || "";
+        bodyText = parsed.text || "";
+        attachments = (parsed.attachments || []).map((a, i) => ({
+            id: i,
+            filename: a.filename || `attachment-${i}`,
+            mimeType: a.contentType || "application/octet-stream",
+            size: a.size || 0,
+            contentId: a.contentId || "",
+        }));
+        // Extract useful headers for the UI
+        const hdr = (key) => {
+            const v = parsed.headers.get(key);
+            if (!v)
+                return "";
+            if (typeof v === "string")
+                return v;
+            if (typeof v === "object" && "text" in v)
+                return v.text || "";
+            if (typeof v === "object" && "value" in v)
+                return String(v.value);
+            return String(v);
+        };
+        deliveredTo = hdr("delivered-to");
+        returnPath = hdr("return-path").replace(/[<>]/g, "");
+        listUnsubscribe = hdr("list-unsubscribe");
+    }
+    if (bodyHtml && !allowRemote) {
+        const allowList = loadAllowlist();
+        const senderAddr = envelope.from?.address || "";
+        const senderDomain = senderAddr.split("@")[1] || "";
+        const toAddrs = (envelope.to || []).map((a) => a.address);
+        const isAllowed = allowList.senders.includes(senderAddr) ||
+            allowList.domains.includes(senderDomain) ||
+            toAddrs.some((a) => allowList.recipients?.includes(a));
+        if (isAllowed) {
+            allowRemote = true;
+        }
+        else {
+            const result = sanitizeHtml(bodyHtml);
+            bodyHtml = result.html;
+            hasRemoteContent = result.hasRemoteContent;
+        }
+    }
+    // Build .eml file path for "View Source"
+    const storePath = getStorePath();
+    const emlPath = `${storePath}/${accountId}/${envelope.folderId}/${envelope.uid}.eml`;
+    return { ...envelope, bodyHtml, bodyText, hasRemoteContent, remoteAllowed: allowRemote, attachments, deliveredTo, returnPath, listUnsubscribe, emlPath };
+}
+export async function updateFlags(params) {
+    const envelope = db.getMessageByUid(params.accountId, params.uid);
+    await imapManager.updateFlagsLocal(params.accountId, params.uid, envelope?.folderId || 0, params.flags);
+}
+export async function deleteMessage(params) {
+    const envelope = db.getMessageByUid(params.accountId, params.uid);
+    if (!envelope)
+        throw new Error("Message not found");
+    await imapManager.trashMessage(params.accountId, envelope.folderId, envelope.uid);
+}
+export async function undeleteMessage(params) {
+    await imapManager.undeleteMessage(params.accountId, params.uid, params.folderId);
+}
+export async function sendMessage(params) {
+    const settings = loadSettings();
+    const account = settings.accounts.find(a => a.id === params.from);
+    if (!account)
+        throw new Error(`Unknown account: ${params.from}`);
+    const to = params.to.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+    const cc = params.cc?.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+    const bcc = params.bcc?.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+    const headers = [
+        `From: ${account.name} <${account.email}>`,
+        `To: ${to}`,
+        cc ? `Cc: ${cc}` : null,
+        bcc ? `Bcc: ${bcc}` : null,
+        `Subject: ${params.subject}`,
+        `Date: ${new Date().toUTCString()}`,
+        params.inReplyTo ? `In-Reply-To: ${params.inReplyTo}` : null,
+        params.references?.length ? `References: ${params.references.join(" ")}` : null,
+        `MIME-Version: 1.0`,
+        `Content-Type: text/html; charset=UTF-8`,
+    ].filter(h => h !== null).join("\r\n");
+    const rawMessage = `${headers}\r\n\r\n${params.bodyHtml || params.bodyText || ""}`;
+    imapManager.queueOutgoingLocal(account.id, rawMessage);
+    for (const addr of params.to)
+        db.recordSentAddress(addr.name, addr.address);
+    if (params.cc)
+        for (const addr of params.cc)
+            db.recordSentAddress(addr.name, addr.address);
+    if (params.bcc)
+        for (const addr of params.bcc)
+            db.recordSentAddress(addr.name, addr.address);
+}
+export async function saveDraft(params) {
+    const settings = loadSettings();
+    const account = settings.accounts.find(a => a.id === params.accountId);
+    if (!account)
+        throw new Error(`Unknown account: ${params.accountId}`);
+    const headers = [
+        `From: ${account.name} <${account.email}>`,
+        params.to ? `To: ${params.to}` : null,
+        params.cc ? `Cc: ${params.cc}` : null,
+        `Subject: ${params.subject || "(no subject)"}`,
+        `Date: ${new Date().toUTCString()}`,
+        `MIME-Version: 1.0`,
+        `Content-Type: text/html; charset=UTF-8`,
+    ].filter(h => h !== null).join("\r\n");
+    const raw = `${headers}\r\n\r\n${params.bodyHtml || params.bodyText || ""}`;
+    return await imapManager.saveDraft(params.accountId, raw, params.previousDraftUid);
+}
+export async function deleteDraft(params) {
+    await imapManager.deleteDraft(params.accountId, params.draftUid);
+}
+export function searchMessages(params) {
+    if (!params.query.trim())
+        return { items: [], total: 0, page: 1, pageSize: 50 };
+    return db.searchMessages(params.query, params.page || 1, params.pageSize || 50);
+}
+export function searchContacts(params) {
+    if (params.query.length < 1)
+        return [];
+    return db.searchContacts(params.query);
+}
+export async function syncAll() {
+    await imapManager.syncAll();
+}
+export function getSyncPending() {
+    return { pending: db.getTotalPendingSyncCount() };
+}
+export function allowRemoteContent(params) {
+    const list = loadAllowlist();
+    if (params.type === "sender" && !list.senders.includes(params.value))
+        list.senders.push(params.value);
+    else if (params.type === "domain" && !list.domains.includes(params.value))
+        list.domains.push(params.value);
+    else if (params.type === "recipient") {
+        if (!list.recipients)
+            list.recipients = [];
+        if (!list.recipients.includes(params.value))
+            list.recipients.push(params.value);
+    }
+    saveAllowlist(list);
+}
+export function getSettings() {
+    return loadSettings();
+}
+export function saveSettingsData(data) {
+    saveSettings(data);
+}
+export function rebuildSearchIndex() {
+    return db.rebuildSearchIndex();
+}
+export function seedContacts() {
+    return db.seedContactsFromMessages();
+}
+export async function syncGoogleContacts() {
+    await imapManager.syncAllContacts();
+}
+export function getVersion() {
+    return { server: "1.0.0", client: "1.0.0" }; // Updated by build
+}
+// ── Action dispatcher for IPC ──
+const actions = {
+    getAccounts, getFolders, getMessages, getUnifiedInbox, getMessage,
+    updateFlags, deleteMessage, undeleteMessage, sendMessage,
+    saveDraft, deleteDraft, searchMessages, searchContacts,
+    syncAll, getSyncPending, allowRemoteContent,
+    getSettings, saveSettingsData, rebuildSearchIndex,
+    seedContacts, syncGoogleContacts, getVersion,
+};
+/** Dispatch an action by name — used by IPC and Express wrapper */
+export async function dispatch(action, params = {}) {
+    const fn = actions[action];
+    if (!fn)
+        throw new Error(`Unknown action: ${action}`);
+    return await fn(params);
+}
+export { db, imapManager };
+//# sourceMappingURL=index.js.map