@bobfrankston/mailx 1.0.133 → 1.0.135

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.133",
+  "version": "1.0.135",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,7 +20,7 @@
     "postinstall": "node launcher/builder/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.50",
+    "@bobfrankston/iflow": "^1.0.51",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
     "@bobfrankston/rust-builder": "^0.1.3",

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,39 +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);
-                // 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);
-                // 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} attempt ${attempt + 1}): ${e.message}`);
-                // Kill stale client so retry creates a fresh connection
-                const stale = this.fetchClients.get(accountId);
-                this.fetchClients.delete(accountId);
-                if (stale) {
-                    try {
-                        await stale.logout();
+            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 */ }
                     }
-                    catch { /* ignore */ }
+                    if (attempt === 1)
+                        return null;
                 }
-                if (attempt === 1)
-                    return null;
-                // Retry with fresh client
             }
-        }
-        return null;
+            return null;
+        });
     }
     /** Get the body store for direct access */
     getBodyStore() {
@@ -1118,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}`);
@@ -1126,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 {
@@ -1174,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)
@@ -1185,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
             }
         }
     }
@@ -1229,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);
@@ -1381,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-server/index.js

@@ -234,10 +234,41 @@ async function start() {
     // Start HTTP server FIRST so UI is always reachable (even during IMAP startup)
     const externalAccess = process.argv.includes("--external");
     const hostname = externalAccess ? "0.0.0.0" : "127.0.0.1";
-    server = createServer(app);
-    wss = new WebSocketServer({ server });
-    wireWebSocket();
-    await new Promise((resolve) => server.listen(PORT, hostname, resolve));
+    // Retry listen with backoff — Windows CLOSE_WAIT zombies can hold the port for minutes after a crash
+    for (let attempt = 0; attempt < 30; attempt++) {
+        server = createServer(app);
+        // Prevent CLOSE_WAIT accumulation: short keepAlive timeout + connection close headers
+        server.keepAliveTimeout = 5000; // close idle keep-alive connections after 5s
+        server.headersTimeout = 10000; // kill connections with no headers after 10s
+        // Track connections for clean shutdown (prevents CLOSE_WAIT zombies on Windows)
+        server.on("connection", (conn) => {
+            openConnections.add(conn);
+            conn.on("close", () => openConnections.delete(conn));
+        });
+        // Suppress EADDRINUSE from bubbling to uncaughtException — we handle it here
+        server.on("error", () => { }); // will be replaced by listen handler below
+        wss = new WebSocketServer({ server });
+        wireWebSocket();
+        const listenResult = await new Promise((resolve) => {
+            server.removeAllListeners("error");
+            server.once("error", (e) => { resolve(e.code || e.message); });
+            server.listen({ port: PORT, host: hostname, exclusive: false }, () => {
+                server.removeAllListeners("error");
+                resolve("ok");
+            });
+        });
+        if (listenResult === "ok")
+            break;
+        if (listenResult === "EADDRINUSE" && attempt < 29) {
+            const wait = Math.min(2000 + attempt * 1000, 10000);
+            console.log(`  Port ${PORT} in use (CLOSE_WAIT zombies?) — retry ${attempt + 1}/30 in ${wait / 1000}s...`);
+            server.close();
+            await new Promise(r => setTimeout(r, wait));
+        }
+        else {
+            throw new Error(`Cannot bind port ${PORT}: ${listenResult}`);
+        }
+    }
     console.log(`mailx server running on http://${hostname}:${PORT}`);
     // Seed contacts (fast — skips existing)
     const seeded = db.seedContactsFromMessages();
@@ -287,6 +318,8 @@ async function start() {
     imapManager.startOutboxWorker();
 }
 // ── Graceful Shutdown ──
+/** Track all open connections so we can destroy them on shutdown (prevents CLOSE_WAIT zombies) */
+const openConnections = new Set();
 async function shutdown() {
     console.log("\nShutting down...");
     const forceExit = setTimeout(() => { console.log("Force exit"); process.exit(1); }, 3000);
@@ -296,6 +329,11 @@ async function shutdown() {
     }
     catch { /* proceed */ }
     db.close();
+    // Destroy all open connections immediately — prevents CLOSE_WAIT zombies on Windows
+    for (const conn of openConnections) {
+        conn.destroy();
+    }
+    openConnections.clear();
     server?.close();
     clearTimeout(forceExit);
     process.exit(0);
@@ -308,11 +346,6 @@ process.on("unhandledRejection", (err) => {
 process.on("uncaughtException", (err) => {
     console.error("FATAL uncaught exception:", err.message);
     console.error(err.stack);
-    // EADDRINUSE = another instance holds the port — exit so node --watch can retry
-    if (err.code === "EADDRINUSE") {
-        console.error("Port in use — exiting so node --watch can retry");
-        process.exit(1);
-    }
     // Other exceptions: stay alive, let node --watch handle file-change restarts
 });
 process.on("exit", (code) => {

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);