@bobfrankston/mailx 1.0.132 → 1.0.134

package/client/app.js

@@ -428,6 +428,7 @@ function doSearch(immediate = false) {
 // Track current folder for scoped search
 let currentAccountId = "";
 let currentFolderId = 0;
+let reloadDebounceTimer = null;
 searchInput?.addEventListener("input", () => {
     clearTimeout(searchTimeout);
     searchTimeout = setTimeout(() => doSearch(false), 300);
@@ -585,8 +586,19 @@ onWsEvent((event) => {
             // Incremental count update — no DOM rebuild, no jitter
             updateFolderCounts();
             updateNewMessageCount();
-            // Reload message list but keep current scroll position and selection
-            reloadCurrentFolder();
+            // Only reload message list if the synced account is the one we're viewing
+            // (or unified inbox which shows all accounts). Debounce to avoid rapid reloads
+            // during first sync which emits per-batch.
+            const syncedAccount = event.accountId;
+            const viewingThis = !currentAccountId || currentAccountId === syncedAccount;
+            if (viewingThis) {
+                if (reloadDebounceTimer)
+                    clearTimeout(reloadDebounceTimer);
+                reloadDebounceTimer = setTimeout(() => {
+                    reloadDebounceTimer = null;
+                    reloadCurrentFolder();
+                }, 500);
+            }
             // Sync finished — re-enable sync button
             const syncBtn = document.getElementById("btn-sync");
             if (syncBtn) {

package/client/components/message-list.js

@@ -94,7 +94,10 @@ export async function loadUnifiedInbox(autoSelect = true) {
         return;
     const savedScroll = !autoSelect ? body.scrollTop : 0;
     const savedUid = !autoSelect ? body.querySelector(".ml-row.selected")?.getAttribute("data-uid") : null;
-    body.innerHTML = `<div class="ml-empty">Loading...</div>`;
+    // Only show loading indicator on fresh navigation, not reloads
+    if (autoSelect) {
+        body.innerHTML = `<div class="ml-empty">Loading...</div>`;
+    }
     try {
         const result = await getUnifiedInbox(1);
         totalMessages = result.total;
@@ -103,8 +106,13 @@ export async function loadUnifiedInbox(autoSelect = true) {
             clearViewer();
             return;
         }
-        body.innerHTML = "";
-        appendMessages(body, "", result.items);
+        // Build new rows into a fragment, then swap atomically (no flash)
+        const fragment = document.createDocumentFragment();
+        const tempDiv = document.createElement("div");
+        appendMessages(tempDiv, "", result.items);
+        while (tempDiv.firstChild)
+            fragment.appendChild(tempDiv.firstChild);
+        body.replaceChildren(fragment);
         if (autoSelect) {
             const firstRow = body.querySelector(".ml-row");
             if (firstRow)
@@ -209,8 +217,13 @@ export async function loadMessages(accountId, folderId, page = 1, specialUse = "
             clearViewer();
             return;
         }
-        body.innerHTML = "";
-        appendMessages(body, accountId, result.items);
+        // Build new rows into a fragment, then swap atomically (no flash)
+        const fragment = document.createDocumentFragment();
+        const tempDiv = document.createElement("div");
+        appendMessages(tempDiv, accountId, result.items);
+        while (tempDiv.firstChild)
+            fragment.appendChild(tempDiv.firstChild);
+        body.replaceChildren(fragment);
         if (autoSelect) {
             // Explicit folder navigation — select first message
             const firstRow = body.querySelector(".ml-row");

package/client/compose/compose.js

@@ -300,15 +300,20 @@ if (fromSelect.options.length === 0) {
 }
 // ── Auto-save drafts every 5 seconds ──
 let draftUid = null;
+let draftId = null; // stable ID for dedup when APPENDUID unavailable
 let draftTimer;
 let lastDraftContent = "";
+let draftSaving = false; // prevent concurrent saves
 async function saveDraft() {
+    if (draftSaving)
+        return; // previous save still in flight
     const content = editor.getHtml() + subjectInput.value + toInput.value;
     if (content === lastDraftContent)
         return; // no changes
     if (!editor.getText().trim() && !subjectInput.value && !toInput.value)
         return; // empty
     lastDraftContent = content;
+    draftSaving = true;
     try {
         const data = await fetch("/api/draft", {
             method: "POST",
@@ -321,12 +326,18 @@ async function saveDraft() {
                 to: toInput.value,
                 cc: ccInput.value,
                 previousDraftUid: draftUid,
+                draftId: draftId,
             }),
         }).then(r => r.ok ? r.json() : null);
         if (data?.draftUid)
             draftUid = data.draftUid;
+        if (data?.draftId)
+            draftId = data.draftId;
     }
     catch { /* ignore draft save errors */ }
+    finally {
+        draftSaving = false;
+    }
 }
 draftTimer = setInterval(saveDraft, 5000);
 // ── Send ──

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.132",
+  "version": "1.0.134",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

package/packages/mailx-api/index.js

@@ -344,9 +344,9 @@ export function createApiRouter(db, imapManager) {
     // ── Drafts ──
     router.post("/draft", async (req, res) => {
         try {
-            const { accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid } = req.body;
-            const uid = await svc.saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid);
-            res.json({ ok: true, draftUid: uid });
+            const { accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId } = req.body;
+            const result = await svc.saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId);
+            res.json({ ok: true, draftUid: result.uid, draftId: result.draftId });
         }
         catch (e) {
             res.status(500).json({ error: e.message });

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

@@ -71,18 +71,28 @@ export declare class ImapManager extends EventEmitter {
     /** Sync just INBOX for each account (fast check for new mail) */
     syncInbox(): Promise<void>;
     /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
-     *  If message count changed, triggers a full inbox sync. */
+     *  If message count changed, triggers inbox sync for that account. */
     private lastInboxCounts;
     private quickCheckRunning;
+    /** Check a single account's inbox */
+    quickInboxCheckAccount(accountId: string): Promise<void>;
+    /** Check all accounts (used by legacy callers) */
     quickInboxCheck(): Promise<void>;
     /** Start periodic sync */
     startPeriodicSync(intervalMinutes: number): void;
     /** Stop periodic sync */
     stopPeriodicSync(): void;
+    /** Check if an account is OAuth (Gmail/Outlook — generous connection limits) */
+    isOAuthAccount(accountId: string): boolean;
     /** Start IMAP IDLE watchers for INBOX on each account */
     startWatching(): Promise<void>;
     /** Stop all IDLE watchers */
     stopWatching(): Promise<void>;
+    /** Per-account fetch queue — serializes body fetches so only one IMAP command runs at a time.
+     *  The persistent fetchClient can only handle one command at a time (IMAP protocol limitation). */
+    private fetchQueues;
+    /** Serialize body fetch operations per account — prevents concurrent IMAP commands on same connection */
+    private enqueueFetch;
     /** Get or create a persistent client for body fetching */
     private getFetchClient;
     /** Fetch a single message body on demand, caching in the store */
@@ -120,17 +130,22 @@ export declare class ImapManager extends EventEmitter {
     copyToSent(accountId: string, rawMessage: string | Buffer): Promise<void>;
     /** Save a draft to the Drafts folder via IMAP APPEND.
      *  Returns the UID of the saved draft (for replacing on next save). */
-    saveDraft(accountId: string, rawMessage: string | Buffer, previousDraftUid?: number): Promise<number | null>;
+    saveDraft(accountId: string, rawMessage: string | Buffer, previousDraftUid?: number, draftId?: string): Promise<number | null>;
     /** Delete a draft after successful send */
     deleteDraft(accountId: string, draftUid: number): Promise<void>;
     /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP */
     queueOutgoingLocal(accountId: string, rawMessage: string): void;
+    /** Guard against concurrent processSendActions for the same account */
+    private sendingAccounts;
     /** Process local send actions — APPEND to Outbox, which the outbox worker then sends */
     private processSendActions;
+    private _processSendActions;
     private outboxInterval;
     private readonly hostname;
     /** Ensure Outbox folder exists, create if needed */
     private ensureOutbox;
+    /** Save a debug copy of outgoing mail to the sending directory */
+    private saveSendingCopy;
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     queueOutgoing(accountId: string, rawMessage: string | Buffer): Promise<void>;
     /** Process local file queue — move to IMAP Outbox when server is reachable */

package/packages/mailx-imap/index.js

@@ -214,13 +214,28 @@ export class ImapManager extends EventEmitter {
         // Wrap logout to auto-decrement connection counter (prevents leaks from missed trackLogout calls)
         const originalLogout = client.logout.bind(client);
         let loggedOut = false;
-        client.logout = async () => {
-            await originalLogout();
+        const doTrackLogout = () => {
             if (!loggedOut) {
                 loggedOut = true;
                 this.trackLogout(accountId);
             }
         };
+        client.logout = async () => {
+            await originalLogout();
+            doTrackLogout();
+        };
+        // Safety net: if client isn't logged out within 5 minutes, assume it leaked
+        const leakTimer = setTimeout(() => {
+            if (!loggedOut) {
+                console.warn(`  [conn] ${accountId}: connection leaked (5min timeout) — forcing decrement`);
+                doTrackLogout();
+            }
+        }, 300000);
+        // Clear the timer if logout happens normally
+        const origDoTrack = doTrackLogout;
+        // Prevent timer from keeping process alive
+        if (leakTimer.unref)
+            leakTimer.unref();
         return client;
     }
     /** Track client logout for connection counting (called automatically by wrapped logout) */
@@ -452,12 +467,10 @@ export class ImapManager extends EventEmitter {
             this.emit("syncProgress", accountId, `sync:${folder.path}`, Math.round((batchEnd / messages.length) * 100));
             // On first sync, emit folderCountsChanged per batch so newest messages appear immediately
             if (firstSync && newCount > 0) {
-                const total = newCount;
-                const unread = this.db.getMessages({ accountId, folderId, page: 1, pageSize: total })
-                    .items.filter((m) => !m.flags.includes("\\Seen")).length;
-                this.db.updateFolderCounts(folderId, total, unread);
+                this.db.recalcFolderCounts(folderId);
+                const folderInfo = this.db.getFolders(accountId).find(f => f.id === folderId);
                 this.emit("folderCountsChanged", accountId, {
-                    [folderId]: { total, unread }
+                    [folderId]: { total: folderInfo?.totalCount || 0, unread: folderInfo?.unreadCount || 0 }
                 });
             }
         }
@@ -485,16 +498,14 @@ export class ImapManager extends EventEmitter {
             }
         }
         // 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);
+        // Use recalcFolderCounts — single SQL query instead of fetching all messages
+        this.db.recalcFolderCounts(folderId);
         this.emit("syncProgress", accountId, `sync:${folder.path}`, 100);
         // Notify client to refresh if anything changed
         if (newCount > 0 || deletedCount > 0) {
+            const updatedFolder = this.db.getFolders(accountId).find(f => f.id === folderId);
             this.emit("folderCountsChanged", accountId, {
-                [folderId]: { total, unread }
+                [folderId]: { total: updatedFolder?.totalCount || 0, unread: updatedFolder?.unreadCount || 0 }
             });
         }
         this.db.updateLastSync(accountId, Date.now());
@@ -730,63 +741,69 @@ export class ImapManager extends EventEmitter {
         }
     }
     /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
-     *  If message count changed, triggers a full inbox sync. */
+     *  If message count changed, triggers inbox sync for that account. */
     lastInboxCounts = new Map();
-    quickCheckRunning = false;
-    async quickInboxCheck() {
-        if (this.quickCheckRunning || this.syncing || this.inboxSyncing)
+    quickCheckRunning = new Set(); // per-account guard
+    /** Check a single account's inbox */
+    async quickInboxCheckAccount(accountId) {
+        if (this.quickCheckRunning.has(accountId) || this.syncing || this.inboxSyncing)
             return;
-        this.quickCheckRunning = true;
+        if (this.reauthenticating.has(accountId))
+            return;
+        this.quickCheckRunning.add(accountId);
+        let client = null;
         try {
-            for (const [accountId] of this.configs) {
-                if (this.reauthenticating.has(accountId))
-                    continue;
-                let client = null;
+            const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+            if (!inbox)
+                return;
+            client = this.createClient(accountId);
+            const count = await client.getMessagesCount("INBOX");
+            await client.logout();
+            client = null;
+            const prev = this.lastInboxCounts.get(accountId) ?? count;
+            this.lastInboxCounts.set(accountId, count);
+            if (count !== prev) {
+                console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
+                client = this.createClient(accountId);
+                await this.syncFolder(accountId, inbox.id, client);
+                await client.logout();
+                client = null;
+            }
+        }
+        catch {
+            // Lightweight check — silently ignore errors
+        }
+        finally {
+            if (client) {
                 try {
-                    const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
-                    if (!inbox)
-                        continue;
-                    client = this.createClient(accountId);
-                    const count = await client.getMessagesCount("INBOX");
                     await client.logout();
-                    client = null;
-                    const prev = this.lastInboxCounts.get(accountId) ?? count;
-                    this.lastInboxCounts.set(accountId, count);
-                    if (count !== prev) {
-                        console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
-                        client = this.createClient(accountId);
-                        await this.syncFolder(accountId, inbox.id, client);
-                        await client.logout();
-                        client = null;
-                    }
-                }
-                catch {
-                    // Lightweight check — silently ignore errors
-                }
-                finally {
-                    if (client) {
-                        try {
-                            await client.logout();
-                        }
-                        catch { /* ignore */ }
-                        this.trackLogout(accountId);
-                    }
                 }
+                catch { /* ignore */ }
             }
+            this.quickCheckRunning.delete(accountId);
         }
-        finally {
-            this.quickCheckRunning = false;
+    }
+    /** Check all accounts (used by legacy callers) */
+    async quickInboxCheck() {
+        for (const [accountId] of this.configs) {
+            await this.quickInboxCheckAccount(accountId);
         }
     }
     /** Start periodic sync */
     startPeriodicSync(intervalMinutes) {
         this.stopPeriodicSync();
-        // Quick inbox check every 10 seconds — STATUS command is cheap but TCP setup isn't
-        // Guards prevent overlapping with full sync or inbox sync
-        const quickCheck = setInterval(() => {
-            this.quickInboxCheck().catch(() => { });
-        }, 10000);
-        this.syncIntervals.set("quick", quickCheck);
+        // Per-account quick inbox check — adapts to server constraints:
+        //   OAuth (Gmail/Outlook): every 15s — generous connection limits
+        //   Password (Dovecot etc): every 60s — conservative, 20-connection limit
+        // IDLE gives instant notification when working; STATUS is the fallback.
+        for (const [accountId] of this.configs) {
+            const interval = this.isOAuthAccount(accountId) ? 15000 : 60000;
+            const timer = setInterval(() => {
+                this.quickInboxCheckAccount(accountId).catch(() => { });
+            }, interval);
+            this.syncIntervals.set(`quick:${accountId}`, timer);
+            console.log(`  [periodic] ${accountId}: STATUS check every ${interval / 1000}s (${this.isOAuthAccount(accountId) ? "OAuth" : "password"})`);
+        }
         // Sync actions (sends + flags/deletes/moves) every 30 seconds
         const actionsInterval = setInterval(async () => {
             for (const [accountId] of this.configs) {
@@ -811,6 +828,11 @@ export class ImapManager extends EventEmitter {
         }
         this.syncIntervals.clear();
     }
+    /** Check if an account is OAuth (Gmail/Outlook — generous connection limits) */
+    isOAuthAccount(accountId) {
+        const config = this.configs.get(accountId);
+        return !!config?.tokenProvider;
+    }
     /** Start IMAP IDLE watchers for INBOX on each account */
     async startWatching() {
         for (const [accountId] of this.configs) {
@@ -820,7 +842,8 @@ export class ImapManager extends EventEmitter {
                 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}`));
+                    // Sync just INBOX for speed — full sync runs on the configured interval
+                    this.syncInbox().catch(e => console.error(`  [idle] sync error: ${e.message}`));
                 });
                 this.watchers.set(accountId, async () => {
                     await stop();
@@ -843,6 +866,16 @@ export class ImapManager extends EventEmitter {
         }
         this.watchers.clear();
     }
+    /** Per-account fetch queue — serializes body fetches so only one IMAP command runs at a time.
+     *  The persistent fetchClient can only handle one command at a time (IMAP protocol limitation). */
+    fetchQueues = new Map();
+    /** Serialize body fetch operations per account — prevents concurrent IMAP commands on same connection */
+    enqueueFetch(accountId, fn) {
+        const prev = this.fetchQueues.get(accountId) || Promise.resolve();
+        const next = prev.then(fn, fn); // run fn after previous completes (regardless of success/failure)
+        this.fetchQueues.set(accountId, next);
+        return next;
+    }
     /** Get or create a persistent client for body fetching */
     getFetchClient(accountId) {
         let client = this.fetchClients.get(accountId);
@@ -863,27 +896,43 @@ export class ImapManager extends EventEmitter {
         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");
-                const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
-                // Update DB so body_path isn't null for on-demand fetches
-                this.db.updateBodyPath(accountId, uid, bodyPath);
-                return raw;
+        // Serialize: only one body fetch per account at a time (IMAP can only handle one command)
+        return this.enqueueFetch(accountId, async () => {
+            // Re-check cache — may have been fetched while queued
+            if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
+                return this.bodyStore.getMessage(accountId, folderId, uid);
             }
-            catch (e) {
-                console.error(`  Body fetch error (${accountId}/${uid}): ${e.message}`);
-                this.fetchClients.delete(accountId);
-                if (attempt === 1)
-                    return null;
-                // Retry with fresh client
+            for (let attempt = 0; attempt < 2; attempt++) {
+                try {
+                    const client = this.getFetchClient(accountId);
+                    // 30s timeout — prevents hanging on stale connections
+                    const msg = await Promise.race([
+                        client.fetchMessageByUid(folder.path, uid, { source: true }),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("Body fetch timeout (30s)")), 30000))
+                    ]);
+                    if (!msg?.source)
+                        return null;
+                    const raw = Buffer.from(msg.source, "utf-8");
+                    const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
+                    this.db.updateBodyPath(accountId, uid, bodyPath);
+                    return raw;
+                }
+                catch (e) {
+                    console.error(`  Body fetch error (${accountId}/${uid} attempt ${attempt + 1}): ${e.message}`);
+                    const stale = this.fetchClients.get(accountId);
+                    this.fetchClients.delete(accountId);
+                    if (stale) {
+                        try {
+                            await stale.logout();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    if (attempt === 1)
+                        return null;
+                }
             }
-        }
-        return null;
+            return null;
+        });
     }
     /** Get the body store for direct access */
     getBodyStore() {
@@ -1106,7 +1155,7 @@ export class ImapManager extends EventEmitter {
     }
     /** 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) {
+    async saveDraft(accountId, rawMessage, previousDraftUid, draftId) {
         const drafts = this.findFolder(accountId, "drafts");
         if (!drafts) {
             console.error(`  [drafts] No Drafts folder found for ${accountId}`);
@@ -1114,17 +1163,29 @@ export class ImapManager extends EventEmitter {
         }
         const client = this.createClient(accountId);
         try {
-            // Delete previous draft if it exists
+            // Delete previous draft — by UID if we have it, otherwise by X-Mailx-Draft-ID header
             if (previousDraftUid) {
                 try {
                     await client.deleteMessageByUid(drafts.path, previousDraftUid);
                 }
                 catch { /* previous draft may already be gone */ }
             }
+            else if (draftId) {
+                // Search Drafts for our draft ID and delete it
+                try {
+                    const uids = await client.searchByHeader(drafts.path, "X-Mailx-Draft-ID", draftId);
+                    for (const uid of uids) {
+                        await client.deleteMessageByUid(drafts.path, uid);
+                    }
+                    if (uids.length > 0)
+                        console.log(`  [drafts] Deleted ${uids.length} previous draft(s) by ID ${draftId}`);
+                }
+                catch { /* search not supported or failed — tolerate duplicate */ }
+            }
             // Append new draft
             const result = await client.appendMessage(drafts.path, rawMessage, ["\\Draft", "\\Seen"]);
-            // imapflow append returns { destination, uid }
-            const uid = result?.uid || null;
+            // APPENDUID returns the UID directly; imapflow returns { destination, uid }
+            const uid = typeof result === "number" ? result : result?.uid || null;
             return uid;
         }
         finally {
@@ -1162,8 +1223,21 @@ export class ImapManager extends EventEmitter {
         // Try immediate processing
         this.processSendActions(accountId).catch(() => { });
     }
+    /** Guard against concurrent processSendActions for the same account */
+    sendingAccounts = new Set();
     /** Process local send actions — APPEND to Outbox, which the outbox worker then sends */
     async processSendActions(accountId) {
+        if (this.sendingAccounts.has(accountId))
+            return; // already processing
+        this.sendingAccounts.add(accountId);
+        try {
+            await this._processSendActions(accountId);
+        }
+        finally {
+            this.sendingAccounts.delete(accountId);
+        }
+    }
+    async _processSendActions(accountId) {
         const actions = this.db.getPendingSyncActions(accountId)
             .filter(a => a.action === "send");
         if (actions.length === 0)
@@ -1173,14 +1247,20 @@ export class ImapManager extends EventEmitter {
                 this.db.completeSyncAction(action.id);
                 continue;
             }
+            // Abandon after 10 failed attempts — don't retry forever
+            if (action.attempts >= 10) {
+                console.error(`  [outbox] Abandoning send action ${action.id} after ${action.attempts} attempts: ${action.rawMessage?.substring(0, 100)}`);
+                this.db.completeSyncAction(action.id);
+                this.emit("accountError", accountId, `Send permanently failed after ${action.attempts} attempts`, "Message removed from queue", false);
+                continue;
+            }
             try {
                 await this.queueOutgoing(accountId, action.rawMessage);
                 this.db.completeSyncAction(action.id);
             }
             catch (e) {
-                console.error(`  [outbox] Local→IMAP failed: ${e.message}`);
+                console.error(`  [outbox] Local→IMAP failed (attempt ${action.attempts + 1}): ${e.message}`);
                 this.db.failSyncAction(action.id, e.message);
-                // Don't give up — keep retrying sends
             }
         }
     }
@@ -1217,8 +1297,26 @@ export class ImapManager extends EventEmitter {
         outbox = this.findFolder(accountId, "outbox");
         return outbox?.path || "Outbox";
     }
+    /** Save a debug copy of outgoing mail to the sending directory */
+    saveSendingCopy(accountId, rawMessage, label) {
+        try {
+            const sendingDir = path.join(import.meta.dirname, "..", "..", "sending", accountId);
+            fs.mkdirSync(sendingDir, { recursive: true });
+            const now = new Date();
+            const pad2 = (n) => String(n).padStart(2, "0");
+            const ts = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
+            const filename = `${ts}-${label}.eml`;
+            fs.writeFileSync(path.join(sendingDir, filename), rawMessage);
+            console.log(`  [sending] Saved debug copy: ${filename}`);
+        }
+        catch (e) {
+            console.error(`  [sending] Failed to save debug copy: ${e.message}`);
+        }
+    }
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     async queueOutgoing(accountId, rawMessage) {
+        // Always save a debug copy
+        this.saveSendingCopy(accountId, rawMessage, "queued");
         try {
             const outboxPath = await this.ensureOutbox(accountId);
             const client = this.createClient(accountId);
@@ -1369,21 +1467,29 @@ export class ImapManager extends EventEmitter {
                     }
                     // Strip Bcc header from raw message before sending
                     const rawToSend = msg.source.replace(/^Bcc:.*\r?\n/mi, "");
+                    // Save debug copy before sending
+                    this.saveSendingCopy(accountId, rawToSend, `sent-${uid}`);
                     await transport.sendMail({
                         raw: rawToSend,
                         envelope: { from: sender, to: recipients },
                     });
                     console.log(`  [outbox] Sent UID ${uid} → ${recipients.join(", ")}`);
-                    // Move to Sent and sync both folders so UI updates
+                    // Delete from Outbox FIRST to prevent double-send if move-to-Sent fails.
+                    // The message is already sent via SMTP — worst case we lose the Sent copy,
+                    // which is better than sending the message twice.
+                    await client.deleteMessageByUid(outboxFolder.path, uid);
+                    // Copy to Sent folder (best-effort — message is already sent)
                     const sentFolder = this.findFolder(accountId, "sent");
                     if (sentFolder) {
-                        await client.moveMessage(msg, outboxFolder.path, sentFolder.path);
-                        this.syncFolder(accountId, sentFolder.id).catch(() => { });
+                        try {
+                            await client.appendMessage(sentFolder.path, msg.source, ["\\Seen"]);
+                            this.syncFolder(accountId, sentFolder.id).catch(() => { });
+                        }
+                        catch (sentErr) {
+                            console.error(`  [outbox] Failed to copy to Sent: ${sentErr.message} — message was sent successfully`);
+                        }
                         this.syncFolder(accountId, outboxFolder.id).catch(() => { });
                     }
-                    else {
-                        await client.deleteMessageByUid(outboxFolder.path, uid);
-                    }
                 }
                 catch (e) {
                     const errMsg = e.message || String(e);

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

@@ -47,7 +47,10 @@ export declare class MailxService {
         contentType: string;
         filename: string;
     }>;
-    saveDraft(accountId: string, subject: string, bodyHtml: string, bodyText: string, to?: string, cc?: string, previousDraftUid?: number): Promise<number | null>;
+    saveDraft(accountId: string, subject: string, bodyHtml: string, bodyText: string, to?: string, cc?: string, previousDraftUid?: number, draftId?: string): Promise<{
+        uid: number | null;
+        draftId: string;
+    }>;
     deleteDraft(accountId: string, draftUid: number): Promise<void>;
     searchContacts(query: string): any[];
     syncGoogleContacts(): Promise<void>;

package/packages/mailx-service/index.js

@@ -285,10 +285,14 @@ export class MailxService {
         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");
+        // Generate a unique Message-ID (required for threading, dedup, and RFC compliance)
+        const domain = account.email.split("@")[1] || "mailx.local";
+        const messageId = `<${Date.now()}.${Math.random().toString(36).slice(2)}@${domain}>`;
         const headers = [
             `From: ${fromHeader}`, `To: ${to}`,
             cc ? `Cc: ${cc}` : null, bcc ? `Bcc: ${bcc}` : null,
             `Subject: ${msg.subject}`, `Date: ${new Date().toUTCString()}`,
+            `Message-ID: ${messageId}`,
             msg.inReplyTo ? `In-Reply-To: ${msg.inReplyTo}` : null,
             msg.references?.length ? `References: ${msg.references.join(" ")}` : null,
             `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: base64`,
@@ -455,19 +459,25 @@ export class MailxService {
         };
     }
     // ── Drafts ──
-    async saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid) {
+    async saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId) {
         const settings = loadSettings();
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
             throw new Error(`Unknown account: ${accountId}`);
+        // Generate or reuse a stable draft ID for dedup
+        const id = draftId || `mailx-draft-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const body = bodyHtml || bodyText || "";
+        const bodyBase64 = Buffer.from(body, "utf-8").toString("base64").replace(/(.{76})/g, "$1\r\n");
         const headers = [
             `From: ${account.name} <${account.email}>`,
             to ? `To: ${to}` : null, cc ? `Cc: ${cc}` : null,
             `Subject: ${subject || "(no subject)"}`, `Date: ${new Date().toUTCString()}`,
-            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`,
+            `X-Mailx-Draft-ID: ${id}`,
+            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: base64`,
         ].filter(h => h !== null).join("\r\n");
-        const raw = `${headers}\r\n\r\n${bodyHtml || bodyText || ""}`;
-        return this.imapManager.saveDraft(accountId, raw, previousDraftUid);
+        const raw = `${headers}\r\n\r\n${bodyBase64}`;
+        const uid = await this.imapManager.saveDraft(accountId, raw, previousDraftUid, id);
+        return { uid, draftId: id };
     }
     async deleteDraft(accountId, draftUid) {
         await this.imapManager.deleteDraft(accountId, draftUid);