@bobfrankston/mailx 1.0.1

package/packages/mailx-imap/index.js

@@ -0,0 +1,1026 @@
+/**
+ * @bobfrankston/mailx-imap
+ * Multi-account IMAP management wrapping iflow.
+ * Syncs messages to local store, emits events for new mail.
+ */
+import { ImapClient, createAutoImapConfig } from "@bobfrankston/iflow";
+import { authenticateOAuth } from "@bobfrankston/oauthsupport";
+import { FileMessageStore } from "@bobfrankston/mailx-store";
+import { loadSettings, getStorePath } from "@bobfrankston/mailx-settings";
+import { EventEmitter } from "node:events";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { simpleParser } from "mailparser";
+import { createTransport } from "nodemailer";
+import * as os from "node:os";
+/** Convert iflow address objects to our EmailAddress */
+function toEmailAddress(addr) {
+    return {
+        name: addr?.name || "",
+        address: addr?.address || ""
+    };
+}
+/** Convert array of iflow addresses */
+function toEmailAddresses(addrs) {
+    if (!addrs)
+        return [];
+    return addrs.map(toEmailAddress);
+}
+/** Extract a plain-text preview from message source */
+async function extractPreview(source) {
+    try {
+        const parsed = await simpleParser(source);
+        const bodyText = parsed.text || "";
+        const bodyHtml = parsed.html || "";
+        const preview = bodyText.replace(/\s+/g, " ").trim().slice(0, 200);
+        const hasAttachments = (parsed.attachments?.length || 0) > 0;
+        return { bodyHtml, bodyText, preview, hasAttachments };
+    }
+    catch {
+        return { bodyHtml: "", bodyText: "", preview: "", hasAttachments: false };
+    }
+}
+export class ImapManager extends EventEmitter {
+    configs = new Map();
+    watchers = new Map();
+    fetchClients = new Map();
+    db;
+    bodyStore;
+    syncIntervals = new Map();
+    syncing = false;
+    inboxSyncing = false;
+    constructor(db) {
+        super();
+        this.db = db;
+        const storePath = getStorePath();
+        this.bodyStore = new FileMessageStore(storePath);
+    }
+    /** Create a fresh ImapClient for an account (disposable, single-use) */
+    createClient(accountId) {
+        const config = this.configs.get(accountId);
+        if (!config)
+            throw new Error(`No config for account ${accountId}`);
+        return new ImapClient(config);
+    }
+    /** Register an account */
+    async addAccount(account) {
+        if (this.configs.has(account.id))
+            return;
+        // createAutoImapConfig auto-detects Gmail from server/username and sets up OAuth
+        const config = createAutoImapConfig({
+            server: account.imap.host,
+            port: account.imap.port,
+            username: account.imap.user,
+            password: account.imap.password
+        });
+        this.configs.set(account.id, config);
+        // Register account in DB
+        this.db.upsertAccount(account.id, account.name, account.email, JSON.stringify(account));
+    }
+    /** Sync folder list for an account */
+    async syncFolders(accountId, client) {
+        if (!client)
+            client = this.createClient(accountId);
+        this.emit("syncProgress", accountId, "folders", 0);
+        const folders = await client.getFolderList();
+        const specialFolders = client.getSpecialFolders(folders);
+        for (const folder of folders) {
+            // Skip non-selectable folders (virtual parents like "Added", "Added2")
+            const flags = folder.flags;
+            const flagArr = flags instanceof Set ? [...flags] : (flags || []);
+            if (flagArr.some((f) => f.toLowerCase() === "\\noselect" || f.toLowerCase() === "\\nonexistent"))
+                continue;
+            let specialUse = null;
+            if (specialFolders.inbox === folder.path)
+                specialUse = "inbox";
+            else if (specialFolders.sent === folder.path)
+                specialUse = "sent";
+            else if (specialFolders.trash === folder.path)
+                specialUse = "trash";
+            else if (specialFolders.drafts === folder.path)
+                specialUse = "drafts";
+            else if (specialFolders.spam === folder.path || specialFolders.junk === folder.path)
+                specialUse = "junk";
+            else if (specialFolders.archive === folder.path)
+                specialUse = "archive";
+            this.db.upsertFolder(accountId, folder.path, folder.name || folder.path.split(folder.delimiter || "/").pop() || folder.path, specialUse, folder.delimiter || "/");
+        }
+        this.emit("syncProgress", accountId, "folders", 100);
+        const dbFolders = this.db.getFolders(accountId);
+        // Register folder names for human-readable store paths
+        for (const f of dbFolders) {
+            this.bodyStore.registerFolder(f.id, f.path);
+        }
+        return dbFolders;
+    }
+    /** Sync messages for a specific folder */
+    async syncFolder(accountId, folderId, client) {
+        if (!client)
+            client = this.createClient(accountId);
+        const folders = this.db.getFolders(accountId);
+        const folder = folders.find(f => f.id === folderId);
+        if (!folder)
+            throw new Error(`Folder ${folderId} not found`);
+        this.emit("syncProgress", accountId, `sync:${folder.path}`, 0);
+        // Get the highest UID we already have for this folder
+        const highestUid = this.db.getHighestUid(accountId, folderId);
+        let messages;
+        if (highestUid > 0) {
+            // Incremental: only fetch messages newer than what we have
+            const fetched = await client.fetchMessagesSinceUid(folder.path, highestUid, { source: true });
+            // Filter out the last known message (IMAP * always returns at least one)
+            messages = fetched.filter(m => m.uid > highestUid);
+        }
+        else {
+            // First sync: use date-based fetch with bodies for local-first
+            const settings = loadSettings();
+            const historyDays = settings.sync.historyDays || 0;
+            const startDate = historyDays > 0
+                ? new Date(Date.now() - historyDays * 86400000)
+                : new Date(0);
+            messages = await client.fetchMessageByDate(folder.path, startDate, new Date(), { source: true });
+        }
+        if (messages.length > 0)
+            console.log(`  ${folder.path}: ${messages.length} new messages`);
+        let newCount = 0;
+        const batchSize = 50;
+        this.db.beginTransaction();
+        try {
+            for (let i = 0; i < messages.length; i++) {
+                const msg = messages[i];
+                // Skip if we already have this UID
+                if (msg.uid <= highestUid) {
+                    // But update flags in case they changed
+                    const flags = [];
+                    if (msg.seen)
+                        flags.push("\\Seen");
+                    if (msg.flagged)
+                        flags.push("\\Flagged");
+                    if (msg.answered)
+                        flags.push("\\Answered");
+                    if (msg.draft)
+                        flags.push("\\Draft");
+                    this.db.updateMessageFlags(accountId, msg.uid, flags);
+                    continue;
+                }
+                // Store body
+                const source = msg.source || "";
+                let bodyPath = "";
+                if (source) {
+                    bodyPath = await this.bodyStore.putMessage(accountId, folderId, msg.uid, Buffer.from(source, "utf-8"));
+                }
+                // Parse for preview and attachment info
+                const parsed = await extractPreview(source);
+                // Build flags array
+                const flags = [];
+                if (msg.seen)
+                    flags.push("\\Seen");
+                if (msg.flagged)
+                    flags.push("\\Flagged");
+                if (msg.answered)
+                    flags.push("\\Answered");
+                if (msg.draft)
+                    flags.push("\\Draft");
+                // Store metadata
+                this.db.upsertMessage({
+                    accountId,
+                    folderId,
+                    uid: msg.uid,
+                    messageId: msg.messageId || "",
+                    inReplyTo: "",
+                    references: [],
+                    date: msg.date instanceof Date ? msg.date.getTime() : (typeof msg.date === "number" ? msg.date : Date.now()),
+                    subject: msg.subject || "",
+                    from: toEmailAddress(msg.from?.[0] || {}),
+                    to: toEmailAddresses(msg.to || []),
+                    cc: toEmailAddresses(msg.cc || []),
+                    flags,
+                    size: msg.size || 0,
+                    hasAttachments: parsed.hasAttachments,
+                    preview: parsed.preview,
+                    bodyPath
+                });
+                newCount++;
+                // Emit progress periodically
+                if (i % batchSize === 0) {
+                    this.emit("syncProgress", accountId, `sync:${folder.path}`, Math.round((i / messages.length) * 100));
+                }
+            }
+            this.db.commitTransaction();
+            if (newCount > 0)
+                console.log(`    stored ${newCount} new messages`);
+        }
+        catch (e) {
+            console.error(`    transaction error: ${e.message}`);
+            this.db.rollbackTransaction();
+            throw e;
+        }
+        // Remove messages deleted on the server
+        let deletedCount = 0;
+        try {
+            const serverUids = new Set(await client.getUids(folder.path));
+            const localUids = this.db.getUidsForFolder(accountId, folderId);
+            for (const uid of localUids) {
+                if (!serverUids.has(uid)) {
+                    this.db.deleteMessage(accountId, uid);
+                    // Also remove cached body
+                    this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
+                    deletedCount++;
+                }
+            }
+            if (deletedCount > 0)
+                console.log(`    removed ${deletedCount} deleted messages`);
+        }
+        catch (e) {
+            console.error(`    deletion sync error: ${e.message}`);
+        }
+        // Update folder counts from local DB (after deletions + additions)
+        const result = this.db.getMessages({ accountId, folderId, page: 1, pageSize: 1 });
+        const total = result.total;
+        const localMsgs = this.db.getMessages({ accountId, folderId, page: 1, pageSize: result.total });
+        const unread = localMsgs.items.filter((m) => !m.flags.includes("\\Seen")).length;
+        this.db.updateFolderCounts(folderId, total, unread);
+        this.emit("syncProgress", accountId, `sync:${folder.path}`, 100);
+        // Notify client to refresh if anything changed
+        if (newCount > 0 || deletedCount > 0) {
+            this.emit("folderCountsChanged", accountId, {
+                [folderId]: { total, unread }
+            });
+        }
+        this.db.updateLastSync(accountId, Date.now());
+        return newCount;
+    }
+    /** Sync all folders for all accounts */
+    async syncAll() {
+        if (this.syncing)
+            return; // Prevent concurrent syncs
+        this.syncing = true;
+        try {
+            await this._syncAll();
+        }
+        finally {
+            this.syncing = false;
+        }
+    }
+    async _syncAll() {
+        for (const [accountId] of this.configs) {
+            let client = null;
+            try {
+                // Fresh client for folder list
+                client = this.createClient(accountId);
+                const folders = await this.syncFolders(accountId, client);
+                await client.logout();
+                client = null;
+                // Fresh client for message sync (getFolderList corrupts imapflow state)
+                client = this.createClient(accountId);
+                // INBOX first so it's available fastest
+                folders.sort((a, b) => {
+                    if (a.specialUse === "inbox")
+                        return -1;
+                    if (b.specialUse === "inbox")
+                        return 1;
+                    return 0;
+                });
+                for (const folder of folders) {
+                    try {
+                        await this.syncFolder(accountId, folder.id, client);
+                    }
+                    catch (e) {
+                        if (e.responseText?.includes("doesn't exist")) {
+                            console.log(`  Removing non-existent folder: ${folder.path}`);
+                            this.db.deleteFolder(folder.id);
+                        }
+                        else {
+                            console.error(`  Skipping folder ${folder.path}: ${e.message}`);
+                        }
+                    }
+                }
+                await client.logout();
+                client = null;
+                this.emit("syncComplete", accountId);
+            }
+            catch (e) {
+                this.emit("syncError", accountId, e.message);
+                console.error(`Sync error for ${accountId}: ${e.message}`);
+            }
+            finally {
+                if (client)
+                    try {
+                        await client.logout();
+                    }
+                    catch { /* ignore */ }
+            }
+        }
+    }
+    /** Sync just INBOX for each account (fast check for new mail) */
+    async syncInbox() {
+        if (this.inboxSyncing)
+            return;
+        this.inboxSyncing = true;
+        try {
+            for (const [accountId] of this.configs) {
+                let client = null;
+                try {
+                    const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+                    if (!inbox)
+                        continue;
+                    // Try up to 2 times with fresh clients
+                    for (let attempt = 0; attempt < 2; attempt++) {
+                        try {
+                            client = this.createClient(accountId);
+                            await this.syncFolder(accountId, inbox.id, client);
+                            await client.logout();
+                            client = null;
+                            break;
+                        }
+                        catch (retryErr) {
+                            if (client)
+                                try {
+                                    await client.logout();
+                                }
+                                catch { /* ignore */ }
+                            client = null;
+                            if (attempt === 1)
+                                throw retryErr;
+                        }
+                    }
+                }
+                catch (e) {
+                    console.error(`  [inbox] Sync error for ${accountId}: ${e.message}`);
+                }
+                finally {
+                    if (client)
+                        try {
+                            await client.logout();
+                        }
+                        catch { /* ignore */ }
+                }
+            }
+        }
+        finally {
+            this.inboxSyncing = false;
+        }
+    }
+    /** Start periodic sync */
+    startPeriodicSync(intervalMinutes) {
+        this.stopPeriodicSync();
+        // INBOX poll + sync actions (IDLE handles instant, this catches gaps)
+        const inboxInterval = setInterval(async () => {
+            // Process pending local→IMAP sync actions (sends + flags/deletes/moves)
+            for (const [accountId] of this.configs) {
+                this.processSendActions(accountId).catch(() => { });
+                this.processSyncActions(accountId).catch(() => { });
+            }
+            this.syncInbox().catch(e => console.error(`  [inbox] error: ${e.message}`));
+        }, 30000);
+        this.syncIntervals.set("inbox", inboxInterval);
+        // Full sync (all folders + IDLE restart) at configured interval
+        const fullInterval = setInterval(async () => {
+            console.log(`  [periodic] Full sync at ${new Date().toLocaleTimeString()}`);
+            await this.syncAll();
+            await this.stopWatching();
+            await this.startWatching();
+        }, intervalMinutes * 60000);
+        this.syncIntervals.set("all", fullInterval);
+    }
+    /** Stop periodic sync */
+    stopPeriodicSync() {
+        for (const [key, interval] of this.syncIntervals) {
+            clearInterval(interval);
+        }
+        this.syncIntervals.clear();
+    }
+    /** Start IMAP IDLE watchers for INBOX on each account */
+    async startWatching() {
+        for (const [accountId] of this.configs) {
+            if (this.watchers.has(accountId))
+                continue;
+            try {
+                const watchClient = this.createClient(accountId);
+                const stop = await watchClient.watchMailbox("INBOX", (newCount) => {
+                    console.log(`  [idle] ${accountId}: ${newCount} new message(s)`);
+                    this.syncAll().catch(e => console.error(`  [idle] sync error: ${e.message}`));
+                });
+                this.watchers.set(accountId, async () => {
+                    await stop();
+                    await watchClient.logout();
+                });
+                console.log(`  [idle] Watching INBOX for ${accountId}`);
+            }
+            catch (e) {
+                console.error(`  [idle] Failed to watch ${accountId}: ${e.message}`);
+            }
+        }
+    }
+    /** Stop all IDLE watchers */
+    async stopWatching() {
+        for (const [id, stop] of this.watchers) {
+            try {
+                await stop();
+            }
+            catch { /* ignore */ }
+        }
+        this.watchers.clear();
+    }
+    /** Get or create a persistent client for body fetching */
+    getFetchClient(accountId) {
+        let client = this.fetchClients.get(accountId);
+        if (!client) {
+            client = this.createClient(accountId);
+            this.fetchClients.set(accountId, client);
+        }
+        return client;
+    }
+    /** Fetch a single message body on demand, caching in the store */
+    async fetchMessageBody(accountId, folderId, uid) {
+        // Already cached?
+        if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
+            return this.bodyStore.getMessage(accountId, folderId, uid);
+        }
+        if (!this.configs.has(accountId))
+            return null;
+        const folder = this.db.getFolders(accountId).find(f => f.id === folderId);
+        if (!folder)
+            return null;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const client = this.getFetchClient(accountId);
+                const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
+                if (!msg?.source)
+                    return null;
+                const raw = Buffer.from(msg.source, "utf-8");
+                await this.bodyStore.putMessage(accountId, folderId, uid, raw);
+                return raw;
+            }
+            catch (e) {
+                console.error(`  Body fetch error (${accountId}/${uid}): ${e.message}`);
+                this.fetchClients.delete(accountId);
+                if (attempt === 1)
+                    return null;
+                // Retry with fresh client
+            }
+        }
+        return null;
+    }
+    /** Get the body store for direct access */
+    getBodyStore() {
+        return this.bodyStore;
+    }
+    /** Move a message to Trash (delete) — local-first, queues IMAP sync */
+    async trashMessage(accountId, folderId, uid) {
+        const trash = this.findFolder(accountId, "trash");
+        // Local first — remove from DB immediately
+        this.db.deleteMessage(accountId, uid);
+        this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
+        console.log(`  Deleted message UID ${uid} locally`);
+        // Queue IMAP action
+        if (trash && trash.id !== folderId) {
+            this.db.queueSyncAction(accountId, "move", uid, folderId, { targetFolderId: trash.id });
+        }
+        else {
+            this.db.queueSyncAction(accountId, "delete", uid, folderId);
+        }
+        // Try immediate sync
+        this.processSyncActions(accountId).catch(() => { });
+    }
+    /** Move a message between folders — local-first, queues IMAP sync */
+    async moveMessage(accountId, uid, fromFolderId, toFolderId) {
+        // Local first
+        this.db.deleteMessage(accountId, uid);
+        console.log(`  Moved UID ${uid} locally (folder ${fromFolderId} → ${toFolderId})`);
+        // Queue IMAP action
+        this.db.queueSyncAction(accountId, "move", uid, fromFolderId, { targetFolderId: toFolderId });
+        // Try immediate sync
+        this.processSyncActions(accountId).catch(() => { });
+    }
+    /** Undelete — move from Trash back to original folder */
+    async undeleteMessage(accountId, uid, originalFolderId) {
+        const trash = this.findFolder(accountId, "trash");
+        if (!trash)
+            throw new Error("No Trash folder found");
+        await this.moveMessage(accountId, uid, trash.id, originalFolderId);
+    }
+    /** Update flags — local-first, queues IMAP sync */
+    async updateFlagsLocal(accountId, uid, folderId, flags) {
+        this.db.updateMessageFlags(accountId, uid, flags);
+        this.db.queueSyncAction(accountId, "flags", uid, folderId, { flags });
+        this.processSyncActions(accountId).catch(() => { });
+    }
+    /** Process pending sync actions for an account */
+    async processSyncActions(accountId) {
+        const actions = this.db.getPendingSyncActions(accountId);
+        if (actions.length === 0)
+            return;
+        const folders = this.db.getFolders(accountId);
+        const client = this.createClient(accountId);
+        try {
+            for (const action of actions) {
+                const folder = folders.find(f => f.id === action.folderId);
+                if (!folder) {
+                    this.db.completeSyncAction(action.id);
+                    continue;
+                }
+                try {
+                    switch (action.action) {
+                        case "delete":
+                            await client.deleteMessageByUid(folder.path, action.uid);
+                            console.log(`  [sync] Deleted UID ${action.uid} from ${folder.path}`);
+                            break;
+                        case "move": {
+                            const target = folders.find(f => f.id === action.targetFolderId);
+                            if (target) {
+                                const msg = await client.fetchMessageByUid(folder.path, action.uid, { source: false });
+                                if (msg) {
+                                    await client.moveMessage(msg, folder.path, target.path);
+                                    console.log(`  [sync] Moved UID ${action.uid}: ${folder.path} → ${target.path}`);
+                                }
+                            }
+                            break;
+                        }
+                        case "flags":
+                            if (action.flags.length > 0) {
+                                await client.addFlags(folder.path, action.uid, action.flags.filter(f => !f.startsWith("-")));
+                                const toRemove = action.flags.filter(f => f.startsWith("-")).map(f => f.slice(1));
+                                if (toRemove.length > 0) {
+                                    await client.removeFlags(folder.path, action.uid, toRemove);
+                                }
+                                console.log(`  [sync] Updated flags UID ${action.uid}`);
+                            }
+                            break;
+                        case "append": {
+                            if (action.rawMessage) {
+                                await client.appendMessage(folder.path, action.rawMessage, action.flags);
+                                console.log(`  [sync] Appended to ${folder.path}`);
+                            }
+                            break;
+                        }
+                    }
+                    this.db.completeSyncAction(action.id);
+                }
+                catch (e) {
+                    console.error(`  [sync] Failed action ${action.action} UID ${action.uid}: ${e.message}`);
+                    this.db.failSyncAction(action.id, e.message);
+                    if (action.attempts >= 5) {
+                        console.error(`  [sync] Giving up on action ${action.id} after 5 attempts`);
+                        this.db.completeSyncAction(action.id);
+                    }
+                }
+            }
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Find a folder by specialUse, case-insensitive */
+    findFolder(accountId, specialUse) {
+        const folders = this.db.getFolders(accountId);
+        return folders.find(f => f.specialUse === specialUse ||
+            f.path.toLowerCase() === specialUse.toLowerCase()) || null;
+    }
+    /** Copy sent message to the Sent folder via IMAP APPEND */
+    async copyToSent(accountId, rawMessage) {
+        const sent = this.findFolder(accountId, "sent");
+        if (!sent) {
+            console.error(`  [sent] No Sent folder found for ${accountId}`);
+            return;
+        }
+        const client = this.createClient(accountId);
+        try {
+            await client.appendMessage(sent.path, rawMessage, ["\\Seen"]);
+            console.log(`  [sent] Copied to ${sent.path}`);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Save a draft to the Drafts folder via IMAP APPEND.
+     *  Returns the UID of the saved draft (for replacing on next save). */
+    async saveDraft(accountId, rawMessage, previousDraftUid) {
+        const drafts = this.findFolder(accountId, "drafts");
+        if (!drafts) {
+            console.error(`  [drafts] No Drafts folder found for ${accountId}`);
+            return null;
+        }
+        const client = this.createClient(accountId);
+        try {
+            // Delete previous draft if it exists
+            if (previousDraftUid) {
+                try {
+                    await client.deleteMessageByUid(drafts.path, previousDraftUid);
+                }
+                catch { /* previous draft may already be gone */ }
+            }
+            // Append new draft
+            const result = await client.appendMessage(drafts.path, rawMessage, ["\\Draft", "\\Seen"]);
+            // imapflow append returns { destination, uid }
+            const uid = result?.uid || null;
+            return uid;
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Delete a draft after successful send */
+    async deleteDraft(accountId, draftUid) {
+        const drafts = this.findFolder(accountId, "drafts");
+        if (!drafts || !draftUid)
+            return;
+        const client = this.createClient(accountId);
+        try {
+            await client.deleteMessageByUid(drafts.path, draftUid);
+            console.log(`  [drafts] Deleted draft UID ${draftUid}`);
+        }
+        catch (e) {
+            console.error(`  [drafts] Delete error: ${e.message}`);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP */
+    queueOutgoingLocal(accountId, rawMessage) {
+        // Use folderId=0 and uid=Date.now() as placeholder — the worker will handle the real IMAP append
+        this.db.queueSyncAction(accountId, "send", Date.now(), 0, { rawMessage });
+        console.log(`  [outbox] Queued locally for ${accountId}`);
+        // Try immediate processing
+        this.processSendActions(accountId).catch(() => { });
+    }
+    /** Process local send actions — APPEND to Outbox, which the outbox worker then sends */
+    async processSendActions(accountId) {
+        const actions = this.db.getPendingSyncActions(accountId)
+            .filter(a => a.action === "send");
+        if (actions.length === 0)
+            return;
+        for (const action of actions) {
+            if (!action.rawMessage) {
+                this.db.completeSyncAction(action.id);
+                continue;
+            }
+            try {
+                await this.queueOutgoing(accountId, action.rawMessage);
+                this.db.completeSyncAction(action.id);
+            }
+            catch (e) {
+                console.error(`  [outbox] Local→IMAP failed: ${e.message}`);
+                this.db.failSyncAction(action.id, e.message);
+                // Don't give up — keep retrying sends
+            }
+        }
+    }
+    // ── Outbox ──
+    outboxInterval = null;
+    hostname = os.hostname();
+    /** Ensure Outbox folder exists, create if needed */
+    async ensureOutbox(accountId) {
+        let outbox = this.findFolder(accountId, "outbox");
+        if (outbox)
+            return outbox.path;
+        // Look for existing folder named Outbox (case-insensitive)
+        const folders = this.db.getFolders(accountId);
+        const existing = folders.find(f => f.path.toLowerCase() === "outbox");
+        if (existing)
+            return existing.path;
+        // Create it
+        const client = this.createClient(accountId);
+        try {
+            await client.createmailbox("Outbox");
+            // Sync folders to pick up the new one
+            await this.syncFolders(accountId, client);
+            await client.logout();
+        }
+        catch (e) {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+            // Might already exist
+            if (!e.message?.includes("already exists"))
+                throw e;
+        }
+        outbox = this.findFolder(accountId, "outbox");
+        return outbox?.path || "Outbox";
+    }
+    /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
+    async queueOutgoing(accountId, rawMessage) {
+        try {
+            const outboxPath = await this.ensureOutbox(accountId);
+            const client = this.createClient(accountId);
+            try {
+                await client.appendMessage(outboxPath, rawMessage, ["\\Seen"]);
+                console.log(`  [outbox] Queued message in ${outboxPath}`);
+                return;
+            }
+            finally {
+                try {
+                    await client.logout();
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch (e) {
+            console.error(`  [outbox] IMAP queue failed: ${e.message} — saving locally`);
+        }
+        // Fallback: save to local file queue
+        const localQueue = path.join(import.meta.dirname, "..", "..", "outbox", accountId);
+        fs.mkdirSync(localQueue, { recursive: true });
+        const now = new Date();
+        const pad2 = (n) => String(n).padStart(2, "0");
+        const filename = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}-${String(Math.floor(Math.random() * 10000)).padStart(4, "0")}.ltr`;
+        fs.writeFileSync(path.join(localQueue, filename), rawMessage);
+        console.log(`  [outbox] Saved locally: ${filename}`);
+    }
+    /** Process local file queue — move to IMAP Outbox when server is reachable */
+    async processLocalQueue(accountId) {
+        const localQueue = path.join(import.meta.dirname, "..", "..", "outbox", accountId);
+        if (!fs.existsSync(localQueue))
+            return;
+        const files = fs.readdirSync(localQueue).filter(f => f.endsWith(".ltr"));
+        if (files.length === 0)
+            return;
+        try {
+            const outboxPath = await this.ensureOutbox(accountId);
+            const client = this.createClient(accountId);
+            try {
+                for (const file of files) {
+                    const filePath = path.join(localQueue, file);
+                    const raw = fs.readFileSync(filePath, "utf-8");
+                    await client.appendMessage(outboxPath, raw, ["\\Seen"]);
+                    fs.unlinkSync(filePath);
+                    console.log(`  [outbox] Moved local ${file} to IMAP Outbox`);
+                }
+            }
+            finally {
+                try {
+                    await client.logout();
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch {
+            // IMAP still unreachable — leave files for next attempt
+        }
+    }
+    /** Process Outbox — send pending messages with flag-based interlock */
+    async processOutbox(accountId) {
+        const outboxFolder = this.findFolder(accountId, "outbox");
+        if (!outboxFolder)
+            return;
+        const settings = loadSettings();
+        const account = settings.accounts.find(a => a.id === accountId);
+        if (!account)
+            return;
+        const client = this.createClient(accountId);
+        try {
+            // Get all UIDs in Outbox
+            const uids = await client.getUids(outboxFolder.path);
+            if (uids.length === 0)
+                return;
+            const sendingFlag = `$Sending-${this.hostname}`;
+            for (const uid of uids) {
+                // Check flags — skip if already being sent or permanently failed
+                const flags = await client.getFlags(outboxFolder.path, uid);
+                if (flags.some(f => f.startsWith("$Sending")))
+                    continue;
+                if (flags.includes("$PermanentFailure"))
+                    continue;
+                if (flags.includes("$Failed")) {
+                    // Retry: remove failed flag
+                    await client.removeFlags(outboxFolder.path, uid, ["$Failed"]);
+                }
+                // Claim this message
+                await client.addFlags(outboxFolder.path, uid, [sendingFlag]);
+                // Re-check — did we win the race?
+                const flagsAfter = await client.getFlags(outboxFolder.path, uid);
+                const sendingFlags = flagsAfter.filter(f => f.startsWith("$Sending"));
+                if (sendingFlags.length > 1 || (sendingFlags.length === 1 && sendingFlags[0] !== sendingFlag)) {
+                    // Another machine claimed it — back off
+                    await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
+                    continue;
+                }
+                // Fetch the raw message
+                const msg = await client.fetchMessageByUid(outboxFolder.path, uid, { source: true });
+                if (!msg?.source) {
+                    await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
+                    continue;
+                }
+                // Send via SMTP
+                try {
+                    const transport = createTransport({
+                        host: account.smtp.host,
+                        port: account.smtp.port,
+                        secure: account.smtp.port === 465,
+                        auth: account.smtp.auth === "password"
+                            ? { user: account.smtp.user, pass: account.smtp.password }
+                            : undefined,
+                        tls: { rejectUnauthorized: false },
+                    });
+                    // Parse recipients from raw message headers for SMTP envelope
+                    const toMatch = msg.source.match(/^To:\s*(.+)$/mi);
+                    const ccMatch = msg.source.match(/^Cc:\s*(.+)$/mi);
+                    const bccMatch = msg.source.match(/^Bcc:\s*(.+)$/mi);
+                    const fromMatch = msg.source.match(/^From:\s*(.+)$/mi);
+                    const parseAddrs = (s) => s.match(/[\w.+-]+@[\w.-]+/g) || [];
+                    const recipients = [
+                        ...(toMatch ? parseAddrs(toMatch[1]) : []),
+                        ...(ccMatch ? parseAddrs(ccMatch[1]) : []),
+                        ...(bccMatch ? parseAddrs(bccMatch[1]) : []),
+                    ];
+                    const sender = fromMatch ? (parseAddrs(fromMatch[1])[0] || account.email) : account.email;
+                    if (recipients.length === 0) {
+                        console.error(`  [outbox] No recipients in UID ${uid} — permanent failure`);
+                        await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
+                        await client.addFlags(outboxFolder.path, uid, ["$PermanentFailure"]);
+                        continue;
+                    }
+                    // Strip Bcc header from raw message before sending
+                    const rawToSend = msg.source.replace(/^Bcc:.*\r?\n/mi, "");
+                    await transport.sendMail({
+                        raw: rawToSend,
+                        envelope: { from: sender, to: recipients },
+                    });
+                    console.log(`  [outbox] Sent UID ${uid} → ${recipients.join(", ")}`);
+                    // Move to Sent
+                    const sentFolder = this.findFolder(accountId, "sent");
+                    if (sentFolder) {
+                        await client.moveMessage(msg, outboxFolder.path, sentFolder.path);
+                    }
+                    else {
+                        await client.deleteMessageByUid(outboxFolder.path, uid);
+                    }
+                }
+                catch (e) {
+                    console.error(`  [outbox] Send failed UID ${uid}: ${e.message}`);
+                    await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
+                    await client.addFlags(outboxFolder.path, uid, ["$Failed"]);
+                }
+            }
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Start background Outbox worker — checks every 10 seconds */
+    startOutboxWorker() {
+        if (this.outboxInterval)
+            return;
+        this.outboxInterval = setInterval(async () => {
+            for (const [accountId] of this.configs) {
+                try {
+                    // First move any local queued messages to IMAP
+                    await this.processLocalQueue(accountId);
+                    // Then process IMAP Outbox
+                    await this.processOutbox(accountId);
+                }
+                catch (e) {
+                    console.error(`  [outbox] Error for ${accountId}: ${e.message}`);
+                }
+            }
+        }, 10000);
+    }
+    /** Stop Outbox worker */
+    stopOutboxWorker() {
+        if (this.outboxInterval) {
+            clearInterval(this.outboxInterval);
+            this.outboxInterval = null;
+        }
+    }
+    // ── Google Contacts Sync ──
+    contactsSyncToken = null;
+    /** Get an OAuth token for Google Contacts API */
+    async getContactsToken(accountId) {
+        const settings = loadSettings();
+        const account = settings.accounts.find(a => a.id === accountId);
+        if (!account || account.imap.auth !== "oauth2")
+            return null;
+        // Find credentials.json — same as iflow uses
+        const iflowDir = path.resolve(import.meta.dirname, "..", "..", "..", "MailApps", "iflow");
+        const credentialsPath = path.join(iflowDir, "credentials.json");
+        if (!fs.existsSync(credentialsPath)) {
+            console.error("  [contacts] credentials.json not found at", credentialsPath);
+            return null;
+        }
+        const accountDir = account.imap.user.replace(/[@.]/g, "_");
+        const tokenDir = path.join(iflowDir, "tokens", accountDir);
+        const token = await authenticateOAuth(credentialsPath, {
+            scope: "https://www.googleapis.com/auth/contacts.readonly",
+            tokenDirectory: tokenDir,
+            tokenFileName: "contacts-token.json",
+            credentialsKey: "installed",
+            includeOfflineAccess: true,
+            loginHint: account.imap.user,
+        });
+        return token?.access_token || null;
+    }
+    /** Sync contacts from Google People API */
+    async syncGoogleContacts(accountId) {
+        const token = await this.getContactsToken(accountId);
+        if (!token)
+            return 0;
+        let added = 0;
+        let nextPageToken;
+        const now = Date.now();
+        try {
+            do {
+                const params = new URLSearchParams({
+                    personFields: "names,emailAddresses,organizations,photos",
+                    pageSize: "100",
+                });
+                if (nextPageToken)
+                    params.set("pageToken", nextPageToken);
+                if (this.contactsSyncToken)
+                    params.set("syncToken", this.contactsSyncToken);
+                const url = `https://people.googleapis.com/v1/people/me/connections?${params}`;
+                const res = await fetch(url, {
+                    headers: { Authorization: `Bearer ${token}` },
+                });
+                if (res.status === 410) {
+                    // Sync token expired — do full sync
+                    this.contactsSyncToken = null;
+                    return this.syncGoogleContacts(accountId);
+                }
+                if (!res.ok) {
+                    const err = await res.text();
+                    console.error(`  [contacts] API error: ${res.status} ${err}`);
+                    return added;
+                }
+                const data = await res.json();
+                if (data.connections) {
+                    for (const person of data.connections) {
+                        const emails = person.emailAddresses || [];
+                        const names = person.names || [];
+                        const orgs = person.organizations || [];
+                        const name = names[0]?.displayName || "";
+                        const org = orgs[0]?.name || "";
+                        const googleId = person.resourceName || "";
+                        for (const emailEntry of emails) {
+                            const email = emailEntry.value?.toLowerCase();
+                            if (!email)
+                                continue;
+                            // Upsert into contacts
+                            const existing = this.db.searchContacts(email, 1);
+                            if (existing.length > 0 && existing[0].email === email) {
+                                // Update name/org if from google
+                                this.db.recordSentAddress(name, email);
+                            }
+                            else {
+                                this.db.recordSentAddress(name, email);
+                                added++;
+                            }
+                            // Update google-specific fields
+                            try {
+                                this.db.db.prepare("UPDATE contacts SET source = 'google', google_id = ?, organization = ?, updated_at = ? WHERE email = ?").run(googleId, org, now, email);
+                            }
+                            catch { /* ignore */ }
+                        }
+                    }
+                }
+                nextPageToken = data.nextPageToken;
+                if (data.nextSyncToken)
+                    this.contactsSyncToken = data.nextSyncToken;
+            } while (nextPageToken);
+            console.log(`  [contacts] Synced ${added} new contacts from Google`);
+        }
+        catch (e) {
+            console.error(`  [contacts] Sync error: ${e.message}`);
+        }
+        return added;
+    }
+    /** Sync contacts for all OAuth accounts */
+    async syncAllContacts() {
+        const settings = loadSettings();
+        for (const account of settings.accounts) {
+            if (account.imap.auth === "oauth2" && account.enabled) {
+                await this.syncGoogleContacts(account.id);
+            }
+        }
+    }
+    /** Shut down all watchers and timers */
+    async shutdown() {
+        this.stopPeriodicSync();
+        this.stopOutboxWorker();
+        await this.stopWatching();
+        for (const [, client] of this.fetchClients) {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+        this.fetchClients.clear();
+    }
+}
+//# sourceMappingURL=index.js.map