@bobfrankston/mailx 1.0.154 → 1.0.156

package/bin/mailx.js

@@ -657,13 +657,10 @@ async function main() {
     // Pass server version to dispatch so getVersion returns it
     const rootPkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8"));
     handle.onRequest(async (req) => {
-        if (verbose)
-            console.error(`[ipc] ← ${req._action} (${req._cbid})`);
-        req._version = rootPkg.version;
+        console.log(`[ipc] ← ${req._action} (${req._cbid})`);
         try {
             const response = await dispatch(svc, req);
-            if (verbose)
-                console.error(`[ipc] → ${req._action} (${req._cbid}) ok`);
+            console.log(`[ipc] → ${req._action} (${req._cbid}) ok`);
             handle.send(response);
         }
         catch (e) {
@@ -671,12 +668,34 @@ async function main() {
             handle.send({ _cbid: req._cbid, error: e.message });
         }
     });
-    // Wire IMAP events → push to WebView
+    // Wire IMAP events → push to WebView (throttled to avoid flooding stdin)
+    let pendingSyncProgress = {};
+    let syncProgressTimer = null;
     imapManager.on("syncProgress", (accountId, phase, progress) => {
-        handle.send({ _event: "syncProgress", type: "syncProgress", accountId, phase, progress });
+        pendingSyncProgress[accountId] = { phase, progress };
+        if (!syncProgressTimer) {
+            syncProgressTimer = setTimeout(() => {
+                syncProgressTimer = null;
+                for (const [id, p] of Object.entries(pendingSyncProgress)) {
+                    handle.send({ _event: "syncProgress", type: "syncProgress", accountId: id, phase: p.phase, progress: p.progress });
+                }
+                pendingSyncProgress = {};
+            }, 500); // batch sync events every 500ms
+        }
     });
+    let pendingCounts = {};
+    let countsTimer = null;
     imapManager.on("folderCountsChanged", (accountId, counts) => {
-        handle.send({ _event: "folderCountsChanged", type: "folderCountsChanged", accountId, counts });
+        pendingCounts[accountId] = counts;
+        if (!countsTimer) {
+            countsTimer = setTimeout(() => {
+                countsTimer = null;
+                for (const [id, c] of Object.entries(pendingCounts)) {
+                    handle.send({ _event: "folderCountsChanged", type: "folderCountsChanged", accountId: id, ...c });
+                }
+                pendingCounts = {};
+            }, 1000); // batch count updates every 1s
+        }
     });
     imapManager.on("syncError", (accountId, error) => {
         handle.send({ _event: "error", type: "error", message: `${accountId}: ${error}` });

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,14 +899,20 @@ optAutocomplete?.addEventListener("change", () => {
     }).catch(() => { });
 });
 const isApp = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-// Retry getVersion — IPC may not be ready on first call
+// Retry getVersion — first IPC calls may be lost before Rust process is ready
 async function getVersionWithRetry() {
+    // Wait for IPC to be established (first getAccounts succeeds around cbid 3)
+    await new Promise(r => setTimeout(r, 3000));
     for (let i = 0; i < 5; i++) {
         try {
-            return await getVersion();
+            const result = await Promise.race([
+                getVersion(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 5000))
+            ]);
+            return result;
         }
         catch {
-            await new Promise(r => setTimeout(r, 1000));
+            await new Promise(r => setTimeout(r, 2000));
         }
     }
     return { version: "?", storage: {} };
@@ -1017,7 +1024,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/folder-tree.js

@@ -603,11 +603,16 @@ async function loadFolderTree(container) {
         setTimeout(() => overlay?.remove(), 400);
     }
     catch (e) {
-        const errEl = document.createElement("div");
-        errEl.className = "folder-loading";
-        errEl.textContent = `Error loading folders: ${e.message}`;
-        container.replaceChildren(errEl);
-        // Dismiss overlay on error too — show the error, not a spinner
+        // Don't destroy existing folder tree on error — just log it
+        console.error(`Folder tree error: ${e.message}`);
+        // Only show error if tree is completely empty (first load failure)
+        if (container.children.length === 0 || container.querySelector(".folder-loading")) {
+            const errEl = document.createElement("div");
+            errEl.className = "folder-loading";
+            errEl.textContent = `Error loading folders: ${e.message}`;
+            container.replaceChildren(errEl);
+        }
+        // Dismiss overlay on error too
         const overlay = document.getElementById("startup-overlay");
         if (overlay) {
             const status = document.getElementById("startup-status");

package/client/index.html

@@ -128,9 +128,9 @@
 
     <footer class="status-bar" id="status-bar">
         <span id="status-accounts"></span>
-        <span id="status-sync"></span>
+        <span id="status-sync">Syncing...</span>
         <span id="status-pending"></span>
-        <span id="status-queue">Queue: empty</span>
+        <span id="status-queue"></span>
     </footer>
 
     <div id="startup-overlay" class="startup-overlay">

package/client/lib/mailxapi.js

@@ -73,8 +73,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.154",
+  "version": "1.0.156",
   "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.204",
+    "@bobfrankston/msger": "^0.1.206",
     "@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,8 @@ export declare class ImapManager extends EventEmitter {
     /** Sync all folders for all accounts */
     syncAll(): Promise<void>;
     private _syncAll;
+    /** 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 +106,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 */
@@ -616,156 +594,87 @@ 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();
+        const priorityOrder = ["sent", "drafts", "archive", "junk", "trash"];
+        // Sync each account sequentially — one connection each, reused for all operations
         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);
-                        await withTimeout(this.syncFolder(accountId, inbox.id, client), 60000, client, "Inbox sync");
-                        await client.logout();
-                        client = null;
+                await this.withConnection(accountId, async (client) => {
+                    // Step 1: Get folder list
+                    const t0 = Date.now();
+                    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)`);
+                    // Step 2: Sync INBOX first (most important)
+                    const inbox = folders.find(f => f.specialUse === "inbox");
+                    if (inbox) {
+                        try {
+                            await this.syncFolder(accountId, inbox.id, client);
+                        }
+                        catch (e) {
+                            console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
+                        }
                     }
-                    catch (e) {
-                        if (client) {
-                            try {
-                                await client.logout();
+                    // Step 3: Sync remaining folders in priority order
+                    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;
+                    });
+                    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; // defer trash subfolders on first sync
+                        try {
+                            await this.syncFolder(accountId, folder.id, client);
+                        }
+                        catch (e) {
+                            if (e.responseText?.includes("doesn't exist")) {
+                                this.db.deleteFolder(folder.id);
+                            }
+                            else {
+                                console.error(`  Skipping folder ${folder.path}: ${e.message}`);
                             }
-                            catch { /* ignore */ }
-                            this.trackLogout(accountId);
-                            client = null;
                         }
-                        console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
                     }
-                }
+                });
+                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}`);
-                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);
-                }
-            }
-            finally {
-                if (client) {
-                    try {
-                        await client.logout();
-                    }
-                    catch { /* ignore */ }
-                    this.trackLogout(accountId);
-                }
+                this.handleSyncError(accountId, errMsg);
             }
         }
