@bobfrankston/mailx 1.0.99 → 1.0.100

package/package.json

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

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

@@ -47,9 +47,13 @@ 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;
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag. */
     private createClient;
+    /** Track client logout for connection counting */
+    private trackLogout;
     /** Register an account */
     addAccount(account: AccountConfig): Promise<void>;
     /** Sync folder list for an account */

package/packages/mailx-imap/index.js

@@ -179,6 +179,11 @@ export class ImapManager extends EventEmitter {
     createPublicClient(accountId) {
         return this.createClient(accountId);
     }
+    // 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
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag. */
     createClient(accountId) {
@@ -192,11 +197,21 @@ 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;
+        this.activeConnections.set(accountId, count);
+        const clientType = this.useNativeClient ? "native" : "imapflow";
+        console.log(`  [conn] ${accountId}: +1 ${clientType} (${count} active)`);
         if (this.useNativeClient) {
             return new CompatImapClient(config, () => new NodeTransport({ rejectUnauthorized: config.rejectUnauthorized !== false }));
         }
         return new ImapClient(config);
     }
+    /** Track client logout for connection counting */
+    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)`);
+    }
     /** Register an account */
     async addAccount(account) {
         if (this.configs.has(account.id))
@@ -233,7 +248,10 @@ export class ImapManager extends EventEmitter {
         if (!client)
             client = this.createClient(accountId);
         this.emit("syncProgress", accountId, "folders", 0);
+        const t0 = Date.now();
+        console.log(`  [diag] ${accountId}: getFolderList starting...`);
         const folders = await client.getFolderList();
+        console.log(`  [diag] ${accountId}: getFolderList done in ${Date.now() - t0}ms (${folders.length} folders)`);
         const specialFolders = client.getSpecialFolders(folders);
         for (const folder of folders) {
             // Skip non-selectable folders (virtual parents like "Added", "Added2")
@@ -381,10 +399,9 @@ export class ImapManager extends EventEmitter {
         // Remove messages deleted on the server (skip on first sync — nothing to reconcile)
         let deletedCount = 0;
         if (!firstSync) {
-            let delClient = null;
             try {
-                delClient = this.createClient(accountId);
-                const serverUids = new Set(await delClient.getUids(folder.path));
+                // Reuse the passed-in client instead of opening a new connection
+                const serverUids = new Set(await client.getUids(folder.path));
                 const localUids = this.db.getUidsForFolder(accountId, folderId);
                 for (const uid of localUids) {
                     if (!serverUids.has(uid)) {
@@ -395,18 +412,10 @@ export class ImapManager extends EventEmitter {
                 }
                 if (deletedCount > 0)
                     console.log(`    removed ${deletedCount} deleted messages`);
-                await delClient.logout();
             }
             catch (e) {
                 console.error(`    deletion sync error: ${e.message}`);
             }
-            finally {
-                if (delClient)
-                    try {
-                        await delClient.logout();
-                    }
-                    catch { /* ignore */ }
-            }
         }
         // Update folder counts from local DB (after deletions + additions)
         const result = this.db.getMessages({ accountId, folderId, page: 1, pageSize: 1 });
@@ -443,12 +452,17 @@ export class ImapManager extends EventEmitter {
         for (const [accountId] of this.configs) {
             let client = null;
             try {
+                const t0 = Date.now();
                 client = this.createClient(accountId);
                 const folders = await Promise.race([
                     this.syncFolders(accountId, client),
                     new Promise((_, reject) => setTimeout(() => reject(new Error("Folder list timeout (30s)")), 30000))
                 ]);
+                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();
+                this.trackLogout(accountId);
                 client = null;
                 accountFolders.set(accountId, folders);
                 // Sync inbox immediately
@@ -461,6 +475,7 @@ export class ImapManager extends EventEmitter {
                             new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout (60s)")), 60000))
                         ]);
                         await client.logout();
+                        this.trackLogout(accountId);
                         client = null;
                     }
                     catch (e) {
@@ -469,6 +484,7 @@ export class ImapManager extends EventEmitter {
                                 await client.logout();
                             }
                             catch { /* ignore */ }
+                            this.trackLogout(accountId);
                             client = null;
                         }
                         console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
@@ -515,11 +531,13 @@ export class ImapManager extends EventEmitter {
                 }
             }
             finally {
-                if (client)
+                if (client) {
                     try {
                         await client.logout();
                     }
                     catch { /* ignore */ }
+                    this.trackLogout(accountId);
+                }
             }
         }
         // Phase 2: Sync remaining folders — priority order, skip Trash subfolders on first sync
@@ -532,41 +550,51 @@ export class ImapManager extends EventEmitter {
                 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;
-            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 {
-                    client = this.createClient(accountId);
-                    await Promise.race([
-                        this.syncFolder(accountId, folder.id, client),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout (${timeout / 1000}s)`)), timeout))
-                    ]);
-                    await client.logout();
-                    client = null;
-                }
-                catch (e) {
-                    if (client) {
-                        try {
-                            await client.logout();
-                        }
-                        catch { /* ignore */ }
-                        client = null;
+            try {
+                client = this.createClient(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;
                     }
-                    if (e.responseText?.includes("doesn't exist")) {
-                        console.log(`  Removing non-existent folder: ${folder.path}`);
-                        this.db.deleteFolder(folder.id);
+                    // Longer timeout for folders we know are large (Trash, first sync)
+                    const timeout = highestUid === 0 ? 180000 : 60000;
+                    try {
+                        await Promise.race([
+                            this.syncFolder(accountId, folder.id, client),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout (${timeout / 1000}s) on ${folder.path}`)), timeout))
+                        ]);
                     }
-                    else {
-                        console.error(`  Skipping folder ${folder.path}: ${e.message}`);
+                    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 { /* */ }
+                            this.trackLogout(accountId);
+                            client = this.createClient(accountId);
+                        }
+                    }
+                }
+            }
+            finally {
+                if (client) {
+                    try {
+                        await client.logout();
                     }
+                    catch { /* */ }
+                    this.trackLogout(accountId);
                 }
             }
             this.accountErrorShown.delete(accountId);