@bobfrankston/rmfmail 1.2.188 → 1.2.191

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

@@ -58,6 +58,15 @@ function vlog(msg: string): void {
     } catch { /* ignore */ }
 }
 
+/** C156: user-visible bootstrap narration. A new-device install looked
+ *  frozen (Bob 2026-07-22) because the stage breadcrumbs only went to vlog.
+ *  This logs (console capture shows it pre-UI) AND emits a bootstrapStatus
+ *  event the client renders in the status bar + folder-tree loading slot. */
+function narrate(msg: string): void {
+    console.log(`[android] ${msg}`);
+    emitEvent({ type: "bootstrapStatus", message: msg });
+}
+
 // ── Sync Manager ──
 
 /** Race a promise against a wall-clock timeout. On timeout it REJECTS so the
@@ -1024,61 +1033,81 @@ async function refreshAccessToken(refreshToken: string): Promise<{ access_token:
 // ── Token provider (browser OAuth, same as desktop) ──
 
 function createNativeTokenProvider(email: string): () => Promise<string> {
-    return async () => {
-        // Check cached token first
-        const cached = await getCachedToken(email);
-        if (cached?.access_token) {
-            const expiresAt = cached.expires_at || 0;
-            const bufferMs = 5 * 60 * 1000; // 5 min buffer
-            if (Date.now() < expiresAt - bufferMs) {
-                return cached.access_token;
-            }
-            // Try refresh
-            if (cached.refresh_token) {
-                try {
-                    console.log(`[oauth] Refreshing token for ${email}`);
-                    const refreshed = await refreshAccessToken(cached.refresh_token);
-                    const token = {
-                        access_token: refreshed.access_token,
-                        refresh_token: cached.refresh_token,
-                        expires_at: Date.now() + refreshed.expires_in * 1000,
-                    };
-                    await setCachedToken(email, token);
-                    return token.access_token;
-                } catch (e: any) {
-                    console.warn(`[oauth] Refresh failed: ${e.message}, starting new flow`);
-                }
+    return () => {
+        // C158: single-flight per email. Startup fires several concurrent
+        // token requests (GDrive reconcile, contacts sync, syncAll) — with
+        // no cached token each one launched its OWN browser-consent intent
+        // (three "Starting OAuth flow" in one boot, 2026-07-22 logit trail).
+        // Concurrent callers now share one resolution. Keyed on a window
+        // global, not a module local, because the double-init bug that
+        // exposed this also loads the module twice — two module instances
+        // must still share the guard.
+        const w = window as any;
+        const inflight: Map<string, Promise<string>> = w.__rmfOAuthInflight ||= new Map();
+        const key = canonEmail(email);
+        const existing = inflight.get(key);
+        if (existing) return existing;
+        const p = fetchTokenForEmail(email).finally(() => inflight.delete(key));
+        inflight.set(key, p);
+        return p;
+    };
+}
+
+async function fetchTokenForEmail(email: string): Promise<string> {
+    // Check cached token first
+    const cached = await getCachedToken(email);
+    if (cached?.access_token) {
+        const expiresAt = cached.expires_at || 0;
+        const bufferMs = 5 * 60 * 1000; // 5 min buffer
+        if (Date.now() < expiresAt - bufferMs) {
+            return cached.access_token;
+        }
+        // Try refresh
+        if (cached.refresh_token) {
+            try {
+                console.log(`[oauth] Refreshing token for ${email}`);
+                const refreshed = await refreshAccessToken(cached.refresh_token);
+                const token = {
+                    access_token: refreshed.access_token,
+                    refresh_token: cached.refresh_token,
+                    expires_at: Date.now() + refreshed.expires_in * 1000,
+                };
+                await setCachedToken(email, token);
+                return token.access_token;
+            } catch (e: any) {
+                console.warn(`[oauth] Refresh failed: ${e.message}, starting new flow`);
             }
         }
+    }
 
-        // No valid token — start browser OAuth flow
-        const bridge = (window as any)._nativeBridge;
-        if (!bridge?.app?.startOAuth) {
-            throw new Error("No native OAuth bridge");
-        }
+    // No valid token — start browser OAuth flow
+    const bridge = (window as any)._nativeBridge;
+    if (!bridge?.app?.startOAuth) {
+        throw new Error("No native OAuth bridge");
+    }
 
-        const authUrl = `${OAUTH_CLIENT.authUri}?` + new URLSearchParams({
-            client_id: OAUTH_CLIENT.clientId,
-            redirect_uri: OAUTH_CLIENT.redirectUri,
-            response_type: "code",
-            scope: OAUTH_SCOPES,
-            access_type: "offline",
-            prompt: "consent",
-            login_hint: email,
-        }).toString();
-
-        console.log(`[oauth] Starting browser consent for ${email}`);
-        const code = await bridge.app.startOAuth(authUrl);
-        const tokens = await exchangeCodeForTokens(code);
-        const token = {
-            access_token: tokens.access_token,
-            refresh_token: tokens.refresh_token,
-            expires_at: Date.now() + tokens.expires_in * 1000,
-        };
-        await setCachedToken(email, token);
-        console.log(`[oauth] Token obtained for ${email}`);
-        return token.access_token;
+    const authUrl = `${OAUTH_CLIENT.authUri}?` + new URLSearchParams({
+        client_id: OAUTH_CLIENT.clientId,
+        redirect_uri: OAUTH_CLIENT.redirectUri,
+        response_type: "code",
+        scope: OAUTH_SCOPES,
+        access_type: "offline",
+        prompt: "consent",
+        login_hint: email,
+    }).toString();
+
+    console.log(`[oauth] Starting browser consent for ${email}`);
+    narrate(`Signing into ${email}…`);
+    const code = await bridge.app.startOAuth(authUrl);
+    const tokens = await exchangeCodeForTokens(code);
+    const token = {
+        access_token: tokens.access_token,
+        refresh_token: tokens.refresh_token,
+        expires_at: Date.now() + tokens.expires_in * 1000,
     };
+    await setCachedToken(email, token);
+    console.log(`[oauth] Token obtained for ${email}`);
+    return token.access_token;
 }
 
 // ── GDrive folder lookup ──
@@ -1339,7 +1368,23 @@ async function waitForNativeBridge(timeoutMs: number = 5000): Promise<void> {
     });
 }
 
-export async function initAndroid(): Promise<void> {
+export function initAndroid(): Promise<void> {
+    // C158: idempotency guard. The 2026-07-22 fold/unfold logit trail showed
+    // ONE WebView reload executing the boot module TWICE — duplicate "bridge
+    // installed", duplicate GDrive lookups, tripled OAuth launches. The
+    // guard lives on window (not a module local) so it holds even when the
+    // module itself is instantiated twice (bundle + package-path specifiers
+    // resolve to distinct module instances).
+    const w = window as any;
+    if (w.__rmfInitAndroid) {
+        console.warn("[android] initAndroid called again — duplicate suppressed (C158)");
+        vlog("C158: duplicate initAndroid call suppressed");
+        return w.__rmfInitAndroid;
+    }
+    return w.__rmfInitAndroid = initAndroidOnce();
+}
+
+async function initAndroidOnce(): Promise<void> {
     console.log("[android] Initializing mailx (main-thread mode)...");
 
     // Main-thread path: async I/O (fetch, TCP bridge) doesn't block the UI,
@@ -1410,7 +1455,7 @@ export async function initAndroid(): Promise<void> {
         reconcileTry++;
         setGDriveTokenProvider(tp);
         try {
-            console.log(`[android] Looking up GDrive .rmfmail folder… (try ${reconcileTry}/${RECONCILE_MAX_TRIES})`);
+            narrate(`Fetching settings from Google Drive… (try ${reconcileTry})`);
             vlog(`gdrive-reconcile try ${reconcileTry}: token fetch`);
             // Watchdog the token fetch — it crosses into native code and has
             // hung on cold boots; without a timeout the whole reconcile just
@@ -1449,7 +1494,7 @@ export async function initAndroid(): Promise<void> {
                     console.warn(`[android] List debug: ${e.message}`);
                 }
                 // Read accounts directly from GDrive (bypass IndexedDB cache)
-                console.log("[android] Reading accounts.jsonc from GDrive...");
+                narrate("Loading accounts from Google Drive…");
                 const gdriveAccounts = await loadAccountsFromCloud();
                 console.log(`[android] GDrive returned ${gdriveAccounts.length} accounts: ${gdriveAccounts.map(a => a.id).join(",")}`);
                 if (gdriveAccounts.length > 0) {
@@ -1468,6 +1513,15 @@ export async function initAndroid(): Promise<void> {
                         await syncManager.addAccount(account);
                     }
                     console.log(`[android] Loaded ${accounts.length} accounts from GDrive`);
+                    // C157: sync NOW. The boot-time syncAll ran before these
+                    // providers existed (fresh install: zero local accounts),
+                    // so without this kick the folder tree stayed empty until
+                    // the next 60 s poll tick — on top of OAuth consent time,
+                    // that read as "frozen for minutes". syncAll's inbox
+                    // phase lists folders first, so the tree paints in
+                    // seconds; message counts stream in behind.
+                    narrate(`Syncing ${accounts.length} account(s)…`);
+                    syncManager.syncAll().catch(e => console.error(`[android] post-reconcile sync: ${e.message}`));
                 }
                 // Register this Android device in clients.jsonc
                 await registerDeviceInGDrive(tp, folderId, accounts.map(a => a.id));
@@ -1755,6 +1809,10 @@ function installBridge(): void {
                 await syncManager.addAccount(account);
                 db.upsertAccount(account.id, account.name, account.email, JSON.stringify(account));
                 console.log(`[android] Account added: ${email}`);
+                // C157: the "Syncing..." message below was aspirational — no
+                // sync was actually kicked, so the new account showed nothing
+                // until the next 60 s poll tick.
+                syncManager.syncAll().catch(e => console.error(`[android] post-setup sync: ${e.message}`));
                 return { ok: true, message: `Added ${email}. Syncing...` };
             } catch (e: any) {
                 return { ok: false, error: e.message };

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

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