@bobfrankston/mailx 1.0.156 → 1.0.158

package/bin/mailx.js

@@ -703,8 +703,9 @@ async function main() {
     imapManager.on("accountError", (accountId, error, hint, isOAuth) => {
         handle.send({ _event: "accountError", type: "accountError", accountId, error, hint, isOAuth });
     });
-    // Wait for WebView2 initialization before starting IMAP (stdin writes during init crash wry)
+    // Wait for WebView2 initialization, then signal readiness
     await new Promise(r => setTimeout(r, 2000));
+    handle.send({ _event: "ready", type: "ready" });
     // Register all accounts (OAuth may open browser for Gmail — event loop stays free for IPC)
     for (const account of settings.accounts) {
         if (!account.enabled)

package/client/app.js

@@ -899,25 +899,8 @@ optAutocomplete?.addEventListener("change", () => {
     }).catch(() => { });
 });
 const isApp = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-// Retry getVersion — first IPC calls may be lost before Rust process is ready
-async function getVersionWithRetry() {
-    // Wait for IPC to be established (first getAccounts succeeds around cbid 3)
-    await new Promise(r => setTimeout(r, 3000));
-    for (let i = 0; i < 5; i++) {
-        try {
-            const result = await Promise.race([
-                getVersion(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 5000))
-            ]);
-            return result;
-        }
-        catch {
-            await new Promise(r => setTimeout(r, 2000));
-        }
-    }
-    return { version: "?", storage: {} };
-}
-const versionPromise = getVersionWithRetry();
+// Wait for server ready signal, then fetch version
+const versionPromise = getVersion();
 versionPromise.then((d) => {
     const el = document.getElementById("app-version");
     const storage = d.storage || {};

package/client/components/message-list.js

@@ -102,8 +102,7 @@ export async function loadUnifiedInbox(autoSelect = true) {
         const result = await getUnifiedInbox(1);
         totalMessages = result.total;
         if (result.items.length === 0) {
-            body.innerHTML = `<div class="ml-empty">No messages</div>`;
-            clearViewer();
+            body.innerHTML = `<div class="ml-empty">${result.total > 0 ? `${result.total} messages syncing...` : "Syncing — messages will appear shortly"}</div>`;
             return;
         }
         // Build new rows into a fragment, then swap atomically (no flash)
@@ -187,6 +186,9 @@ export async function loadSearchResults(query, scope = "all", accountId = "", fo
     }
 }
 export async function loadMessages(accountId, folderId, page = 1, specialUse = "", autoSelect = true) {
+    // Clear viewer when navigating to a new folder (not on reloads)
+    if (autoSelect)
+        clearViewer();
     searchMode = false;
     unifiedMode = false;
     showToInsteadOfFrom = ["sent", "drafts", "outbox"].includes(specialUse) ||

package/client/components/message-viewer.js

@@ -19,8 +19,8 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
     const headerEl = document.getElementById("mv-header");
     const bodyEl = document.getElementById("mv-body");
     const attEl = document.getElementById("mv-attachments");
-    bodyEl.innerHTML = `<div class="mv-empty">Loading...</div>`;
-    headerEl.hidden = true;
+    bodyEl.innerHTML = `<div class="mv-empty">Fetching message body...</div>`;
+    // Don't hide the header — keep previous header visible until new one loads
     attEl.hidden = true;
     try {
         const msg = await getMessage(accountId, uid, false, folderId);
@@ -102,7 +102,7 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                         draftFolderId: msg.folderId,
                     };
                     sessionStorage.setItem("composeInit", JSON.stringify(init));
-                    window.open("/compose/compose.html", "_blank", "width=800,height=600,menubar=no,toolbar=no,status=no");
+                    window.open("compose/compose.html", "_blank", "width=800,height=600,menubar=no,toolbar=no,status=no");
                 };
             }
             else {

package/client/lib/mailxapi.js

@@ -12,6 +12,8 @@
     var _callbacks = {};
     var _callbackId = 0;
     var _eventHandlers = [];
+    var _ready = false;
+    var _pendingCalls = []; // buffered until server sends "ready"
 
     function callNode(action, params) {
         var id = String(++_callbackId);
@@ -22,10 +24,14 @@
             }, 120000);
             _callbacks[id] = { resolve: resolve, reject: reject, timer: timer };
             var msg = Object.assign({ _action: action, _cbid: id }, params || {});
+            if (!_ready) {
+                // Buffer until server is ready (early calls are lost in the pipe)
+                _pendingCalls.push(msg);
+                return;
+            }
             if (window.ipc && window.ipc.postMessage) {
                 window.ipc.postMessage(JSON.stringify(msg));
             } else {
-                // Fallback: should not happen in WebView
                 clearTimeout(timer);
                 delete _callbacks[id];
                 reject(new Error("No IPC channel available"));
@@ -33,6 +39,20 @@
         });
     }
 
