@bobfrankston/rmfmail 1.2.48 → 1.2.49

package/packages/mailx-imap/index.ts

@@ -24,15 +24,13 @@ const SMTP_PORT_STARTTLS = 587;
 const SMTP_PORT_IMPLICIT_TLS = 465;
 
 type OpsTask = () => Promise<void>;
-interface OpsQueue {
-    fast: OpsTask[];
-    slow: OpsTask[];
-    /** Whether the fast lane is currently draining a task. Independent of
-     *  `runningSlow` — both lanes can drain concurrently because each uses
-     *  its own connection (fastClient vs. opsClient). C123: the second
-     *  connection is lazy-allocated on the first fast-lane task. */
-    runningFast: boolean;
-    runningSlow: boolean;
+/** One FIFO task queue per (account, lane). All lanes drain concurrently —
+ *  each lane runs on its own persistent connection — so a slow op on one lane
+ *  never blocks another. Within a lane, strictly sequential (one IMAP command
+ *  in flight, no SELECT races). */
+interface LaneQueue {
+    tasks: OpsTask[];
+    running: boolean;
 }
 interface HostSemaphore {
     permits: number;
@@ -591,39 +589,45 @@ export class ImapManager extends EventEmitter {
     // No semaphore, no pool, no per-operation connect/disconnect.
     // IDLE uses a separate connection (see startWatching).
 
-    /** Persistent slow-lane operational connection per account. Used by sync,
-     *  prefetch, outbox-append, large backfills, and any other "this might
-     *  take a while" operation. */
-    private opsClients = new Map<string, any>();
-    /** Lazy-allocated fast-lane client per account (C123). Lives alongside
-     *  `opsClients` so click-time body fetches and flag toggles don't have
-     *  to wait behind a multi-minute prefetch / backfill on the slow client.
-     *  Created on the first fast-lane `withConnection` call; reused while
-     *  alive; recreated on stale-detect or error-discard like opsClients.
-     *  Costs +1 IMAP socket per active account, well under any reasonable
-     *  per-user-IP cap (Dovecot's default is 20). */
-    private fastClients = new Map<string, any>();
-    /** Two-lane operation queue per account — interactive ops (body fetch on
-     *  click, flag toggle) drain before background ops (sync, prefetch). FIFO
-     *  within each lane. The single ops connection means there's never a race
-     *  on which folder is SELECTed; commands run strictly sequentially. */
-    private opsQueues = new Map<string, OpsQueue>();
+    /** Per-workload connection lanes. Each (lane, account) gets its OWN
+     *  persistent IMAP connection so a slow op on one lane can't block another:
+     *  a 90s `SELECT Sent` on "outbox" or a giant `UID FETCH` on "prefetch" no
+     *  longer wedges INBOX sync/backfill on "sync". This is the root fix for
+     *  the "whole sync worker goes silent" wedge (Bob 2026-06-20): before, all
+     *  background work shared ONE slow connection and serialized behind the
+     *  slowest command (a 90s SELECT Sent / a giant prefetch FETCH stalled
+     *  INBOX backfill behind it). Lanes in use:
+     *    fast     — interactive: body fetch on click, flag toggle, move
+     *    slow     — folder sync + set-diff backfill (the `{slow:true}` default)
+     *    prefetch — background body download (heaviest, longest)
+     *    outbox   — send + sent-sweep + Outbox/Sent SELECT/APPEND
+     *  Per account that's ≤4 persistent sockets + 1 IDLE, under Dovecot's 20.
+     *  laneName → (accountId → persistent client). */
+    private laneClients = new Map<string, Map<string, any>>();
+    /** Per-account, per-lane FIFO task queues. accountId → (laneName → queue).
+     *  All lanes for an account drain concurrently (each on its own socket);
+     *  within a lane, strictly sequential — no SELECT race. */
+    private laneQueues = new Map<string, Map<string, LaneQueue>>();
     /** Per-host semaphore — caps simultaneous IMAP socket opens to one server.
-     *  Defensive guardrail: with the single-ops-per-account model an individual
-     *  user's mailx never hits more than (#accounts × 2) sockets per host, well
-     *  under any reasonable server cap. Exists for the multi-account-on-one-host
-     *  case (e.g. bobma + bobma2 both on imap.iecc.com). */
+     *  Defensive guardrail for the multi-account-on-one-host case (e.g. bobma +
+     *  bobma2 both on imap.iecc.com). NOTE: the permit is held for the
+     *  connection's LIFETIME (released on logout/destroy), not just the open —
+     *  so this also bounds the number of live persistent connections per host.
+     *  Each account now keeps up to 4 persistent lanes (fast/slow/prefetch/
+     *  outbox) + 1 IDLE (IDLE bypasses the semaphore). 8 permits covers two
+     *  accounts' lanes with headroom, still far under Dovecot's ~20/user+IP. */
     private hostSemaphores = new Map<string, HostSemaphore>();
-    private static readonly HOST_PERMITS = 4;
-
-    /** Get (or create) a persistent connection for an account on the named
-     *  lane. Two lanes today: `slow` (the original `opsClients` map — sync,
-     *  prefetch, backfill, outbox) and `fast` (the C123 `fastClients` map —
-     *  click-time body fetch, flag toggles, anything user-driven). Same
-     *  stale-detect + reconnect semantics on both. logout() is wrapped as a
-     *  no-op so legacy callers don't close the persistent client. */
-    private async getLaneClient(accountId: string, lane: "fast" | "slow"): Promise<any> {
-        const map = lane === "fast" ? this.fastClients : this.opsClients;
+    private static readonly HOST_PERMITS = 8;
+
+    /** The (accountId → client) map for a lane, created on first use. */
+    private laneClientMap(lane: string): Map<string, any> {
+        let m = this.laneClients.get(lane);
+        if (!m) { m = new Map(); this.laneClients.set(lane, m); }
+        return m;
+    }
+
+    private async getLaneClient(accountId: string, lane: string): Promise<any> {
+        const map = this.laneClientMap(lane);
         let client = map.get(accountId);
         if (client) {
             // C38: health-check the cached client before returning. If the
@@ -640,7 +644,7 @@ export class ImapManager extends EventEmitter {
             console.log(`  [conn] ${accountId}: stale ${lane} client detected — reconnecting`);
             client = undefined as any;
         }
-        client = await this.newClient(accountId, lane === "fast" ? "fast" : "ops");
+        client = await this.newClient(accountId, lane);
         // Wrap logout as no-op — this is a persistent connection. The
         // newClient wrapper's close-counter runs on `_realLogout`.
         const realLogout = client.logout.bind(client);
@@ -657,33 +661,30 @@ export class ImapManager extends EventEmitter {
         return this.getLaneClient(accountId, "slow");
     }
 
-    /** Run an operation on the account's connection — queued, sequential, no concurrency */
-    /** Run an operation against the account's single ops connection. Tasks
-     *  queue strictly sequentially per account — only one IMAP command in
-     *  flight at a time. This eliminates the SELECT-races and "stale client
-     *  recovery" paths the old multi-client design needed.
+    /** Run an operation against one of the account's per-workload lane
+     *  connections. Tasks queue strictly sequentially WITHIN a lane (one IMAP
+     *  command in flight, no SELECT race) but lanes run CONCURRENTLY, each on
+     *  its own socket — so a slow op on one lane never blocks another.
      *
-     *  Default lane is `fast` — covers virtually everything (body fetch,
-     *  flag toggle, move, incremental sync). Pass `slow: true` only for
-     *  operations the caller knows will take a long time and shouldn't
-     *  block the user (multi-folder prefetch batches, large backfills).
-     *  When both lanes have tasks, fast drains first.
+     *  Pick the lane via `opts.lane` (e.g. "sync", "prefetch", "outbox").
+     *  Default is "fast" — interactive ops (body fetch on click, flag toggle,
+     *  move). `slow: true` is a legacy alias for the "slow" misc lane; prefer
+     *  a named lane so distinct workloads don't serialize behind each other.
      *
-     *  Within a lane, FIFO. The running task always finishes — IMAP can't
-     *  preempt a command mid-flight. */
+     *  The running task always finishes — IMAP can't preempt a command
+     *  mid-flight; the wall-clock timeout below bounds how long that can be. */
     async withConnection<T>(
         accountId: string,
         fn: (client: any) => Promise<T>,
-        opts: { slow?: boolean; timeoutMs?: number } = {},
+        opts: { slow?: boolean; lane?: string; timeoutMs?: number } = {},
     ): Promise<T> {
-        let queue = this.opsQueues.get(accountId);
-        if (!queue) {
-            queue = { fast: [], slow: [], runningFast: false, runningSlow: false };
-            this.opsQueues.set(accountId, queue);
-        }
-        const lane: "fast" | "slow" = opts.slow ? "slow" : "fast";
+        const lane: string = opts.lane ?? (opts.slow ? "slow" : "fast");
+        let perAccount = this.laneQueues.get(accountId);
+        if (!perAccount) { perAccount = new Map(); this.laneQueues.set(accountId, perAccount); }
+        let queue = perAccount.get(lane);
+        if (!queue) { queue = { tasks: [], running: false }; perAccount.set(lane, queue); }
         // Per-task wall-clock cap. Without one, a wedged IMAP command (TCP
-        // half-open, server stalled mid-FETCH) keeps the queue's running flag
+        // half-open, server stalled mid-FETCH) keeps the lane's running flag
         // set forever and every subsequent same-lane task — including the
         // retry button the user just hit — waits behind it. Default is
         // generous; callers driving user-visible reads pass a tighter value.
@@ -703,13 +704,12 @@ export class ImapManager extends EventEmitter {
                     resolve(result);
                 } catch (e: any) {
                     clearTimeout(timer);
-                    // Discard the lane's client on any error — a half-broken
-                    // socket poisons every subsequent request on that lane.
-                    // Don't touch the OTHER lane's client; the lanes are
-                    // independent. Destroy synchronously kills the in-flight
-                    // command's socket so the underlying promise rejects and
-                    // stops holding state.
-                    const map = lane === "fast" ? this.fastClients : this.opsClients;
+                    // Discard THIS lane's client on any error — a half-broken
+                    // socket poisons every subsequent request on the lane.
+                    // Other lanes' clients are independent and untouched.
+                    // Destroy synchronously kills the in-flight command's
+                    // socket so the underlying promise rejects.
+                    const map = this.laneClientMap(lane);
                     const stale = map.get(accountId);
                     map.delete(accountId);
                     if (stale) {
@@ -719,31 +719,27 @@ export class ImapManager extends EventEmitter {
                     reject(e);
                 }
             };
-            queue![lane].push(task);
+            queue!.tasks.push(task);
             this.drainOpsQueue(accountId);
         });
     }
 
-    /** Run the next queued task on each lane. Fast and slow lanes drain
-     *  CONCURRENTLY — each on its own connection (C123). FIFO within each
-     *  lane. The running flag per lane prevents reentrant draining of the
-     *  same lane. */
+    /** Drain the next queued task on EVERY lane for the account. Lanes run
+     *  concurrently — each on its own connection — and the per-lane running
+     *  flag prevents reentrant draining of the same lane. */
     private drainOpsQueue(accountId: string): void {
-        const queue = this.opsQueues.get(accountId);
-        if (!queue) return;
-        const drainLane = (lane: "fast" | "slow"): void => {
-            const runningKey = lane === "fast" ? "runningFast" : "runningSlow";
-            if (queue[runningKey]) return;
-            const next = queue[lane].shift();
-            if (!next) return;
-            queue[runningKey] = true;
+        const perAccount = this.laneQueues.get(accountId);
+        if (!perAccount) return;
+        for (const queue of perAccount.values()) {
+            if (queue.running) continue;
+            const next = queue.tasks.shift();
+            if (!next) continue;
+            queue.running = true;
             next().finally(() => {
-                queue[runningKey] = false;
-                drainLane(lane);
+                queue.running = false;
+                this.drainOpsQueue(accountId);
             });
-        };
-        drainLane("fast");
-        drainLane("slow");
+        }
     }
 
     /** Acquire one slot of the per-host connection semaphore. Returns a release
@@ -853,7 +849,7 @@ export class ImapManager extends EventEmitter {
      *  so the server's connection slots free immediately rather than
      *  waiting for socket idle timeouts. */
     async closeAllClients(accountId: string): Promise<void> {
-        for (const map of [this.opsClients, this.fastClients]) {
+        for (const map of this.laneClients.values()) {
             const c = map.get(accountId);
             map.delete(accountId);
             if (c) { try { await (c._realLogout || c.logout)(); } catch { /* */ } try { c.destroy?.(); } catch { /* */ } }
@@ -871,7 +867,7 @@ export class ImapManager extends EventEmitter {
     /** Disconnect the persistent operational connections (both lanes) for
      *  an account. */
     async disconnectOps(accountId: string): Promise<void> {
-        for (const [name, map] of [["ops", this.opsClients], ["fast", this.fastClients]] as const) {
+        for (const [name, map] of this.laneClients) {
             const client = map.get(accountId);
             map.delete(accountId);
             if (client) {
@@ -2524,12 +2520,15 @@ export class ImapManager extends EventEmitter {
         return stored;
     }
 
-    /** Kill and recreate the persistent ops connection */
+    /** Kill and recreate the persistent connections for an account — drops the
+     *  client on every lane so the next task on each reconnects fresh. */
     private async reconnectOps(accountId: string): Promise<void> {
-        const old = this.opsClients.get(accountId);
-        this.opsClients.delete(accountId);
-        if (old) { try { await (old._realLogout || old.logout)(); } catch { /* */ } }
-        console.log(`  [conn] ${accountId}: reconnecting`);
+        for (const map of this.laneClients.values()) {
+            const old = map.get(accountId);
+            map.delete(accountId);
+            if (old) { try { await (old._realLogout || old.logout)(); } catch { /* */ } }
+        }
+        console.log(`  [conn] ${accountId}: reconnecting (all lanes)`);
     }
 
     /** Handle sync errors — classify and emit appropriate UI events.
@@ -3562,7 +3561,7 @@ export class ImapManager extends EventEmitter {
                                     })());
                                 });
                                 await Promise.all(pending);
-                            }, { slow: true, timeoutMs: 300_000 });
+                            }, { lane: "prefetch", timeoutMs: 300_000 });
                             // 5-min cap, not the 90s interactive default:
                             // prefetch is background, and a 25-message body
                             // chunk on a slow Dovecot legitimately runs past
@@ -4326,7 +4325,7 @@ export class ImapManager extends EventEmitter {
             await this.withConnection(accountId, async (client) => {
                 await client.createmailbox("Outbox");
                 await this.syncFolders(accountId, client);
-            });
+            }, { lane: "outbox" });
         } catch (e: any) {
             // Might already exist — benign
             if (!e.message?.includes("already exists")) throw e;
@@ -4437,7 +4436,7 @@ export class ImapManager extends EventEmitter {
             await this.withConnection(accountId, async (client) => {
                 appendedUid = await client.appendMessage(outboxPath, rawMessage, ["\\Seen"]);
                 console.log(`  [outbox] Queued message in ${outboxPath}${appendedUid != null ? ` (UID ${appendedUid})` : ""}`);
-            });
+            }, { lane: "outbox" });
             if (outboxFolder) {
                 if (appendedUid != null) {
                     // Inserts the row from the source bytes we already have +
@@ -4644,7 +4643,9 @@ export class ImapManager extends EventEmitter {
         // claim so the recovery sweeper picks it up next tick.
         try {
             const outboxPath = await this.ensureOutbox(accountId);
-            const client = await this.createClientWithLimit(accountId);
+            // Outbox lane, not the slow/sync lane — a wedged APPEND here (which
+            // withTimeout force-closes the socket on) must not disrupt sync.
+            const client = await this.getLaneClient(accountId, "outbox");
             try {
                 for (const { dir, file } of filesToSend) {
                     const filePath = path.join(dir, file);
@@ -4780,9 +4781,9 @@ export class ImapManager extends EventEmitter {
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account) return;
 
-        // List UIDs first — quick command, fast lane.
+        // List UIDs first — quick command on the dedicated outbox lane.
         const uids = await this.withConnection(accountId, (client) =>
-            client.getUids(outboxFolder.path)
+            client.getUids(outboxFolder.path), { lane: "outbox" }
         ) as number[];
         if (uids.length === 0) return;
 
@@ -4792,9 +4793,9 @@ export class ImapManager extends EventEmitter {
         const sentFolder = this.findFolder(accountId, "sent");
 
         for (const uid of uids) {
-            // Each iteration is one slow-lane turn — fast-lane work can run
-            // between iterations, so a body click during a long outbox drain
-            // gets serviced promptly.
+            // Each iteration is one outbox-lane turn — sync, prefetch and
+            // fast-lane (click) work all run on their own connections, so a
+            // long outbox drain never blocks them.
             const result = await this.withConnection(accountId, async (client) => {
                 const flags = await client.getFlags(outboxFolder.path, uid);
 
@@ -4842,7 +4843,7 @@ export class ImapManager extends EventEmitter {
                     return { skip: true };
                 }
                 return { source: msg.source };
-            }, { slow: true });
+            }, { lane: "outbox" });
 
             if ((result as any).skip) continue;
             const source = (result as any).source as string;
@@ -4858,13 +4859,13 @@ export class ImapManager extends EventEmitter {
                 await this.withConnection(accountId, async (client) => {
                     // Delete FIRST to prevent double-send if Sent-copy fails.
                     await client.deleteMessageByUid(outboxFolder.path, uid);
-                }, { slow: true });
+                }, { lane: "outbox" });
                 if (sentFolder) {
                     let appendedSentUid: number | null = null;
                     try {
                         await this.withConnection(accountId, async (client) => {
                             appendedSentUid = await client.appendMessage(sentFolder.path, source, ["\\Seen"]);
-                        }, { slow: true });
+                        }, { lane: "outbox" });
                     } catch (sentErr: any) {
                         console.error(`  [outbox] Failed to copy to Sent: ${sentErr.message} — message was sent successfully`);
                     }
@@ -4894,7 +4895,7 @@ export class ImapManager extends EventEmitter {
                     await this.withConnection(accountId, async (client) => {
                         await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
                         await client.addFlags(outboxFolder.path, uid, ["$Failed"]);
-                    }, { slow: true });
+                    }, { lane: "outbox" });
                 } catch { /* best-effort */ }
                 // Suppress the banner for transient network errors. ETIMEDOUT
                 // on a Dovecot send is the server being slow / a TCP idle
@@ -5033,10 +5034,10 @@ export class ImapManager extends EventEmitter {
                     this.outboxBackoffDelay.delete(accountId);
                 } catch (e: any) {
                     // Stale-socket errors (Dovecot silently drops idle connections,
-                    // or the sync path timed out and destroyed the socket): force a
-                    // fresh ops client so the next tick doesn't keep hitting the same
-                    // dead socket. Without reconnectOps, the dead client stays in the
-                    // opsClients map and every subsequent processOutbox call fails
+                    // or the sync path timed out and destroyed the socket): force
+                    // fresh lane clients so the next tick doesn't keep hitting the
+                    // same dead socket. Without reconnectOps, the dead client stays
+                    // in its lane map and every subsequent processOutbox call fails
                     // immediately with "Not connected" — forever.
                     const msg = String(e?.message || e);
                     if (/Not connected|ECONNRESET|socket hang up|EPIPE|write after end/i.test(msg)) {
@@ -5136,19 +5137,18 @@ export class ImapManager extends EventEmitter {
         if (rows.length === 0) return;
         let reconciled = 0;
         let appended = 0;
-        // Use a DEDICATED IMAP client for sent-sweep — do NOT share the
-        // slow-lane ops client. The priority-INBOX sync grabs the slow-lane
-        // client via getOpsClient() (no lane queueing) and runs SEARCH→FETCH
-        // as a logical transaction; if sent-sweep's searchByHeader (SELECT
-        // Sent → SEARCH → CLOSE) interleaves on the same wire between the
-        // sync's SEARCH and FETCH, the FETCH lands with no mailbox selected
-        // and Dovecot returns "BAD No mailbox selected" — new mail never
-        // lands locally (Bob 2026-05-25: "not seeing recent mail").
-        // iflow-direct serializes per-command, not per-task, so reusing the
-        // shared client is unsafe across logical transactions. A dedicated
-        // client is the smallest surgical fix.
-        const client = await this.createClientWithLimit(accountId);
-        try {
+        // Run the whole sweep on the dedicated "outbox" lane — its OWN
+        // persistent connection, separate from the slow/sync lane. Two reasons:
+        //  1. Sent-sweep's `SELECT Sent` has been observed taking 90s on this
+        //     server; on the shared slow lane that stalled INBOX sync/backfill
+        //     behind it (the "whole worker goes silent" wedge, Bob 2026-06-20).
+        //  2. withConnection serializes the entire SEARCH→APPEND sweep on one
+        //     connection, so it can't interleave mid-transaction with another
+        //     task's SELECT (the "BAD No mailbox selected" class, Bob
+        //     2026-05-25). Previously this used createClientWithLimit() — which
+        //     actually returned the SHARED slow client and then destroyed it in
+        //     a finally, the opposite of "dedicated".
+        await this.withConnection(accountId, async (client) => {
             for (const row of rows) {
                 const msgId = row.message_id;
                 if (!msgId) continue;
@@ -5185,10 +5185,7 @@ export class ImapManager extends EventEmitter {
                     }
                 }
             }
-        } finally {
-            try { await (client._realLogout || client.logout)(); } catch { /* */ }
-            try { client.destroy?.(); } catch { /* */ }
-        }
+        }, { lane: "outbox", timeoutMs: 120_000 });
         if (reconciled + appended > 0) {
             this.emit("folderCountsChanged", accountId, {});
             console.log(`  [sent-sweep] ${accountId}: ${reconciled} rebound, ${appended} re-appended`);
@@ -5469,13 +5466,13 @@ export class ImapManager extends EventEmitter {
         this.stopPeriodicSync();
         this.stopOutboxWorker();
         await this.stopWatching();
-        // Disconnect persistent connections on both lanes. Use a Set
-        // because fastClients can hold an entry an account doesn't have
-        // in opsClients (e.g. body fetches happened but no sync did).
-        const accountIds = new Set<string>([
-            ...this.opsClients.keys(),
-            ...this.fastClients.keys(),
-        ]);
+        // Disconnect persistent connections on every lane. Union across all
+        // lane maps because a lane can hold an account the others don't (e.g.
+        // body fetches happened on "fast" but no sync ran on "sync").
+        const accountIds = new Set<string>();
+        for (const map of this.laneClients.values()) {
+            for (const k of map.keys()) accountIds.add(k);
+        }
         for (const accountId of accountIds) {
             await this.disconnectOps(accountId);
         }

package/packages/mailx-imap/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.104",
+  "version": "0.1.105",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bobfrankston/mailx-imap",
-      "version": "0.1.104",
+      "version": "0.1.105",
       "license": "ISC",
       "dependencies": {
         "@bobfrankston/iflow-direct": "^0.1.27",

package/packages/mailx-imap/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.104",
+  "version": "0.1.105",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",