@bobfrankston/mailx 1.0.385 → 1.0.386

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.385",
+  "version": "1.0.386",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.7",
     "@bobfrankston/miscinfo": "^1.0.9",
     "@bobfrankston/oauthsupport": "^1.0.24",
-    "@bobfrankston/msger": "^0.1.348",
+    "@bobfrankston/msger": "^0.1.349",
     "@bobfrankston/mailx-host": "^0.1.4",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
@@ -88,7 +88,7 @@
       "@bobfrankston/iflow-node": "^0.1.7",
       "@bobfrankston/miscinfo": "^1.0.9",
       "@bobfrankston/oauthsupport": "^1.0.24",
-      "@bobfrankston/msger": "^0.1.348",
+      "@bobfrankston/msger": "^0.1.349",
       "@bobfrankston/mailx-host": "^0.1.4",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",

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

@@ -133,6 +133,11 @@ export declare class ImapManager extends EventEmitter {
     private getBodyClient;
     /** Drop the body-fetch connection (e.g. after a socket error). */
     private dropBodyClient;
+    /** Force-close every pooled client for an account — ops, body, any
+     *  lingering ones in openClients. Used when the server reports its
+     *  connection cap is hit so our slot count drops to zero on the
+     *  server side before backoff expires. */
+    closeAllClients(accountId: string): Promise<void>;
     /** Disconnect the persistent operational connection for an account */
     disconnectOps(accountId: string): Promise<void>;
     /** Legacy API — callers that still create/destroy connections.

package/packages/mailx-imap/index.js

@@ -498,6 +498,50 @@ export class ImapManager extends EventEmitter {
         }
         catch { /* */ }
     }
