@bobfrankston/rmfmail 1.2.5 → 1.2.6

package/packages/mailx-imap/index.ts

@@ -3401,6 +3401,21 @@ export class ImapManager extends EventEmitter {
                             console.error(`  [prefetch] ${accountId} folder ${folder.path} chunk ${chunkStart / PREFETCH_CHUNK_SIZE}: batch fetch failed: ${msg}`);
                             counters.errors++;
                             this.recordFolderError(accountId, folder.path);
+                            // A dead connection / network outage won't heal
+                            // mid-run — every further chunk just re-fails on the
+                            // same dead socket and burns the error budget (Bob
+                            // 2026-06-13: prefetch "Not connected" thrash on a
+                            // flaky network). Stop this folder's remaining chunks
+                            // NOW; the next reconciler tick reconnects fresh.
+                            // These are transient, so the UIDs are NOT backed off
+                            // (markPrefetchEmpty is per-message poison only) —
+                            // they retry next tick. Genuine per-body errors are
+                            // handled per-UID above and never reach here.
+                            const dead = /not connected|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE|socket|connection (closed|reset|lost)|disconnect/i.test(msg);
+                            if (dead) {
+                                console.log(`  [prefetch] ${accountId}/${folder.path}: connection down — deferring rest to next tick`);
+                                break;
+                            }
                             if (counters.errors >= ERROR_BUDGET) break;
                         }
                         // Prune missing UIDs only when the batch actually

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

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

package/test/service-boot.mjs

@@ -0,0 +1,62 @@
+/** Daemon-boot integration: construct the FULL MailxService with the sync
+ *  proxy + read-worker exactly as bin/mailx.ts does, then verify reads work and
+ *  nothing crashes while the reconciler's timers fire. Catches boot wiring bugs
+ *  the component tests can't (service ↔ proxy ↔ reconciler interplay). */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawnSyncWorker, MailxService } from "../packages/mailx-service/index.js";
+import { MailxDB, Store, FileMessageStore } from "../packages/mailx-store/index.js";
+
+const liveDir = path.join(os.homedir(), ".rmfmail");
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "rmf-boot-"));
+const tmpStore = path.join(tmp, "store");
+fs.mkdirSync(tmpStore, { recursive: true });
+for (const s of ["", "-wal", "-shm"]) {
+    const src = path.join(liveDir, "mailx.db" + s);
+    if (fs.existsSync(src)) try { fs.copyFileSync(src, path.join(tmp, "mailx.db" + s)); } catch {}
+}
+let fail = 0;
+const ok = (m) => console.log("  ✓", m);
+const bad = (m) => { console.error("  ✗", m); fail++; };
+process.on("uncaughtException", (e) => bad(`uncaughtException: ${e.message}`));
+process.on("unhandledRejection", (e) => bad(`unhandledRejection: ${e?.message || e}`));
+
+console.log("\nservice-boot integration test");
+
+// Mirror bin/mailx.ts: store on main, sync worker, MailxService(store, proxy).
+const db = new MailxDB(tmp);
+const store = new Store(db, new FileMessageStore(tmpStore));
+const synced = await spawnSyncWorker({ configDir: tmp, storePath: tmpStore });
+ok("sync worker spawned");
+
+let svc;
+try { svc = new MailxService(store, synced.proxy); ok("MailxService constructed with proxy (no throw)"); }
+catch (e) { bad(`MailxService ctor threw: ${e.message}`); process.exit(1); }
+
+// Give the read-worker a moment to come up, then exercise reads.
+await new Promise(r => setTimeout(r, 400));
+try {
+    const accts = await svc.getAccounts();
+    ok(`getAccounts() → ${accts.length} accounts`);
+} catch (e) { bad(`getAccounts threw: ${e.message}`); }
+try {
+    const inbox = await svc.getUnifiedInbox(1, 20, false);
+    ok(`getUnifiedInbox() → ${inbox.items.length} items / total ${inbox.total}`);
+    if (inbox.items[0] && !inbox.items[0].uuid) bad("envelope missing uuid (highlight regression)");
+} catch (e) { bad(`getUnifiedInbox threw: ${e.message}`); }
+try {
+    const ob = await svc.getOutboxStatus();
+    ok(`getOutboxStatus() (via worker) → total ${ob.total}`);
+} catch (e) { bad(`getOutboxStatus threw: ${e.message}`); }
+
+// Let the reconciler's startup timers fire — this is where a proxy/await
+// mismatch would blow up. Watch for ~6s.
+console.log("  letting reconciler timers run for 6s (watching for crashes)…");
+await new Promise(r => setTimeout(r, 6000));
+ok("survived 6s of reconciler activity without crashing");
+
+await synced.close();
+try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {}
+console.log(`\n${fail ? "RESULT: FAIL" : "RESULT: PASS"}\n`);
+process.exit(fail);

