@bobfrankston/rmfmail 1.2.113 → 1.2.115

package/client/app.js

@@ -657,6 +657,69 @@ function scheduleSyncedStamp() {
         }
     }, SYNC_SETTLE_MS);
 }
+// C121: connect-phase ticker. The daemon emits connectProgress per IMAP
+// connection attempt (socket → handshake → done/failed). While any attempt
+// has been in flight longer than CONNECT_SHOW_AFTER_MS, the status bar shows
+// "Connecting to <host> (<phase> <purpose>, 3.2s)" with a live elapsed
+// counter — so a stuck DNS/TLS/greeting/LOGIN is distinguishable at a glance
+// instead of an opaque frozen "Syncing…". Healthy sub-second connects never
+// surface (the delay gate kills the flicker).
+const activeConnects = new Map();
+const CONNECT_SHOW_AFTER_MS = 1500;
+let connectTickTimer = null;
+function handleConnectProgress(event) {
+    const key = `${event.accountId}|${event.purpose}`;
+    if (event.phase === "done" || event.phase === "failed") {
+        activeConnects.delete(key);
+        if (activeConnects.size === 0 && connectTickTimer) {
+            clearInterval(connectTickTimer);
+            connectTickTimer = null;
+            // Leave the bar to the normal sync handlers; stamp settle so a
+            // lingering "Connecting…" flips to Synced when things go quiet.
+            scheduleSyncedStamp();
+        }
+        return;
+    }
+    const existing = activeConnects.get(key);
+    if (existing) {
+        existing.phase = event.phase;
+    }
+    else {
+        activeConnects.set(key, {
+            host: event.host || event.accountId,
+            purpose: event.purpose || "",
+            phase: event.phase,
+            startedAt: Date.now() - (event.elapsedMs || 0),
+        });
+    }
+    if (!connectTickTimer)
+        connectTickTimer = setInterval(renderConnectTick, 100);
+}
+function renderConnectTick() {
+    const el = document.getElementById("status-sync");
+    if (!el || activeConnects.size === 0)
+        return;
+    // Staleness guard: if a done/failed event got lost (daemon restart,
+    // dropped IPC line) an entry would tick forever — expire at 10 min,
+    // well past any transport timeout.
+    const now = Date.now();
+    for (const [k, c] of activeConnects) {
+        if (now - c.startedAt > 600_000)
+            activeConnects.delete(k);
+    }
+    // Show the LONGEST-waiting attempt — that's the one worth staring at.
+    let worst = null;
+    for (const c of activeConnects.values()) {
+        if (!worst || c.startedAt < worst.startedAt)
+            worst = c;
+    }
+    if (!worst)
+        return;
+    const elapsed = Date.now() - worst.startedAt;
+    if (elapsed < CONNECT_SHOW_AFTER_MS)
+        return;
+    el.textContent = `Connecting to ${worst.host} (${worst.phase}${worst.purpose ? " " + worst.purpose : ""}, ${(elapsed / 1000).toFixed(1)}s)`;
+}
 // ── Auto two-line when message list is narrow ──
 const messageList = document.getElementById("message-list");
 if (messageList) {
@@ -3148,6 +3211,9 @@ onWsEvent((event) => {
                 startupStatus.textContent = "Loading accounts...";
             // Don't refresh folder tree on connect — it's already loaded by initFolderTree
             break;
+        case "connectProgress":
+            handleConnectProgress(event);
+            break;
         case "syncProgress": {
             // Aggregate folders phases ("folders:<path>" when starting a folder,
             // "folders-done" between folders) print as a proportion so the user