@bobfrankston/rmfmail 1.1.162 → 1.1.166

package/packages/mailx-imap/index.ts

@@ -2446,6 +2446,26 @@ export class ImapManager extends EventEmitter {
             console.log(`  [periodic] ${accountId}: STATUS check every ${interval / 1000}s (${isGmail ? "API" : "IMAP+IDLE"})`);
         }
 
+        // DEADMAN: IDLE silently dropped on 2026-05-27 at 10:07 (empty
+        // error message swallowed the cause) and 90 minutes of new mail
+        // went undelivered until manual reload. Every 60s, check that an
+        // IDLE watcher exists for every IMAP-path account; if not, kick
+        // startWatching() to re-establish. startWatching itself is
+        // idempotent (the `watchers.has(accountId) continue` guard means
+        // accounts with healthy IDLE are skipped). One log line per
+        // detected gap so a chronically failing account is obvious in
+        // the log.
+        const deadmanInterval = setInterval(() => {
+            for (const [accountId] of this.configs) {
+                if (this.isGmailAccount(accountId)) continue; // Gmail = API, no IDLE
+                if (this.watchers.has(accountId)) continue;
+                console.log(`  [idle-deadman] ${accountId}: no IDLE watcher — attempting restart`);
+                this.startWatching().catch(e =>
+                    console.error(`  [idle-deadman] ${accountId} restart failed: ${e?.message || e}`));
+            }
+        }, 60_000);
+        this.syncIntervals.set("idle-deadman", deadmanInterval);
+
         // Sync actions (sends + flags/deletes/moves) every 30 seconds — skip during active sync
         const actionsInterval = setInterval(async () => {
             if (this.syncing) return;
@@ -2572,7 +2592,20 @@ export class ImapManager extends EventEmitter {
                 });
                 console.log(`  [idle] Watching INBOX for ${accountId}${useNotify ? " (+NOTIFY personal mailboxes)" : ""}`);
             } catch (e: any) {
-                console.error(`  [idle] Failed to watch ${accountId}: ${e.message}`);
+                // Defensive: same empty-message bug class as the transport
+                // path. `Failed to watch bobma: ` with nothing after the
+                // colon hid 86 minutes of IDLE outage on 2026-05-27 — new
+                // messages arrived in Thunderbird but mailx never noticed
+                // because IDLE silently died and the log gave no clue why.
+                const parts: string[] = [];
+                if (e?.message) parts.push(String(e.message));
+                if (e?.code) parts.push(`code=${e.code}`);
+                if (e?.errno !== undefined) parts.push(`errno=${e.errno}`);
+                if (e?.syscall) parts.push(`syscall=${e.syscall}`);
+                const desc = parts.length > 0
+                    ? parts.join(" ")
+                    : `<no message> ${typeof e} ${e?.constructor?.name || ""}`.trim();
+                console.error(`  [idle] Failed to watch ${accountId}: ${desc}`);
             }
         }
     }
@@ -2676,7 +2709,7 @@ export class ImapManager extends EventEmitter {
         }
         const envelope: any = this.db.getMessageByUid(accountId, uid, folderId);
         let storedPath = envelope?.bodyPath || "";
-        if (!storedPath) storedPath = this.db.getMessageBodyPath(accountId, uid) || "";
+        if (!storedPath) storedPath = this.db.getMessageBodyPath(accountId, uid, folderId) || "";
         if (storedPath && await this.bodyStore.hasByPath(storedPath)) {
             return this.bodyStore.readByPath(storedPath);
         }
@@ -3046,7 +3079,18 @@ export class ImapManager extends EventEmitter {
                             batchSucceeded = true;
                             this.clearFolderErrors(accountId, folder.path);
                         } catch (e: any) {
-                            const msg = String(e?.message || "");
+                            // Build a description that never collapses to "".
+                            // Even with the iflow transport fix below, defense
+                            // in depth: some error paths produce objects whose
+                            // .message is empty, or pass non-Error values.
+                            const parts: string[] = [];
+                            if (e?.message) parts.push(String(e.message));
+                            if (e?.code) parts.push(`code=${e.code}`);
+                            if (e?.errno !== undefined) parts.push(`errno=${e.errno}`);
+                            if (e?.syscall) parts.push(`syscall=${e.syscall}`);
+                            const msg = parts.length > 0
+                                ? parts.join(" ")
+                                : `<no message> ${typeof e} ${e?.constructor?.name || ""}`.trim();
                             console.error(`  [prefetch] ${accountId} folder ${folder.path} chunk ${chunkStart / PREFETCH_CHUNK_SIZE}: batch fetch failed: ${msg}`);
                             counters.errors++;
                             this.recordFolderError(accountId, folder.path);
@@ -4184,7 +4228,17 @@ export class ImapManager extends EventEmitter {
                         await client.addFlags(outboxFolder.path, uid, ["$Failed"]);
                     }, { slow: true });
                 } catch { /* best-effort */ }
-                this.emit("accountError", accountId, `Send failed: ${errMsg}`, "Message kept in Outbox", false);
+                // Suppress the banner for transient network errors. ETIMEDOUT
+                // on a Dovecot send is the server being slow / a TCP idle
+                // drop, NOT a user-actionable failure — the next outbox tick
+                // retries with exponential backoff. Surfacing it as a sticky
+                // "Send failed: ETIMEDOUT" banner trains the user to ignore
+                // banners (Bob 2026-05-26 "timeout??"). handleSyncError uses
+                // the same classifier; keep the two paths in sync.
+                const isTransient = /timeout|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|Too many|socket hang up|EPIPE|write after end/i.test(errMsg);
+                if (!isTransient) {
+                    this.emit("accountError", accountId, `Send failed: ${errMsg}`, "Message kept in Outbox", false);
+                }
                 if (/auth|login|credential|invalid/i.test(errMsg)) {
                     this.outboxBackoff.set(accountId, Date.now() + 3600000); // 1 hour
                     console.error(`  [outbox] Auth failure for ${accountId} — outbox paused for 1 hour`);

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

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

package/packages/mailx-service/index.js

@@ -2549,7 +2549,7 @@ export class MailxService {
         // re-fetch here would be wasted IMAP work and risks racing.
         const bodyStore = this.imapManager.getBodyStore();
         let raw = null;
-        const storedPath = envelope.bodyPath || this.db.getMessageBodyPath(accountId, uid) || "";
+        const storedPath = envelope.bodyPath || this.db.getMessageBodyPath(accountId, uid, folderId ?? envelope.folderId) || "";
         if (storedPath && await bodyStore.hasByPath(storedPath)) {
             try {
                 raw = await bodyStore.readByPath(storedPath);