package/test/sync-worker-isolation.mjs

@@ -0,0 +1,71 @@
+/** Sync-worker ISOLATION test: register real accounts over the bus, run a real
+ *  syncAll INSIDE the worker, and prove (a) sync events forward back to main and
+ *  (b) the MAIN event loop stays free the whole time. Network-resilient: a sync
+ *  failure still validates that the worker didn't take main down with it. */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawnSyncWorker } from "../packages/mailx-service/index.js";
+import { MailxDB } from "../packages/mailx-store/index.js";
+import { loadAccountsAsync } from "../packages/mailx-settings/index.js";
+
+const liveDir = path.join(os.homedir(), ".rmfmail");
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "rmf-iso-"));
+const tmpStore = path.join(tmp, "store");
+fs.mkdirSync(tmpStore, { recursive: true });
+for (const s of ["", "-wal", "-shm"]) {
+    const src = path.join(liveDir, "mailx.db" + s);
+    if (fs.existsSync(src)) try { fs.copyFileSync(src, path.join(tmp, "mailx.db" + s)); } catch {}
+}
+new MailxDB(tmp); // main builds schema first
+console.log("\nsync-worker isolation test");
+
+const synced = await spawnSyncWorker({ configDir: tmp, storePath: tmpStore });
+console.log("  ✓ worker spawned");
+
+// Register real accounts over the bus.
+let accounts = [];
+try { accounts = await loadAccountsAsync(); } catch (e) { console.log(`  (loadAccounts failed: ${e.message})`); }
+console.log(`  accounts to register: ${accounts.length}`);
+for (const a of accounts) {
+    try { await synced.proxy.addAccount(a); console.log(`  ✓ addAccount ${a.id} crossed the bus`); }
+    catch (e) { console.log(`  ✗ addAccount ${a.id}: ${e.message}`); }
+}
+
+// Count sync events forwarded worker → main.
+let events = 0;
+const seen = new Set();
+for (const ev of ["syncProgress", "folderSynced", "syncComplete", "folderCountsChanged", "syncError", "accountError"]) {
+    synced.proxy.on(ev, () => { events++; seen.add(ev); });
+}
+
+// Main-loop lag monitor: a 25ms heartbeat. If sync in the worker froze main,
+// this spikes; if the worker is truly isolated, it stays tiny.
+let maxLag = 0, last = Date.now();
+const beat = setInterval(() => { const now = Date.now(); maxLag = Math.max(maxLag, now - last - 25); last = now; }, 25);
+
+// Fire a real syncAll in the worker (cap at 25s so a hung network ends the test).
+const t0 = Date.now();
+console.log("  running syncAll() in the worker (≤25s)…");
+await Promise.race([
+    synced.proxy.syncAll().catch(e => console.log(`  (syncAll returned error — fine, we're testing isolation: ${String(e.message).slice(0, 60)})`)),
+    new Promise(r => setTimeout(r, 25000)),
+]);
+const elapsed = Date.now() - t0;
+clearInterval(beat);
+
+console.log(`\n  syncAll wall time: ${elapsed}ms`);
+console.log(`  sync events forwarded to main: ${events}  (${[...seen].join(", ") || "none"})`);
+console.log(`  MAIN event-loop max lag during sync: ${maxLag}ms`);
+
+let fail = 0;
+if (maxLag < 500) console.log(`  ✓ main loop stayed responsive (maxLag ${maxLag}ms < 500ms) — sync is isolated`);
+else { console.log(`  ✗ main loop lagged ${maxLag}ms — sync is NOT isolated`); fail++; }
+if (accounts.length === 0) console.log("  ⚠ no accounts loaded — event-forwarding not exercised (network/cloud down)");
+else if (events > 0) console.log(`  ✓ real sync events forwarded worker→main`);
+else console.log("  ⚠ no sync events seen (network may be down) — isolation still proven by lag");
+
+await synced.close();
+try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {}
+console.log(`\n${fail ? "RESULT: FAIL" : "RESULT: PASS"}\n`);
+process.exit(fail);