@bobfrankston/rmfmail 1.2.296 → 1.2.297

package/packages/mailx-imap/index.ts

@@ -843,7 +843,7 @@ export class ImapManager extends EventEmitter {
     async withConnection<T>(
         accountId: string,
         fn: (client: any) => Promise<T>,
-        opts: { slow?: boolean; lane?: string; timeoutMs?: number } = {},
+        opts: { slow?: boolean; lane?: string; timeoutMs?: number; priority?: boolean } = {},
     ): Promise<T> {
         const lane: string = opts.lane ?? (opts.slow ? "slow" : "fast");
         let perAccount = this.laneQueues.get(accountId);
@@ -886,7 +886,17 @@ export class ImapManager extends EventEmitter {
                     reject(e);
                 }
             };
-            queue!.tasks.push(task);
+            // A task the user is waiting on goes to the FRONT of its lane.
+            // Lanes are strictly sequential, so without this a click-time body
+            // fetch sits behind whatever background work was queued first and
+            // can only start after all of it — Bob 2026-08-29: "if I look at a
+            // letter while sync things get confused … viewing the body should
+            // get priority instead of waiting for sync". It cannot preempt the
+            // command already in flight (an IMAP command cannot be cancelled
+            // without dropping the connection), but it no longer waits for the
+            // whole backlog.
+            if (opts.priority) queue!.tasks.unshift(task);
+            else queue!.tasks.push(task);
             this.drainOpsQueue(accountId);
         });
     }
@@ -3743,13 +3753,20 @@ export class ImapManager extends EventEmitter {
         // IMAP: fast lane on the ops queue. One try; if the socket is stale,
         // withConnection's discard-on-error logic drops the client so the
         // next attempt (caller-driven retry) gets a fresh one.
+        //
+        // An interactive fetch (`force`) jumps the lane queue and gets a
+        // tighter cap: the reader is staring at a blank pane, and 90 s of
+        // silence followed by a banner is the worst of both. 30 s is long
+        // enough for a big body on a slow server and short enough that a
+        // wedged lane becomes a RETRYABLE timeout while the reader is still
+        // looking at the message.
         try {
             const raw = await this.withConnection(accountId, async (client) => {
                 const msg: any = await client.fetchMessageByUid(folder.path, uid, { source: true });
                 if (!msg) throw makeNotFoundError(accountId, folderId, uid);
                 if (!msg.source) return null;
                 return Buffer.from(msg.source, "utf-8");
-            });
+            }, force ? { priority: true, timeoutMs: 30_000 } : {});
             if (!raw) return null;
             const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
             this.db.updateBodyPath(accountId, folderId, uid, bodyPath);
@@ -3761,8 +3778,18 @@ export class ImapManager extends EventEmitter {
         } catch (e: any) {
             if (e?.isNotFound) throw e;
             console.error(`  Body fetch error (${accountId}/${uid}): ${e?.message || e}`);
-            // Record so the next view / prefetch backs off instead of
-            // re-attempting a hanging fetch and re-congesting the queue.
+            // A lane timeout / dropped socket says nothing about whether this
+            // message HAS a body. Swallowing it into `null` told the caller
+            // "the server has no body for this" — the reconciler classifies
+            // that as non-transient, skips its retry budget, and banners.
+            // That is the "eventually reports an error rather than retrying"
+            // Bob hit (2026-08-29). Rethrow instead, so the reconciler's
+            // transient test sees the word "timeout" and retries with backoff.
+            const transient = /timeout|discarding client|connection|not connected|ECONN|ETIMEDOUT|ENOTFOUND|socket/i
+                .test(String(e?.message || ""));
+            if (transient) throw e;
+            // A genuine "no body here" — arm the backoff so prefetch and the
+            // next view don't re-attempt a fetch the server won't satisfy.
             try { this.markPrefetchEmpty(accountId, folderId, uid); } catch { /* */ }
             return null;
         }

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

@@ -1,12 +1,12 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.169",
+  "version": "0.1.170",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bobfrankston/mailx-imap",
-      "version": "0.1.169",
+      "version": "0.1.170",
       "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.169",
+  "version": "0.1.170",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",