@bobfrankston/rmfmail 1.2.76 → 1.2.78

package/packages/mailx-store-web/android-bootstrap.ts

@@ -60,6 +60,27 @@ function vlog(msg: string): void {
 
 // ── Sync Manager ──
 
+/** Race a promise against a wall-clock timeout. On timeout it REJECTS so the
+ *  caller's try/catch moves on — the underlying op may keep running in the
+ *  background, but it can no longer STALL the whole sync. Critical on Android:
+ *  an auth-failing IMAP account (outlook/aol) or a slow BridgeTransport
+ *  listFolders/fetch would otherwise hang Phase 1 forever and new mail for the
+ *  healthy accounts never arrived (Bob 2026-06-27). */
+function withTimeout<T>(label: string, ms: number, fn: () => Promise<T>): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done) return;
+            done = true;
+            reject(new Error(`timeout after ${ms}ms: ${label}`));
+        }, ms);
+        fn().then(
+            (v) => { if (!done) { done = true; clearTimeout(timer); resolve(v); } },
+            (e) => { if (!done) { done = true; clearTimeout(timer); reject(e); } },
+        );
+    });
+}
+
 class AndroidSyncManager implements WebSyncManager {
     private providers = new Map<string, MailProvider>();
     private tokenProviders = new Map<string, () => Promise<string>>();
@@ -67,6 +88,19 @@ class AndroidSyncManager implements WebSyncManager {
     // spawning parallel fetch loops that race on IndexedDB and blow through
     // Gmail's per-user quota.
     private prefetchingAccounts = new Set<string>();
+    // Single-flight guard for syncAll. It's triggered from THREE places — boot,
+    // a 60s interval, and every visibilitychange→visible — with no coordination.
+    // On Android everything (incl. wa-sqlite) runs on the main thread, so
+    // overlapping runs stacked up: re-listing folders repeatedly, contending on
+    // the DB, and freezing the event loop ~1s at a time — the sync never
+    // advanced to fetching new mail, so the list stayed stale despite "Synced"
+    // (Bob 2026-06-27). Coalesce concurrent calls to one in-flight run.
+    private syncAllInflight: Promise<void> | null = null;
+    // Separate guard for the Phase-2/3 background pass (other folders + body
+    // prefetch). It runs DETACHED from the inbox guard so a long folder sweep
+    // can't make the 60s poll skip the inbox refresh (new mail must keep
+    // flowing). One background pass at a time — overlapping triggers no-op.
+    private bgSyncInflight: Promise<void> | null = null;
 
     constructor(
         private db: WebMailxDB,
@@ -135,48 +169,81 @@ class AndroidSyncManager implements WebSyncManager {
     }
 
     async syncAll(): Promise<void> {
-        const accounts = this.db.getAccounts();
-        vlog(`syncAll: ${accounts.length} accounts in DB: ${accounts.map(a => a.id).join(",")}`);
+        // The inbox guard covers ONLY Phase 1 (inbox sync). Overlapping triggers
+        // coalesce so they can't thrash the single main thread.
+        if (this.syncAllInflight) {
+            console.log("[sync] inbox sync already in flight — coalescing this trigger");
+            return this.syncAllInflight;
+        }
+        const t0 = Date.now();
+        console.log("[sync] syncAll START (inbox phase)");
+        this.syncAllInflight = this._syncInboxes()
+            .catch((e: any) => { console.error(`[sync] inbox sync error: ${e?.message || e}`); })
+            .finally(() => {
+                console.log(`[sync] inbox phase DONE in ${Date.now() - t0}ms`);
+                this.syncAllInflight = null;
+            });
+        // Phase 2/3 (other folders + body prefetch) run DETACHED, under their own
+        // guard — they must not hold the inbox guard, or a slow folder sweep would
+        // make the next 60s poll skip new inbox mail.
+        this._kickBackgroundSync();
+        return this.syncAllInflight;
+    }
 
-        // Phase 1: Sync INBOX for every account first — user sees new mail fast.
-        for (const account of accounts) {
-            if (!this.providers.has(account.id)) continue;
-            try {
+    /** Phase 1: sync every account's INBOX IN PARALLEL so a slow account (e.g.
+     *  Gmail's metadata fetch, or an auth-failing IMAP account) can't delay new
+     *  mail for the others. Each account is time-boxed; network fetches overlap
+     *  even though JS is single-threaded (the awaits yield). */
+    private async _syncInboxes(): Promise<void> {
+        const accounts = this.db.getAccounts().filter(a => this.providers.has(a.id));
+        vlog(`syncInboxes: ${accounts.length} accounts: ${accounts.map(a => a.id).join(",")}`);
+        await Promise.all(accounts.map(account =>
+            withTimeout(`${account.id} inbox`, 60000, async () => {
                 const folders = await this.syncFolders(account.id);
                 const inbox = folders.find(f => f.specialUse === "inbox");
                 if (inbox) {
+                    console.log(`[sync] ${account.id}: fetching INBOX (folderId=${inbox.id})`);
                     await this.syncFolder(account.id, inbox.id);
+                    console.log(`[sync] ${account.id}: INBOX fetch done`);
                     emitEvent({ type: "syncComplete", accountId: account.id });
                 }
-            } catch (e: any) {
-                console.error(`[sync] ${account.id} inbox: ${e.message}`);
-            }
-        }
+            }).catch((e: any) => console.error(`[sync] ${account.id} inbox: ${e?.message || e}`)),
+        ));
+    }
 
-        // Phase 2: Remaining folders (sent, drafts, trash, then everything else).
+    /** Phase 2 + 3: remaining folders, then body prefetch. Runs in the
+     *  background under its own single-flight guard. */
+    private _kickBackgroundSync(): void {
+        if (this.bgSyncInflight) return;
+        const t0 = Date.now();
+        this.bgSyncInflight = this._syncRemainingAndPrefetch()
+            .catch((e: any) => console.error(`[sync] background sweep error: ${e?.message || e}`))
+            .finally(() => {
+                console.log(`[sync] background sweep DONE in ${Date.now() - t0}ms`);
+                this.bgSyncInflight = null;
+            });
+    }
+
+    private async _syncRemainingAndPrefetch(): Promise<void> {
+        const accounts = this.db.getAccounts().filter(a => this.providers.has(a.id));
+        // Phase 2: remaining folders (per account, per folder time-boxed).
         for (const account of accounts) {
-            if (!this.providers.has(account.id)) continue;
             try {
                 const folders = this.db.getFolders(account.id);
                 const remaining = folders.filter(f => f.specialUse !== "inbox");
                 for (const folder of remaining) {
-                    try { await this.syncFolder(account.id, folder.id); }
+                    try { await withTimeout(`${account.id} ${folder.path}`, 45000, () => this.syncFolder(account.id, folder.id)); }
                     catch (e: any) { console.error(`[sync] Skip ${folder.path}: ${e.message}`); }
                 }
                 this.db.updateLastSync(account.id, Date.now());
                 emitEvent({ type: "syncComplete", accountId: account.id });
             } catch (e: any) {
                 console.error(`[sync] ${account.id}: ${e.message}`);
-                vlog(`syncAll: ${account.id} ERROR: ${e.message}`);
                 emitEvent({ type: "syncError", accountId: account.id, error: e.message });
             }
         }
-
-        // Phase 3: background body prefetch. Fire-and-forget — sync itself is
-        // already done and the UI doesn't wait on this. Per-account guard means
-        // a slow account can't block a fast one.
+        // Phase 3: body prefetch (fire-and-forget per account).
         for (const account of accounts) {
-            if (!this.providers.has(account.id)) continue;
             this.prefetchBodies(account.id).catch(e =>
                 console.error(`[prefetch] ${account.id}: ${e.message}`));
         }

package/packages/mailx-store-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store-web",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",