@bobfrankston/mailx 1.0.134 → 1.0.136

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.134",
+  "version": "1.0.136",
   "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.52",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
     "@bobfrankston/rust-builder": "^0.1.3",

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

@@ -34,6 +34,9 @@ export declare class ImapManager extends EventEmitter {
     useNativeClient: boolean;
     /** Accounts hitting connection limits — back off until this time */
     private connectionBackoff;
+    /** Per-account connection semaphore — limits concurrent IMAP connections */
+    private connectionSemaphore;
+    private static MAX_CONNECTIONS;
     constructor(db: MailxDB);
     /** Get OAuth access token for an account (for SMTP auth) */
     getOAuthToken(accountId: string): Promise<string | null>;
@@ -51,9 +54,16 @@ export declare class ImapManager extends EventEmitter {
     createPublicClient(accountId: string): any;
     /** Track active IMAP connections for diagnostics */
     private activeConnections;
+    /** Acquire a connection slot. Resolves when a slot is available. */
+    private acquireConnection;
+    /** Release a connection slot, unblocking the next waiter. */
+    private releaseConnection;
+    /** Create client with semaphore — acquires slot, wraps logout to release it. */
+    createClientWithLimit(accountId: string): Promise<any>;
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag.
-     *  The client's logout() is wrapped to auto-decrement the connection counter. */
+     *  The client's logout() is wrapped to auto-decrement the connection counter.
+     *  Prefer createClientWithLimit() for concurrent operations — it waits for a semaphore slot. */
     private createClient;
     /** Track client logout for connection counting (called automatically by wrapped logout) */
     private trackLogout;

package/packages/mailx-imap/index.js

@@ -71,6 +71,26 @@ async function extractPreview(source) {
         return { bodyHtml: "", bodyText: "", preview: "", hasAttachments: false };
     }
 }
+/** Race a promise against a timeout. On timeout, forcibly logout the client to prevent hanging. */
+async function withTimeout(promise, ms, client, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            // Force-close the client to unblock the hanging promise
+            try {
+                client.logout?.();
+            }
+            catch { /* ignore */ }
+            reject(new Error(`${label} timeout (${ms / 1000}s)`));
+        }, ms);
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 export class ImapManager extends EventEmitter {
     configs = new Map();
     watchers = new Map();
@@ -86,6 +106,9 @@ export class ImapManager extends EventEmitter {
     useNativeClient = false;
     /** Accounts hitting connection limits — back off until this time */
     connectionBackoff = new Map();
+    /** Per-account connection semaphore — limits concurrent IMAP connections */
+    connectionSemaphore = new Map();
+    static MAX_CONNECTIONS = 2; // 1 for sync/fetch, 1 for IDLE
     constructor(db) {
         super();
         this.db = db;
@@ -186,9 +209,68 @@ export class ImapManager extends EventEmitter {
     // private legacyFallbacks = new Set<string>();
     /** Track active IMAP connections for diagnostics */
     activeConnections = new Map(); // accountId → count
+    /** Acquire a connection slot. Resolves when a slot is available. */
+    acquireConnection(accountId) {
+        let sem = this.connectionSemaphore.get(accountId);
+        if (!sem) {
+            sem = { active: 0, waiting: [] };
+            this.connectionSemaphore.set(accountId, sem);
+        }
+        if (sem.active < ImapManager.MAX_CONNECTIONS) {
+            sem.active++;
+            return Promise.resolve();
+        }
+        // At limit — queue and wait
+        return new Promise((resolve) => {
+            sem.waiting.push(() => { sem.active++; resolve(); });
+        });
+    }
+    /** Release a connection slot, unblocking the next waiter. */
+    releaseConnection(accountId) {
+        const sem = this.connectionSemaphore.get(accountId);
+        if (!sem)
+            return;
+        sem.active = Math.max(0, sem.active - 1);
+        if (sem.waiting.length > 0 && sem.active < ImapManager.MAX_CONNECTIONS) {
+            const next = sem.waiting.shift();
+            next();
+        }
+    }
+    /** Create client with semaphore — acquires slot, wraps logout to release it. */
+    async createClientWithLimit(accountId) {
+        await this.acquireConnection(accountId);
+        try {
+            const client = this.createClient(accountId);
+            // Wrap logout to also release the semaphore slot
+            const originalLogout = client.logout;
+            let released = false;
+            client.logout = async () => {
+                await originalLogout.call(client);
+                if (!released) {
+                    released = true;
+                    this.releaseConnection(accountId);
+                }
+            };
+            // Safety: release slot if client is never logged out (leak protection)
+            const leakRelease = setTimeout(() => {
+                if (!released) {
+                    released = true;
+                    this.releaseConnection(accountId);
+                }
+            }, 310000); // slightly after the 5min leak timer in createClient
+            if (leakRelease.unref)
+                leakRelease.unref();
+            return client;
+        }
+        catch (e) {
+            this.releaseConnection(accountId);
+            throw e;
+        }
+    }
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag.
-     *  The client's logout() is wrapped to auto-decrement the connection counter. */
+     *  The client's logout() is wrapped to auto-decrement the connection counter.
+     *  Prefer createClientWithLimit() for concurrent operations — it waits for a semaphore slot. */
     createClient(accountId) {
         if (this.reauthenticating.has(accountId))
             throw new Error(`Account ${accountId} is re-authenticating`);
@@ -201,6 +283,10 @@ export class ImapManager extends EventEmitter {
         if (!config)
             throw new Error(`No config for account ${accountId}`);
         const count = (this.activeConnections.get(accountId) || 0) + 1;
+        // Hard limit: warn if exceeding max, but still allow (callers should use createClientWithLimit)
+        if (count > ImapManager.MAX_CONNECTIONS) {
+            console.warn(`  [conn] ${accountId}: WARNING exceeding limit (${count} > ${ImapManager.MAX_CONNECTIONS})`);
+        }
         this.activeConnections.set(accountId, count);
         const clientType = this.useNativeClient ? "native" : "imapflow";
         console.log(`  [conn] ${accountId}: +1 ${clientType} (${count} active)`);
@@ -537,11 +623,8 @@ export class ImapManager extends EventEmitter {
             let client = null;
             try {
                 const t0 = Date.now();
-                client = this.createClient(accountId);
-                const folders = await Promise.race([
-                    this.syncFolders(accountId, client),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("Folder list timeout (30s)")), 30000))
-                ]);
+                client = await this.createClientWithLimit(accountId);
+                const folders = await withTimeout(this.syncFolders(accountId, client), 30000, client, "Folder list");
                 console.log(`  [timing] ${accountId}: folder list ${Date.now() - t0}ms (${folders.length} folders)`);
                 // Legacy fallback removed — was doubling connections.
                 // If native client has issues, set useNativeClient=false or use --legacy-imap flag.
@@ -552,11 +635,8 @@ export class ImapManager extends EventEmitter {
                 const inbox = folders.find(f => f.specialUse === "inbox");
                 if (inbox) {
                     try {
-                        client = this.createClient(accountId);
-                        await Promise.race([
-                            this.syncFolder(accountId, inbox.id, client),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout (60s)")), 60000))
-                        ]);
+                        client = await this.createClientWithLimit(accountId);
+                        await withTimeout(this.syncFolder(accountId, inbox.id, client), 60000, client, "Inbox sync");
                         await client.logout();
                         client = null;
                     }
@@ -644,7 +724,7 @@ export class ImapManager extends EventEmitter {
             // Reuse one IMAP connection per account for all folders (avoid 87+ TLS handshakes)
             let client = null;
             try {
-                client = this.createClient(accountId);
+                client = await this.createClientWithLimit(accountId);
                 for (const folder of remaining) {
                     // Skip Trash subfolders on first sync — they're large and low priority
                     const isTrashChild = folder.path.includes("/") && folder.path.toLowerCase().startsWith("trash");
@@ -656,10 +736,7 @@ export class ImapManager extends EventEmitter {
                     // Longer timeout for folders we know are large (Trash, first sync)
                     const timeout = highestUid === 0 ? 180000 : 60000;
                     try {
-                        await Promise.race([
-                            this.syncFolder(accountId, folder.id, client),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout (${timeout / 1000}s) on ${folder.path}`)), timeout))
-                        ]);
+                        await withTimeout(this.syncFolder(accountId, folder.id, client), timeout, client, `Sync ${folder.path}`);
                     }
                     catch (e) {
                         if (e.responseText?.includes("doesn't exist")) {
@@ -673,7 +750,7 @@ export class ImapManager extends EventEmitter {
                                 await client.logout();
                             }
                             catch { /* */ }
-                            client = this.createClient(accountId);
+                            client = await this.createClientWithLimit(accountId);
                         }
                     }
                 }
@@ -706,7 +783,7 @@ export class ImapManager extends EventEmitter {
                     // Try up to 2 times with fresh clients
                     for (let attempt = 0; attempt < 2; attempt++) {
                         try {
-                            client = this.createClient(accountId);
+                            client = await this.createClientWithLimit(accountId);
                             await this.syncFolder(accountId, inbox.id, client);
                             await client.logout();
                             client = null;
@@ -750,13 +827,17 @@ export class ImapManager extends EventEmitter {
             return;
         if (this.reauthenticating.has(accountId))
             return;
+        // Skip if at connection limit — don't queue, just skip this cycle
+        const sem = this.connectionSemaphore.get(accountId);
+        if (sem && sem.active >= ImapManager.MAX_CONNECTIONS)
+            return;
         this.quickCheckRunning.add(accountId);
         let client = null;
         try {
             const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
             if (!inbox)
                 return;
-            client = this.createClient(accountId);
+            client = await this.createClientWithLimit(accountId);
             const count = await client.getMessagesCount("INBOX");
             await client.logout();
             client = null;
@@ -764,7 +845,7 @@ export class ImapManager extends EventEmitter {
             this.lastInboxCounts.set(accountId, count);
             if (count !== prev) {
                 console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
-                client = this.createClient(accountId);
+                client = await this.createClientWithLimit(accountId);
                 await this.syncFolder(accountId, inbox.id, client);
                 await client.logout();
                 client = null;
@@ -839,7 +920,7 @@ export class ImapManager extends EventEmitter {
             if (this.watchers.has(accountId))
                 continue;
             try {
-                const watchClient = this.createClient(accountId);
+                const watchClient = await this.createClientWithLimit(accountId);
                 const stop = await watchClient.watchMailbox("INBOX", (newCount) => {
                     console.log(`  [idle] ${accountId}: ${newCount} new message(s)`);
                     // Sync just INBOX for speed — full sync runs on the configured interval
@@ -877,10 +958,10 @@ export class ImapManager extends EventEmitter {
         return next;
     }
     /** Get or create a persistent client for body fetching */
-    getFetchClient(accountId) {
+    async getFetchClient(accountId) {
         let client = this.fetchClients.get(accountId);
         if (!client) {
-            client = this.createClient(accountId);
+            client = await this.createClientWithLimit(accountId);
             this.fetchClients.set(accountId, client);
         }
         return client;
@@ -904,12 +985,9 @@ export class ImapManager extends EventEmitter {
             }
             for (let attempt = 0; attempt < 2; attempt++) {
                 try {
-                    const client = this.getFetchClient(accountId);
+                    const client = await 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))
-                    ]);
+                    const msg = await withTimeout(client.fetchMessageByUid(folder.path, uid, { source: true }), 30000, client, "Body fetch");
                     if (!msg?.source)
                         return null;
                     const raw = Buffer.from(msg.source, "utf-8");
@@ -1359,7 +1437,7 @@ export class ImapManager extends EventEmitter {
             return;
         try {
             const outboxPath = await this.ensureOutbox(accountId);
-            const client = this.createClient(accountId);
+            const client = await this.createClientWithLimit(accountId);
             try {
                 for (const file of files) {
                     const filePath = path.join(localQueue, file);
@@ -1389,7 +1467,7 @@ export class ImapManager extends EventEmitter {
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
             return;
-        const client = this.createClient(accountId);
+        const client = await this.createClientWithLimit(accountId);
         try {
             // Get all UIDs in Outbox
             const uids = await client.getUids(outboxFolder.path);

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) => {