@bobfrankston/mailx 1.0.155 → 1.0.157

package/bin/mailx.js

@@ -703,8 +703,9 @@ async function main() {
     imapManager.on("accountError", (accountId, error, hint, isOAuth) => {
         handle.send({ _event: "accountError", type: "accountError", accountId, error, hint, isOAuth });
     });
-    // Wait for WebView2 initialization before starting IMAP (stdin writes during init crash wry)
+    // Wait for WebView2 initialization, then signal readiness
     await new Promise(r => setTimeout(r, 2000));
+    handle.send({ _event: "ready", type: "ready" });
     // Register all accounts (OAuth may open browser for Gmail — event loop stays free for IPC)
     for (const account of settings.accounts) {
         if (!account.enabled)

package/client/app.js

@@ -292,7 +292,8 @@ async function openCompose(mode) {
     }
     // Store init data for compose window to pick up
     sessionStorage.setItem("composeInit", JSON.stringify(init));
-    window.open("/compose/compose.html", "_blank", "width=800,height=600,menubar=no,toolbar=no,status=no");
+    // Use relative URL so it works with both HTTP and custom protocol (msger://)
+    window.open("compose/compose.html", "_blank", "width=800,height=600,menubar=no,toolbar=no,status=no");
 }
 function quoteBody(msg) {
     const date = new Date(msg.date).toLocaleString();
@@ -898,19 +899,8 @@ optAutocomplete?.addEventListener("change", () => {
     }).catch(() => { });
 });
 const isApp = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-// Retry getVersion — IPC may not be ready on first call