-        // 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
-            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}`);
-                    }
-                    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);
-                        }
-                    }
-                }
+    }
+    /** 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(() => { });
             }
-            finally {
-                if (client) {
-                    try {
-                        await client.logout();
-                    }
-                    catch { /* */ }
-                    this.trackLogout(accountId);
-                }
+            if (!this.accountErrorShown.has(accountId)) {
+                this.accountErrorShown.add(accountId);
+                this.emit("accountError", accountId, errMsg, "Authentication expired — re-authenticate", true);
             }
-            this.accountErrorShown.delete(accountId);
-            this.emit("syncComplete", accountId);
+        }
+        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) */
@@ -775,42 +684,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 {
@@ -827,40 +711,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);
         }
     }
@@ -885,8 +754,10 @@ export class ImapManager extends EventEmitter {
             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
+        // Sync actions (sends + flags/deletes/moves) every 30 seconds — skip during active sync
         const actionsInterval = setInterval(async () => {
+            if (this.syncing)
+                return;
             for (const [accountId] of this.configs) {
                 this.processSendActions(accountId).catch(() => { });
                 this.processSyncActions(accountId).catch(() => { });
@@ -920,7 +791,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
@@ -957,15 +830,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?
@@ -983,33 +848,21 @@ 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");
+            try {
+                return await this.withConnection(accountId, async (client) => {
+                    const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
                     if (!msg?.source)
                         return null;
                     const raw = Buffer.from(msg.source, "utf-8");
                     const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
                     this.db.updateBodyPath(accountId, uid, bodyPath);
                     return raw;
-                }
-                catch (e) {
-                    console.error(`  Body fetch error (${accountId}/${uid} attempt ${attempt + 1}): ${e.message}`);
-                    const stale = this.fetchClients.get(accountId);
-                    this.fetchClients.delete(accountId);
-                    if (stale) {
-                        try {
-                            await stale.logout();
-                        }
-                        catch { /* ignore */ }
-                    }
-                    if (attempt === 1)
-                        return null;
-                }
+                });
+            }
+            catch (e) {
+                console.error(`  Body fetch error (${accountId}/${uid}): ${e.message}`);
+                return null;
             }
-            return null;
         });
     }
     /** Get the body store for direct access */
@@ -1136,7 +989,8 @@ export class ImapManager extends EventEmitter {
     async updateFlagsLocal(accountId, uid, folderId, flags) {
         this.db.updateMessageFlags(accountId, uid, flags);
         this.db.queueSyncAction(accountId, "flags", uid, folderId, { flags });
-        this.processSyncActions(accountId).catch(() => { });
+        // Don't process immediately — let the 30s timer batch actions
+        // (immediate processing during sync causes connection churn)
     }
     /** Process pending sync actions for an account */
     async processSyncActions(accountId) {
@@ -1144,8 +998,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) {
@@ -1198,13 +1051,7 @@ export class ImapManager extends EventEmitter {
                     }
                 }
             }
-        }
-        finally {
-            try {
-                await client.logout();
-            }
-            catch { /* ignore */ }
-        }
+        });
     }
     /** Find a folder by specialUse, case-insensitive */
     findFolder(accountId, specialUse) {
@@ -1727,27 +1574,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