+    /** Force-close every pooled client for an account — ops, body, any
+     *  lingering ones in openClients. Used when the server reports its
+     *  connection cap is hit so our slot count drops to zero on the
+     *  server side before backoff expires. */
+    async closeAllClients(accountId) {
+        const ops = this.opsClients.get(accountId);
+        this.opsClients.delete(accountId);
+        if (ops) {
+            try {
+                await (ops._realLogout || ops.logout)();
+            }
+            catch { /* */ }
+            try {
+                ops.destroy?.();
+            }
+            catch { /* */ }
+        }
+        const body = this.bodyClients.get(accountId);
+        this.bodyClients.delete(accountId);
+        if (body) {
+            try {
+                await (body._realLogout || body.logout)();
+            }
+            catch { /* */ }
+            try {
+                body.destroy?.();
+            }
+            catch { /* */ }
+        }
+        const open = this.openClients.get(accountId);
+        if (open) {
+            for (const c of Array.from(open)) {
+                try {
+                    await (c._realLogout || c.logout)?.();
+                }
+                catch { /* */ }
+                try {
+                    c.destroy?.();
+                }
+                catch { /* */ }
+            }
+            open.clear();
+        }
+    }
     /** Disconnect the persistent operational connection for an account */
     async disconnectOps(accountId) {
         const client = this.opsClients.get(accountId);
@@ -1441,7 +1485,16 @@ export class ImapManager extends EventEmitter {
     /** 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);
+            // Dovecot connection cap hit. 60s was too short — the server
+            // tracks slots with a decay window, and mailx was racing right
+            // back into the cap every time. Extend to 5 min AND close all
+            // pooled clients so the server's count drops to zero. Also
+            // mark all of this account's folder-cooldowns so prefetch
+            // doesn't try to reopen during the backoff.
+            const BACKOFF_MS = 5 * 60_000;
+            this.connectionBackoff.set(accountId, Date.now() + BACKOFF_MS);
+            this.closeAllClients(accountId).catch(() => { });
+            console.warn(`  [conn] ${accountId}: server connection cap hit — closing all clients + ${BACKOFF_MS / 1000}s backoff`);
         }
         const config = this.configs.get(accountId);
         const isOAuth = !!config?.tokenProvider;
@@ -2139,9 +2192,19 @@ export class ImapManager extends EventEmitter {
                             this.clearFolderErrors(accountId, folder.path);
                         }
                         catch (e) {
-                            console.error(`  [prefetch] ${accountId} folder ${folder.path}: batch fetch failed: ${e.message}`);
+                            const msg = String(e?.message || "");
+                            console.error(`  [prefetch] ${accountId} folder ${folder.path}: batch fetch failed: ${msg}`);
                             counters.errors++;
                             this.recordFolderError(accountId, folder.path);
+                            // Server connection cap hit during prefetch — this is why
+                            // bobma log shows "100+ bodies to fetch" with no follow-up
+                            // "done": subsequent folders also hit the cap, burn the
+                            // budget, and nothing progresses. Route through the
+                            // sync-error handler so backoff + closeAllClients kick in.
+                            if (/max_userip_connections|Too many simultaneous/i.test(msg)) {
+                                this.handleSyncError(accountId, msg);
+                                break;
+                            }
                             if (counters.errors >= ERROR_BUDGET)
                                 break;
                         }

package/packages/mailx-store/db.js

@@ -1023,32 +1023,41 @@ export class MailxDB {
     }
     /** Search contacts by name or email prefix */
     searchContacts(query, limit = 10) {
-        // Two-pass ranking so autocomplete feels responsive: rows whose name or
-        // local-part starts with the query rank first (exact prefix match is
-        // usually what the user wants), then substring matches fill out the
-        // rest. Within each tier, sort by (recency-weighted use_count) so a
-        // contact the user messaged today beats one from two years ago even
-        // if the older one has more total sends. Recency bonus: +1 per send
-        // decayed by ~half every 30 days.
-        const prefixQ = `${query}%`;
+        // Ranking: prefix matches beat substring matches, then recency-weighted
+        // use_count within a tier. Recency decay: half-life of 30 days, so a
+        // contact used today edges out one from months ago even with a lower
+        // raw use_count. Computed in JS since SQLite lacks exp/log.
+        //
+        // Wrapped in try/catch + simple-query fallback so a (hypothetical) SQL
+        // edge case on exotic input can never leave autocomplete showing blank.
+        // The rank-0 baseline is identical behavior to the original query.
         const substr = `%${query}%`;
-        const rows = this.db.prepare(`SELECT name, email, source, use_count, last_used,
-                    (CASE
-                        WHEN lower(name) LIKE lower(?) THEN 3
-                        WHEN substr(email, 1, instr(email, '@') - 1) LIKE lower(?) THEN 2
-                        WHEN email LIKE ? OR name LIKE ? THEN 1
-                        ELSE 0
-                     END) AS match_rank
-             FROM contacts
-             WHERE email LIKE ? OR name LIKE ?
-             ORDER BY match_rank DESC, use_count DESC, last_used DESC
-             LIMIT ?`).all(prefixQ, prefixQ, substr, substr, substr, substr, limit);
-        // Recency-weighted rescore, best-in-JS since SQLite lacks log/exp
-        // natively. 30-day half-life — close enough to "recent contacts
-        // float up" without being fussy about the exact decay curve.
+        let rows;
+        try {
+            const prefixQ = `${query}%`;
+            rows = this.db.prepare(`SELECT name, email, source, use_count, last_used,
+                        (CASE
+                            WHEN lower(name) LIKE lower(?) THEN 3
+                            WHEN substr(email, 1, instr(email, '@') - 1) LIKE lower(?) THEN 2
+                            WHEN email LIKE ? OR name LIKE ? THEN 1
+                            ELSE 0
+                         END) AS match_rank
+                 FROM contacts
+                 WHERE email LIKE ? OR name LIKE ?
+                 ORDER BY match_rank DESC, use_count DESC, last_used DESC
+                 LIMIT ?`).all(prefixQ, prefixQ, substr, substr, substr, substr, limit);
+        }
+        catch (e) {
+            console.error(`  [searchContacts] ranked query failed (${e?.message}) — falling back to simple LIKE`);
+            rows = this.db.prepare(`SELECT name, email, source, use_count, last_used, 0 AS match_rank
+                 FROM contacts
+                 WHERE email LIKE ? OR name LIKE ?
+                 ORDER BY use_count DESC, last_used DESC
+                 LIMIT ?`).all(substr, substr, limit);
+        }
         const now = Date.now();
         const HALF_LIFE_MS = 30 * 86400_000;
-        const score = (r) => r.match_rank * 10_000
+        const score = (r) => (r.match_rank || 0) * 10_000
             + (r.use_count || 0) * Math.pow(0.5, Math.max(0, now - (r.last_used || 0)) / HALF_LIFE_MS);
         rows.sort((a, b) => score(b) - score(a));
         return rows.map(r => ({ name: r.name, email: r.email, source: r.source, useCount: r.use_count }));