-async function getVersionWithRetry() {
-    for (let i = 0; i < 5; i++) {
-        try {
-            return await getVersion();
-        }
-        catch {
-            await new Promise(r => setTimeout(r, 1000));
-        }
-    }
-    return { version: "?", storage: {} };
-}
-const versionPromise = getVersionWithRetry();
+// Wait for server ready signal, then fetch version
+const versionPromise = getVersion();
 versionPromise.then((d) => {
     const el = document.getElementById("app-version");
     const storage = d.storage || {};
@@ -1017,7 +1007,7 @@ function scheduleMiddnightRefresh() {
 }
 scheduleMiddnightRefresh();
 // ── Apply theme from settings ──
-getVersion().then((d) => {
+versionPromise.then((d) => {
     if (d.theme === "dark")
         document.documentElement.classList.add("theme-dark");
     else if (d.theme === "light")

package/client/components/message-list.js

@@ -102,8 +102,7 @@ export async function loadUnifiedInbox(autoSelect = true) {
         const result = await getUnifiedInbox(1);
         totalMessages = result.total;
         if (result.items.length === 0) {
-            body.innerHTML = `<div class="ml-empty">No messages</div>`;
-            clearViewer();
+            body.innerHTML = `<div class="ml-empty">${result.total > 0 ? `${result.total} messages syncing...` : "Syncing — messages will appear shortly"}</div>`;
             return;
         }
         // Build new rows into a fragment, then swap atomically (no flash)
@@ -187,6 +186,9 @@ export async function loadSearchResults(query, scope = "all", accountId = "", fo
     }
 }
 export async function loadMessages(accountId, folderId, page = 1, specialUse = "", autoSelect = true) {
+    // Clear viewer when navigating to a new folder (not on reloads)
+    if (autoSelect)
+        clearViewer();
     searchMode = false;
     unifiedMode = false;
     showToInsteadOfFrom = ["sent", "drafts", "outbox"].includes(specialUse) ||

package/client/components/message-viewer.js

@@ -19,8 +19,8 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
     const headerEl = document.getElementById("mv-header");
     const bodyEl = document.getElementById("mv-body");
     const attEl = document.getElementById("mv-attachments");
-    bodyEl.innerHTML = `<div class="mv-empty">Loading...</div>`;
-    headerEl.hidden = true;
+    bodyEl.innerHTML = `<div class="mv-empty">Fetching message body...</div>`;
+    // Don't hide the header — keep previous header visible until new one loads
     attEl.hidden = true;
     try {
         const msg = await getMessage(accountId, uid, false, folderId);
@@ -102,7 +102,7 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                         draftFolderId: msg.folderId,
                     };
                     sessionStorage.setItem("composeInit", JSON.stringify(init));
-                    window.open("/compose/compose.html", "_blank", "width=800,height=600,menubar=no,toolbar=no,status=no");
+                    window.open("compose/compose.html", "_blank", "width=800,height=600,menubar=no,toolbar=no,status=no");
                 };
             }
             else {

package/client/lib/mailxapi.js

@@ -12,6 +12,8 @@
     var _callbacks = {};
     var _callbackId = 0;
     var _eventHandlers = [];
+    var _ready = false;
+    var _pendingCalls = []; // buffered until server sends "ready"
 
     function callNode(action, params) {
         var id = String(++_callbackId);
@@ -22,10 +24,14 @@
             }, 120000);
             _callbacks[id] = { resolve: resolve, reject: reject, timer: timer };
             var msg = Object.assign({ _action: action, _cbid: id }, params || {});
+            if (!_ready) {
+                // Buffer until server is ready (early calls are lost in the pipe)
+                _pendingCalls.push(msg);
+                return;
+            }
             if (window.ipc && window.ipc.postMessage) {
                 window.ipc.postMessage(JSON.stringify(msg));
             } else {
-                // Fallback: should not happen in WebView
                 clearTimeout(timer);
                 delete _callbacks[id];
                 reject(new Error("No IPC channel available"));
@@ -33,6 +39,16 @@
         });
     }
 
+    function flushPending() {
+        _ready = true;
+        var pending = _pendingCalls.splice(0);
+        for (var i = 0; i < pending.length; i++) {
+            if (window.ipc && window.ipc.postMessage) {
+                window.ipc.postMessage(JSON.stringify(pending[i]));
+            }
+        }
+    }
+
     // Called by Rust to resolve promises
     window._mailxapiResolve = function(id, value) {
         var cb = _callbacks[id];
@@ -53,6 +69,11 @@
 
     // Called by Rust to push events (new mail, sync progress, etc.)
     window._mailxapiEvent = function(event) {
+        // "ready" signal from server — flush buffered IPC calls
+        if (event && event.type === "ready") {
+            flushPending();
+            return;
+        }
         for (var i = 0; i < _eventHandlers.length; i++) {
             try { _eventHandlers[i](event); } catch(e) { /* ignore */ }
         }
@@ -73,8 +94,8 @@
         getUnifiedInbox: function(page, pageSize) {
             return callNode("getUnifiedInbox", { page: page, pageSize: pageSize });
         },
-        getMessage: function(accountId, uid, allowRemote) {
-            return callNode("getMessage", { accountId: accountId, uid: uid, allowRemote: allowRemote });
+        getMessage: function(accountId, uid, allowRemote, folderId) {
+            return callNode("getMessage", { accountId: accountId, uid: uid, allowRemote: allowRemote, folderId: folderId });
         },
 
         // Actions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.155",
+  "version": "1.0.157",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -23,7 +23,7 @@
     "@bobfrankston/iflow": "^1.0.53",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
-    "@bobfrankston/msger": "^0.1.205",
+    "@bobfrankston/msger": "^0.1.207",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",

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

@@ -34,9 +34,6 @@ 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>;
@@ -52,20 +49,24 @@ export declare class ImapManager extends EventEmitter {
     searchOnServer(accountId: string, mailboxPath: string, criteria: any): Promise<number[]>;
     /** Create a fresh IMAP client for an account (public access for API endpoints) */
     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. */
+    /** Persistent operational connections — one per account, reused for all operations */
+    private opsClients;
+    /** Operation queues — ensures sequential access per account */
+    private opsQueues;
+    /** Get (or create) the persistent operational connection for an account.
+     *  logout() is wrapped as a no-op so legacy callers don't close it. */
+    private getOpsClient;
+    /** Run an operation on the account's connection — queued, sequential, no concurrency */
+    withConnection<T>(accountId: string, fn: (client: any) => Promise<T>): Promise<T>;
+    /** Create a new IMAP client (internal — callers use getOpsClient or withConnection) */
+    private newClient;
+    /** Disconnect the persistent operational connection for an account */
+    disconnectOps(accountId: string): Promise<void>;
+    /** Legacy API — callers that still create/destroy connections.
+     *  These return the persistent ops client. logout() is a no-op
+     *  (the connection stays alive for reuse). */
     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.
-     *  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;
     /** Number of registered IMAP accounts */
     getAccountCount(): number;
@@ -78,6 +79,12 @@ export declare class ImapManager extends EventEmitter {
     /** Sync all folders for all accounts */
     syncAll(): Promise<void>;
     private _syncAll;
+    /** Sync a single account — manages its own connection lifecycle */
+    private syncAccount;
+    /** Kill and recreate the persistent ops connection */
+    private reconnectOps;
+    /** Handle sync errors — classify and emit appropriate UI events */
+    private handleSyncError;
     /** 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).
@@ -103,8 +110,6 @@ export declare class ImapManager extends EventEmitter {
     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 */
     fetchMessageBody(accountId: string, folderId: number, uid: number): Promise<Buffer | null>;
     /** Get the body store for direct access */

package/packages/mailx-imap/index.js

@@ -106,9 +106,7 @@ 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 all operations (sequential), 1 for IDLE
+    // Connection management: see withConnection() below — no semaphore needed
     constructor(db) {
         super();
         this.db = db;
@@ -207,74 +205,74 @@ export class ImapManager extends EventEmitter {
     // Legacy fallback disabled — was doubling connections without helping.
     // To re-enable: uncomment legacyFallbacks logic in createClient and _syncAll.
     // 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();
-        }
+    // ── Connection management: one persistent connection per account ──
+    // All operations on an account are serialized through an operation queue.
+    // No semaphore, no pool, no per-operation connect/disconnect.
+    // IDLE uses a separate connection (see startWatching).
+    /** Persistent operational connections — one per account, reused for all operations */
+    opsClients = new Map();
+    /** Operation queues — ensures sequential access per account */
+    opsQueues = new Map();
+    /** Get (or create) the persistent operational connection for an account.
+     *  logout() is wrapped as a no-op so legacy callers don't close it. */
+    async getOpsClient(accountId) {
+        let client = this.opsClients.get(accountId);
+        if (client)
+            return client;
+        client = this.newClient(accountId);
+        // Wrap logout as no-op — this is a persistent connection
+        const realLogout = client.logout.bind(client);
+        client.logout = async () => { };
+        client._realLogout = realLogout; // stash for actual disconnect
+        this.opsClients.set(accountId, client);
+        console.log(`  [conn] ${accountId}: connected`);
+        return client;
     }
-    /** 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);
+    /** Run an operation on the account's connection — queued, sequential, no concurrency */
+    async withConnection(accountId, fn) {
+        const prev = this.opsQueues.get(accountId) || Promise.resolve();
+        const next = prev.then(async () => {
+            try {
+                const client = await this.getOpsClient(accountId);
+                return await fn(client);
+            }
+            catch (e) {
+                // Connection broken — discard it so next operation reconnects
+                const stale = this.opsClients.get(accountId);
+                this.opsClients.delete(accountId);
+                if (stale) {
+                    try {
+                        await stale.logout();
+                    }
+                    catch { /* */ }
                 }
-            };
-            // Safety: release slot if client is never logged out (leak protection)
-            const leakRelease = setTimeout(() => {
-                if (!released) {
-                    released = true;
-                    this.releaseConnection(accountId);
+                throw e;
+            }
+        }, async () => {
+            // Previous operation failed — still try this one with a fresh connection
+            try {
+                const client = await this.getOpsClient(accountId);
+                return await fn(client);
+            }
+            catch (e) {
+                const stale = this.opsClients.get(accountId);
+                this.opsClients.delete(accountId);
+                if (stale) {
+                    try {
+                        await stale.logout();
+                    }
+                    catch { /* */ }
                 }
-            }, 310000); // slightly after the 5min leak timer in createClient
-            if (leakRelease.unref)
-                leakRelease.unref();
-            return client;
-        }
-        catch (e) {
-            this.releaseConnection(accountId);
-            throw e;
-        }
+                throw e;
+            }
+        });
+        this.opsQueues.set(accountId, next.catch(() => { }));
+        return next;
     }
-    /** 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.
-     *  Prefer createClientWithLimit() for concurrent operations — it waits for a semaphore slot. */
-    createClient(accountId) {
+    /** Create a new IMAP client (internal — callers use getOpsClient or withConnection) */
+    newClient(accountId) {
         if (this.reauthenticating.has(accountId))
             throw new Error(`Account ${accountId} is re-authenticating`);
-        // Check connection backoff
         const backoffUntil = this.connectionBackoff.get(accountId);
         if (backoffUntil && Date.now() < backoffUntil) {
             throw new Error(`Account ${accountId} in connection backoff (${Math.round((backoffUntil - Date.now()) / 1000)}s remaining)`);
@@ -282,54 +280,34 @@ export class ImapManager extends EventEmitter {
         const config = this.configs.get(accountId);
         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)`);
-        let client;
         if (this.useNativeClient) {
-            client = new CompatImapClient(config, () => new NodeTransport({ rejectUnauthorized: config.rejectUnauthorized !== false }));
+            return new CompatImapClient(config, () => new NodeTransport({ rejectUnauthorized: config.rejectUnauthorized !== false }));
         }
-        else {
-            client = new ImapClient(config);
-        }
-        // Wrap logout to auto-decrement connection counter (prevents leaks from missed trackLogout calls)
-        const originalLogout = client.logout.bind(client);
-        let loggedOut = false;
-        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();
+        return new ImapClient(config);
+    }
+    /** Disconnect the persistent operational connection for an account */
+    async disconnectOps(accountId) {
+        const client = this.opsClients.get(accountId);
+        this.opsClients.delete(accountId);
+        if (client) {
+            try {
+                await (client._realLogout || client.logout)();
             }
-        }, 300000);
-        // Clear the timer if logout happens normally
-        const origDoTrack = doTrackLogout;
-        // Prevent timer from keeping process alive
-        if (leakTimer.unref)
-            leakTimer.unref();
-        return client;
+            catch { /* */ }
+            console.log(`  [conn] ${accountId}: disconnected`);
+        }
     }
-    /** Track client logout for connection counting (called automatically by wrapped logout) */
-    trackLogout(accountId) {
-        const count = Math.max(0, (this.activeConnections.get(accountId) || 1) - 1);
-        this.activeConnections.set(accountId, count);
-        console.log(`  [conn] ${accountId}: -1 (${count} active)`);
+    /** Legacy API — callers that still create/destroy connections.
+     *  These return the persistent ops client. logout() is a no-op
+     *  (the connection stays alive for reuse). */
+    async createClientWithLimit(accountId) {
+        return this.getOpsClient(accountId);
     }
+    createClient(accountId) {
+        // Return a fresh disposable client (used by IDLE watcher and one-off operations)
+        return this.newClient(accountId);
+    }
+    trackLogout(_accountId) { }
     /** Number of registered IMAP accounts */
     getAccountCount() { return this.configs.size; }
     /** Register an account */
@@ -400,7 +378,10 @@ export class ImapManager extends EventEmitter {
             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);
-        return this.db.getFolders(accountId);
+        // Notify UI that folder structure changed — triggers tree re-render
+        const dbFolders = this.db.getFolders(accountId);
+        this.emit("folderCountsChanged", accountId, {});
+        return dbFolders;
     }
     /** Sync messages for a specific folder */
     async syncFolder(accountId, folderId, client) {
@@ -616,158 +597,115 @@ export class ImapManager extends EventEmitter {
         }
     }
     async _syncAll() {
-        // Phase 1: Sync folder lists and inboxes for ALL accounts first
-        // so every account has content visible quickly
-        const accountFolders = new Map();
-        for (const [accountId] of this.configs) {
-            let client = null;
-            try {
-                const t0 = Date.now();
-                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.
-                await client.logout();
-                client = null;
-                accountFolders.set(accountId, folders);
-                // Sync inbox immediately
-                const inbox = folders.find(f => f.specialUse === "inbox");
-                if (inbox) {
-                    try {
-                        client = await this.createClientWithLimit(accountId);
-                        const inboxTimeout = this.db.getHighestUid(accountId, inbox.id) === 0 ? 300000 : 60000;
-                        await withTimeout(this.syncFolder(accountId, inbox.id, client), inboxTimeout, client, "Inbox sync");
-                        await client.logout();
-                        client = null;
-                    }
-                    catch (e) {
-                        if (client) {
-                            try {
-                                await client.logout();
-                            }
-                            catch { /* ignore */ }
-                            this.trackLogout(accountId);
-                            client = null;
-                        }
-                        console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
-                    }
-                }
-            }
-            catch (e) {
-                const errMsg = imapError(e);
-                this.emit("syncError", accountId, errMsg);
-                console.error(`Sync error for ${accountId}: ${errMsg}`);
-                const config = this.configs.get(accountId);
-                const isOAuth = !!config?.tokenProvider;
-                // Connection limit — back off for 60 seconds
-                if (errMsg.includes("max_userip_connections") || errMsg.includes("Too many simultaneous")) {
-                    this.connectionBackoff.set(accountId, Date.now() + 60000);
-                    console.log(`  [backoff] ${accountId}: connection limit hit, backing off 60s`);
-                }
-                // Classify error: transient (timeout, connection) vs auth (credentials, token)
-                const isTransient = /timeout|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|Too many/i.test(errMsg);
-                const isAuth = /auth|login|credential|token|AUTHENTICATIONFAILED/i.test(errMsg);
-                if (isTransient) {
-                    // Transient: just log, will auto-retry on next sync cycle
-                    console.log(`  [transient] ${accountId}: ${errMsg} — will retry next cycle`);
-                }
-                else if (isAuth && isOAuth) {
-                    // OAuth auth error: auto-reauth ONCE, then show banner
-                    const lastReauth = this.lastReauthAttempt.get(accountId) || 0;
-                    const cooldown = Date.now() - lastReauth > 300000; // 5 min cooldown
-                    if (cooldown && !this.reauthenticating.has(accountId)) {
-                        this.lastReauthAttempt.set(accountId, Date.now());
-                        console.log(`  [auth] ${accountId}: attempting automatic re-authentication...`);
-                        this.reauthenticate(accountId).then(ok => {
-                            if (!ok && !this.accountErrorShown.has(accountId)) {
-                                this.accountErrorShown.add(accountId);
-                                this.emit("accountError", accountId, errMsg, "Authentication expired — re-authenticate", true);
-                            }
-                        }).catch(() => {
-                            if (!this.accountErrorShown.has(accountId)) {
-                                this.accountErrorShown.add(accountId);
-                                this.emit("accountError", accountId, errMsg, "Authentication expired — re-authenticate", true);
-                            }
-                        });
-                    }
-                    else if (!this.accountErrorShown.has(accountId)) {
-                        this.accountErrorShown.add(accountId);
-                        this.emit("accountError", accountId, errMsg, "Authentication expired — re-authenticate", true);
-                    }
-                }
-                else if (!this.accountErrorShown.has(accountId)) {
-                    // Non-transient, non-OAuth: show error banner
-                    this.accountErrorShown.add(accountId);
-                    this.emit("accountError", accountId, errMsg, isOAuth ? "Authentication may have expired" : "Check server connectivity", isOAuth);
+        const priorityOrder = ["sent", "drafts", "archive", "junk", "trash"];
+        // Sync all accounts in parallel — each manages its own connection
+        const syncPromises = [...this.configs.keys()].map(accountId => this.syncAccount(accountId, priorityOrder));
+        await Promise.allSettled(syncPromises);
+    }
+    /** Sync a single account — manages its own connection lifecycle */
+    async syncAccount(accountId, priorityOrder) {
+        try {
+            // Step 1: Get folder list (fast — <1s typically)
+            let client = await this.getOpsClient(accountId);
+            const t0 = Date.now();
+            const folders = await this.syncFolders(accountId, client);
+            console.log(`  [timing] ${accountId}: folder list ${Date.now() - t0}ms (${folders.length} folders)`);
+            // Step 2: Sync INBOX first
+            const inbox = folders.find(f => f.specialUse === "inbox");
+            if (inbox) {
+                try {
+                    client = await this.getOpsClient(accountId);
+                    await this.syncFolder(accountId, inbox.id, client);
                 }
-            }
-            finally {
-                if (client) {
-                    try {
-                        await client.logout();
-                    }
-                    catch { /* ignore */ }
-                    this.trackLogout(accountId);
+                catch (e) {
+                    console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
+                    await this.reconnectOps(accountId);
                 }
             }
-        }
-        // Phase 2: Sync remaining folders — priority order, skip Trash subfolders on first sync
-        const priorityOrder = ["sent", "drafts", "archive", "junk", "trash"];
-        for (const [accountId, folders] of accountFolders) {
-            // Sort: sent/drafts first, then regular, then trash subfolders last
+            // Step 3: Sync remaining folders
             const remaining = folders.filter(f => f.specialUse !== "inbox");
             remaining.sort((a, b) => {
                 const pa = priorityOrder.indexOf(a.specialUse || "") >= 0 ? priorityOrder.indexOf(a.specialUse || "") : 5;
                 const pb = priorityOrder.indexOf(b.specialUse || "") >= 0 ? priorityOrder.indexOf(b.specialUse || "") : 5;
                 return pa - pb;
             });
-            // Reuse one IMAP connection per account for all folders (avoid 87+ TLS handshakes)
-            let client = null;
-            try {
-                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");
-                    const highestUid = this.db.getHighestUid(accountId, folder.id);
-                    if (isTrashChild && highestUid === 0) {
-                        console.log(`  Deferring first sync of ${folder.path} (Trash subfolder)`);
-                        continue;
-                    }
-                    // Longer timeout for folders we know are large (Trash, first sync)
-                    const timeout = highestUid === 0 ? 180000 : 60000;
-                    try {
-                        await withTimeout(this.syncFolder(accountId, folder.id, client), timeout, client, `Sync ${folder.path}`);
+            let consecutiveErrors = 0;
+            for (const folder of remaining) {
+                const isTrashChild = folder.path.includes("/") && folder.path.toLowerCase().startsWith("trash");
+                const highestUid = this.db.getHighestUid(accountId, folder.id);
+                if (isTrashChild && highestUid === 0)
+                    continue;
+                try {
+                    client = await this.getOpsClient(accountId);
+                    await this.syncFolder(accountId, folder.id, client);
+                    consecutiveErrors = 0;
+                }
+                catch (e) {
+                    consecutiveErrors++;
+                    if (e.responseText?.includes("doesn't exist")) {
+                        this.db.deleteFolder(folder.id);
                     }
-                    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}`);
-                            // Connection may be broken — reconnect
-                            try {
-                                await client.logout();
-                            }
-                            catch { /* */ }
-                            client = await this.createClientWithLimit(accountId);
-                        }
+                    else {
+                        console.error(`  Skipping ${folder.path}: ${e.message}`);
+                        // Connection is probably dead — reconnect
+                        await this.reconnectOps(accountId);
                     }
-                }
-            }
-            finally {
-                if (client) {
-                    try {
-                        await client.logout();
+                    // Too many consecutive errors = connection fundamentally broken
+                    if (consecutiveErrors >= 3) {
+                        console.error(`  [sync] ${accountId}: ${consecutiveErrors} consecutive errors — aborting sync`);
+                        break;
                     }
-                    catch { /* */ }
-                    this.trackLogout(accountId);
                 }
             }
             this.accountErrorShown.delete(accountId);
             this.emit("syncComplete", accountId);
         }
+        catch (e) {
+            const errMsg = imapError(e);
+            this.emit("syncError", accountId, errMsg);
+            console.error(`Sync error for ${accountId}: ${errMsg}`);
+            this.handleSyncError(accountId, errMsg);
+        }
+    }
+    /** Kill and recreate the persistent ops connection */
+    async reconnectOps(accountId) {
+        const old = this.opsClients.get(accountId);
+        this.opsClients.delete(accountId);
+        if (old) {
+            try {
+                await (old._realLogout || old.logout)();
+            }
+            catch { /* */ }
+        }
+        console.log(`  [conn] ${accountId}: reconnecting`);
+    }
+    /** Handle sync errors — classify and emit appropriate UI events */
+    handleSyncError(accountId, errMsg) {
+        if (errMsg.includes("max_userip_connections") || errMsg.includes("Too many simultaneous")) {
+            this.connectionBackoff.set(accountId, Date.now() + 60000);
+        }
+        const config = this.configs.get(accountId);
+        const isOAuth = !!config?.tokenProvider;
+        const isTransient = /timeout|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|Too many/i.test(errMsg);
+        const isAuth = /auth|login|credential|token|AUTHENTICATIONFAILED/i.test(errMsg);
+        if (isTransient) {
+            console.log(`  [transient] ${accountId}: ${errMsg} — will retry next cycle`);
+        }
+        else if (isAuth && isOAuth) {
+            const lastReauth = this.lastReauthAttempt.get(accountId) || 0;
+            if (Date.now() - lastReauth > 300000 && !this.reauthenticating.has(accountId)) {
+                this.lastReauthAttempt.set(accountId, Date.now());
+                this.reauthenticate(accountId).catch(() => { });
+            }
+            if (!this.accountErrorShown.has(accountId)) {
+                this.accountErrorShown.add(accountId);
+                this.emit("accountError", accountId, errMsg, "Authentication expired — re-authenticate", true);
+            }
+        }
+        else if (!this.accountErrorShown.has(accountId)) {
+            this.accountErrorShown.add(accountId);
+            this.emit("accountError", accountId, errMsg, isOAuth ? "Authentication may have expired" : "Check server connectivity", isOAuth);
+        }
     }
     /** Sync just INBOX for each account (fast check for new mail) */
     async syncInbox() {
@@ -776,42 +714,17 @@ export class ImapManager extends EventEmitter {
         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 = await this.createClientWithLimit(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;
-                        }
-                    }
+                    await this.withConnection(accountId, async (client) => {
+                        await this.syncFolder(accountId, inbox.id, client);
+                    });
                 }
                 catch (e) {
                     console.error(`  [inbox] Sync error for ${accountId}: ${e.message}`);
                 }
-                finally {
-                    if (client)
-                        try {
-                            await client.logout();
-                        }
-                        catch { /* ignore */ }
-                }
             }
         }
         finally {
@@ -828,40 +741,25 @@ 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 = await this.createClientWithLimit(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 = await this.createClientWithLimit(accountId);
-                await this.syncFolder(accountId, inbox.id, client);
-                await client.logout();
-                client = null;
-            }
+            await this.withConnection(accountId, async (client) => {
+                const count = await client.getMessagesCount("INBOX");
+                const prev = this.lastInboxCounts.get(accountId) ?? count;
+                this.lastInboxCounts.set(accountId, count);
+                if (count !== prev) {
+                    console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
+                    await this.syncFolder(accountId, inbox.id, client);
+                }
+            });
         }
         catch {
             // Lightweight check — silently ignore errors
         }
         finally {
-            if (client) {
-                try {
-                    await client.logout();
-                }
-                catch { /* ignore */ }
-            }
             this.quickCheckRunning.delete(accountId);
         }
     }
@@ -923,7 +821,9 @@ export class ImapManager extends EventEmitter {
             if (this.watchers.has(accountId))
                 continue;
             try {
-                const watchClient = await this.createClientWithLimit(accountId);
+                // IDLE uses createClient (not createClientWithLimit) — it's a persistent
+                // background connection that must NOT consume a semaphore slot
+                const watchClient = this.createClient(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
@@ -960,15 +860,7 @@ export class ImapManager extends EventEmitter {
         this.fetchQueues.set(accountId, next);
         return next;
     }
-    /** Get or create a persistent client for body fetching */
-    async getFetchClient(accountId) {
-        let client = this.fetchClients.get(accountId);
-        if (!client) {
-            client = await this.createClientWithLimit(accountId);
-            this.fetchClients.set(accountId, client);
-        }
-        return client;
-    }
+    // Body fetch uses withConnection — no separate client needed
     /** Fetch a single message body on demand, caching in the store */
     async fetchMessageBody(accountId, folderId, uid) {
         // Already cached?
@@ -986,33 +878,30 @@ export class ImapManager extends EventEmitter {
             if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
                 return this.bodyStore.getMessage(accountId, folderId, uid);
             }
-            for (let attempt = 0; attempt < 2; attempt++) {
-                try {
-                    const client = await this.getFetchClient(accountId);
-                    // 30s timeout — prevents hanging on stale connections
-                    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");
-                    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 */ }
+            // Body fetch uses a fresh connection — never waits behind background sync
+            let client = null;
+            try {
+                client = this.newClient(accountId);
+                const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
+                await client.logout();
+                client = null;
+                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}): ${e.message}`);
+                if (client) {
+                    try {
+                        await client.logout();
                     }
-                    if (attempt === 1)
-                        return null;
+                    catch { /* */ }
                 }
+                return null;
             }
-            return null;
         });
     }
     /** Get the body store for direct access */
@@ -1148,8 +1037,7 @@ export class ImapManager extends EventEmitter {
         if (actions.length === 0)
             return;
         const folders = this.db.getFolders(accountId);
-        const client = await this.createClientWithLimit(accountId);
-        try {
+        await this.withConnection(accountId, async (client) => {
             for (const action of actions) {
                 const folder = folders.find(f => f.id === action.folderId);
                 if (!folder) {
@@ -1202,13 +1090,7 @@ export class ImapManager extends EventEmitter {
                     }
                 }
             }
-        }
-        finally {
-            try {
-                await client.logout();
-            }
-            catch { /* ignore */ }
-        }
+        });
     }
     /** Find a folder by specialUse, case-insensitive */
     findFolder(accountId, specialUse) {
@@ -1731,27 +1613,10 @@ export class ImapManager extends EventEmitter {
         this.stopPeriodicSync();
         this.stopOutboxWorker();
         await this.stopWatching();
-        // Disconnect all persistent fetch clients
-        for (const [, client] of this.fetchClients) {
-            try {
-                await client.logout();
-            }
-            catch { /* ignore */ }
-        }
-        this.fetchClients.clear();
-        // Force-release all semaphore slots to unblock any waiting operations
-        for (const [accountId, sem] of this.connectionSemaphore) {
-            sem.active = 0;
-            for (const waiter of sem.waiting) {
-                try {
-                    waiter();
-                }
-                catch { /* */ }
-            }
-            sem.waiting.length = 0;
+        // Disconnect all persistent operational connections
+        for (const [accountId] of this.opsClients) {
+            await this.disconnectOps(accountId);
         }
-        this.connectionSemaphore.clear();
-        this.activeConnections.clear();
     }
 }
 //# sourceMappingURL=index.js.map