@bobfrankston/rmfmail 1.2.76 → 1.2.78

package/client/android-bootstrap.bundle.js

@@ -9749,6 +9749,32 @@ function vlog(msg) {
   } catch {
   }
 }
+function withTimeout(label, ms, fn) {
+  return new Promise((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);
+        }
+      }
+    );
+  });
+}
 var AndroidSyncManager = class {
   constructor(db2, bodyStore2) {
     this.db = db2;
@@ -9762,6 +9788,19 @@ var AndroidSyncManager = class {
   // spawning parallel fetch loops that race on IndexedDB and blow through
   // Gmail's per-user quota.
   prefetchingAccounts = /* @__PURE__ */ new Set();
+  // 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.
+  syncAllInflight = 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.
+  bgSyncInflight = null;
   on(_event, _handler) {
   }
   emit(event, ...args) {
@@ -9815,29 +9854,60 @@ var AndroidSyncManager = class {
     return this.providers.get(accountId) || null;
   }
   async syncAll() {
-    const accounts = this.db.getAccounts();
-    vlog(`syncAll: ${accounts.length} accounts in DB: ${accounts.map((a) => a.id).join(",")}`);
-    for (const account of accounts) {
-      if (!this.providers.has(account.id)) continue;
-      try {
+    if (this.syncAllInflight) {
+      console.log("[sync] inbox sync already in flight \u2014 coalescing this trigger");
+      return this.syncAllInflight;
+    }
+    const t0 = Date.now();
+    console.log("[sync] syncAll START (inbox phase)");
+    this.syncAllInflight = this._syncInboxes().catch((e) => {
+      console.error(`[sync] inbox sync error: ${e?.message || e}`);
+    }).finally(() => {
+      console.log(`[sync] inbox phase DONE in ${Date.now() - t0}ms`);
+      this.syncAllInflight = null;
+    });
+    this._kickBackgroundSync();
+    return this.syncAllInflight;
+  }
+  /** 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). */
+  async _syncInboxes() {
+    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`, 6e4, 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) {
-        console.error(`[sync] ${account.id} inbox: ${e.message}`);
-      }
-    }
+      }).catch((e) => console.error(`[sync] ${account.id} inbox: ${e?.message || e}`))
+    ));
+  }
+  /** Phase 2 + 3: remaining folders, then body prefetch. Runs in the
+   *  background under its own single-flight guard. */
+  _kickBackgroundSync() {
+    if (this.bgSyncInflight) return;
+    const t0 = Date.now();
+    this.bgSyncInflight = this._syncRemainingAndPrefetch().catch((e) => console.error(`[sync] background sweep error: ${e?.message || e}`)).finally(() => {
+      console.log(`[sync] background sweep DONE in ${Date.now() - t0}ms`);
+      this.bgSyncInflight = null;
+    });
+  }
+  async _syncRemainingAndPrefetch() {
+    const accounts = this.db.getAccounts().filter((a) => this.providers.has(a.id));
     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);
+            await withTimeout(`${account.id} ${folder.path}`, 45e3, () => this.syncFolder(account.id, folder.id));
           } catch (e) {
             console.error(`[sync] Skip ${folder.path}: ${e.message}`);
           }
@@ -9846,12 +9916,10 @@ var AndroidSyncManager = class {
         emitEvent({ type: "syncComplete", accountId: account.id });
       } catch (e) {
         console.error(`[sync] ${account.id}: ${e.message}`);
-        vlog(`syncAll: ${account.id} ERROR: ${e.message}`);
         emitEvent({ type: "syncError", accountId: account.id, error: e.message });
       }
     }
     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}`));
     }
   }