+    function flushPending() {
+        _ready = true;
+        var pending = _pendingCalls.splice(0);
+        // Send diagnostic so it shows in Node.js IPC log
+        if (window.ipc && window.ipc.postMessage) {
+            window.ipc.postMessage(JSON.stringify({ _action: "_debug", _cbid: "0", info: "flush " + pending.length + " calls: " + pending.map(function(m) { return m._action; }).join(", ") }));
+        }
+        for (var i = 0; i < pending.length; i++) {
+            if (window.ipc && window.ipc.postMessage) {
+                window.ipc.postMessage(JSON.stringify(pending[i]));
+            }
+        }
+    }
+
     // Called by Rust to resolve promises
     window._mailxapiResolve = function(id, value) {
         var cb = _callbacks[id];
@@ -53,6 +73,11 @@
 
     // Called by Rust to push events (new mail, sync progress, etc.)
     window._mailxapiEvent = function(event) {
+        // "ready" signal from server — flush buffered IPC calls
+        if (event && event.type === "ready") {
+            flushPending();
+            return;
+        }
         for (var i = 0; i < _eventHandlers.length; i++) {
             try { _eventHandlers[i](event); } catch(e) { /* ignore */ }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.156",
+  "version": "1.0.158",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,10 +20,10 @@
     "postinstall": "node bin/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.53",
+    "@bobfrankston/iflow": "^1.0.54",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
-    "@bobfrankston/msger": "^0.1.206",
+    "@bobfrankston/msger": "^0.1.208",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",

package/packages/mailx-imap/index.d.ts

@@ -79,6 +79,10 @@ export declare class ImapManager extends EventEmitter {
     /** Sync all folders for all accounts */
     syncAll(): Promise<void>;
     private _syncAll;
+    /** Sync a single account — manages its own connection lifecycle */
+    private syncAccount;
+    /** Kill and recreate the persistent ops connection */
+    private reconnectOps;
     /** Handle sync errors — classify and emit appropriate UI events */
     private handleSyncError;
     /** Sync just INBOX for each account (fast check for new mail) */

package/packages/mailx-imap/index.js

@@ -378,7 +378,10 @@ export class ImapManager extends EventEmitter {
             this.db.upsertFolder(accountId, folder.path, folder.name || folder.path.split(folder.delimiter || "/").pop() || folder.path, specialUse, folder.delimiter || "/");
         }
         this.emit("syncProgress", accountId, "folders", 100);
-        return this.db.getFolders(accountId);
+        // Notify UI that folder structure changed — triggers tree re-render
+        const dbFolders = this.db.getFolders(accountId);
+        this.emit("folderCountsChanged", accountId, {});
+        return dbFolders;
     }
     /** Sync messages for a specific folder */
     async syncFolder(accountId, folderId, client) {
@@ -391,6 +394,7 @@ export class ImapManager extends EventEmitter {
         this.emit("syncProgress", accountId, `sync:${folder.path}`, 0);
         // Get the highest UID we already have for this folder
         const highestUid = this.db.getHighestUid(accountId, folderId);
+        console.log(`  [sync] ${accountId}/${folder.path}: highestUid=${highestUid}, fetching...`);
         let messages;
         const firstSync = highestUid === 0;
         const historyDays = getHistoryDays(accountId);
@@ -595,59 +599,92 @@ export class ImapManager extends EventEmitter {
     }
     async _syncAll() {
         const priorityOrder = ["sent", "drafts", "archive", "junk", "trash"];
-        // Sync each account sequentially — one connection each, reused for all operations
-        for (const [accountId] of this.configs) {
-            try {
-                await this.withConnection(accountId, async (client) => {
-                    // Step 1: Get folder list
-                    const t0 = Date.now();
-                    const folders = await withTimeout(this.syncFolders(accountId, client), 30000, client, "Folder list");
-                    console.log(`  [timing] ${accountId}: folder list ${Date.now() - t0}ms (${folders.length} folders)`);
-                    // Step 2: Sync INBOX first (most important)
-                    const inbox = folders.find(f => f.specialUse === "inbox");
-                    if (inbox) {
-                        try {
-                            await this.syncFolder(accountId, inbox.id, client);
-                        }
-                        catch (e) {
-                            console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
-                        }
+        // Sync all accounts in parallel — each manages its own connection
+        const syncPromises = [...this.configs.keys()].map(accountId => this.syncAccount(accountId, priorityOrder));
+        await Promise.allSettled(syncPromises);
+    }
+    /** Sync a single account — manages its own connection lifecycle */
+    async syncAccount(accountId, priorityOrder) {
+        try {
+            // Step 1: Get folder list (fast — <1s typically)
+            let client = await this.getOpsClient(accountId);
+            const t0 = Date.now();
+            const folders = await this.syncFolders(accountId, client);
+            console.log(`  [timing] ${accountId}: folder list ${Date.now() - t0}ms (${folders.length} folders)`);
+            // Step 2: Sync INBOX first
+            const inbox = folders.find(f => f.specialUse === "inbox");
+            if (inbox) {
+                console.log(`  [sync] ${accountId}: starting INBOX sync (folder ${inbox.id})`);
+                try {
+                    client = await this.getOpsClient(accountId);
+                    console.log(`  [sync] ${accountId}: got client, calling syncFolder for INBOX`);
+                    await this.syncFolder(accountId, inbox.id, client);
+                    console.log(`  [sync] ${accountId}: INBOX sync complete`);
+                }
+                catch (e) {
+                    console.error(`  Inbox sync error for ${accountId}: ${e.message}`);
+                    await this.reconnectOps(accountId);
+                }
+            }
+            else {
+                console.log(`  [sync] ${accountId}: no INBOX folder found`);
+            }
+            // Step 3: Sync remaining folders
+            const remaining = folders.filter(f => f.specialUse !== "inbox");
+            remaining.sort((a, b) => {
+                const pa = priorityOrder.indexOf(a.specialUse || "") >= 0 ? priorityOrder.indexOf(a.specialUse || "") : 5;
+                const pb = priorityOrder.indexOf(b.specialUse || "") >= 0 ? priorityOrder.indexOf(b.specialUse || "") : 5;
+                return pa - pb;
+            });
+            let consecutiveErrors = 0;
+            for (const folder of remaining) {
+                const isTrashChild = folder.path.includes("/") && folder.path.toLowerCase().startsWith("trash");
+                const highestUid = this.db.getHighestUid(accountId, folder.id);
+                if (isTrashChild && highestUid === 0)
+                    continue;
+                try {
+                    client = await this.getOpsClient(accountId);
+                    await this.syncFolder(accountId, folder.id, client);
+                    consecutiveErrors = 0;
+                }
+                catch (e) {
+                    consecutiveErrors++;
+                    if (e.responseText?.includes("doesn't exist")) {
+                        this.db.deleteFolder(folder.id);
                     }
-                    // Step 3: Sync remaining folders in priority order
-                    const remaining = folders.filter(f => f.specialUse !== "inbox");
-                    remaining.sort((a, b) => {
-                        const pa = priorityOrder.indexOf(a.specialUse || "") >= 0 ? priorityOrder.indexOf(a.specialUse || "") : 5;
-                        const pb = priorityOrder.indexOf(b.specialUse || "") >= 0 ? priorityOrder.indexOf(b.specialUse || "") : 5;
-                        return pa - pb;
-                    });
-                    for (const folder of remaining) {
-                        const isTrashChild = folder.path.includes("/") && folder.path.toLowerCase().startsWith("trash");
-                        const highestUid = this.db.getHighestUid(accountId, folder.id);
-                        if (isTrashChild && highestUid === 0)
-                            continue; // defer trash subfolders on first sync
-                        try {
-                            await this.syncFolder(accountId, folder.id, client);
-                        }
-                        catch (e) {
-                            if (e.responseText?.includes("doesn't exist")) {
-                                this.db.deleteFolder(folder.id);
-                            }
-                            else {
-                                console.error(`  Skipping folder ${folder.path}: ${e.message}`);
-                            }
-                        }
+                    else {
+                        console.error(`  Skipping ${folder.path}: ${e.message}`);
+                        // Connection is probably dead — reconnect
+                        await this.reconnectOps(accountId);
                     }
-                });
-                this.accountErrorShown.delete(accountId);
-                this.emit("syncComplete", accountId);
+                    // Too many consecutive errors = connection fundamentally broken
+                    if (consecutiveErrors >= 3) {
+                        console.error(`  [sync] ${accountId}: ${consecutiveErrors} consecutive errors — aborting sync`);
+                        break;
+                    }
+                }
             }
-            catch (e) {
-                const errMsg = imapError(e);
-                this.emit("syncError", accountId, errMsg);
-                console.error(`Sync error for ${accountId}: ${errMsg}`);
-                this.handleSyncError(accountId, errMsg);
+            this.accountErrorShown.delete(accountId);
+            this.emit("syncComplete", accountId);
+        }
+        catch (e) {
+            const errMsg = imapError(e);
+            this.emit("syncError", accountId, errMsg);
+            console.error(`Sync error for ${accountId}: ${errMsg}`);
+            this.handleSyncError(accountId, errMsg);
+        }
+    }
+    /** Kill and recreate the persistent ops connection */
+    async reconnectOps(accountId) {
+        const old = this.opsClients.get(accountId);
+        this.opsClients.delete(accountId);
+        if (old) {
+            try {
+                await (old._realLogout || old.logout)();
             }
+            catch { /* */ }
         }
+        console.log(`  [conn] ${accountId}: reconnecting`);
     }
     /** Handle sync errors — classify and emit appropriate UI events */
     handleSyncError(accountId, errMsg) {
@@ -848,19 +885,28 @@ export class ImapManager extends EventEmitter {
             if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
                 return this.bodyStore.getMessage(accountId, folderId, uid);
             }
+            // Body fetch uses a fresh connection — never waits behind background sync
+            let client = null;
             try {
-                return await this.withConnection(accountId, async (client) => {
-                    const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
-                    if (!msg?.source)
-                        return null;
-                    const raw = Buffer.from(msg.source, "utf-8");
-                    const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
-                    this.db.updateBodyPath(accountId, uid, bodyPath);
-                    return raw;
-                });
+                client = this.newClient(accountId);
+                const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
+                await client.logout();
+                client = null;
+                if (!msg?.source)
+                    return null;
+                const raw = Buffer.from(msg.source, "utf-8");
+                const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
+                this.db.updateBodyPath(accountId, uid, bodyPath);
+                return raw;
             }
             catch (e) {
                 console.error(`  Body fetch error (${accountId}/${uid}): ${e.message}`);
+                if (client) {
+                    try {
+                        await client.logout();
+                    }
+                    catch { /* */ }
+                }
                 return null;
             }
         });