@bobfrankston/rmfmail 1.1.212 → 1.1.214

package/client/app.ts

@@ -4750,9 +4750,24 @@ optAutomarkDelay?.addEventListener("change", () => {
 declare const mailxapi: { isApp: boolean; platform: string; ensureServer: () => Promise<boolean>; getVersion: () => Promise<any> } | undefined;
 const isApp = typeof mailxapi !== "undefined" && mailxapi?.isApp;
 
-// Wait for server ready signal, then fetch version
-const versionPromise = getVersion();
+// Wait for server ready signal, then fetch version. getVersion is idempotent
+// and trivial; msger occasionally drops the startup IPC (see api-client note),
+// so retry with backoff rather than leaving "(??)" + a "service error" banner
+// up forever for a cosmetic version read (Bob 2026-06-02). A short per-action
+// timeout (mailxapi.js) makes each failed attempt give up in 5s.
+async function getVersionWithRetry(attempts = 5): Promise<any> {
+    for (let i = 0; i < attempts; i++) {
+        try { return await getVersion(); }
+        catch (e) {
+            if (i === attempts - 1) { console.warn("getVersion failed after retries:", e); return {}; }
+            await new Promise(r => setTimeout(r, 1500));
+        }
+    }
+    return {};
+}
+const versionPromise = getVersionWithRetry();
 versionPromise.then((d: any) => {
+    if (!d || !d.version) return;   // all retries dropped — leave the prior text, no scary banner
     const els = document.querySelectorAll<HTMLElement>(".app-version");
     const storage = d.storage || {};
     const storageLabel = storage.provider && storage.provider !== "local"

package/client/lib/mailxapi.js

@@ -53,27 +53,67 @@
         // turned a slow-but-fine search into "mailxapi timeout:
         // searchMessages". Local search stays fast and well under any limit.
         searchMessages: 120000,
+        // getVersion reads package.json — instant. With the startup-race
+        // re-send above (it's in RESENDABLE) a dropped post is re-tried every
+        // 2s, so a 5s ceiling normally allows ~2 re-sends before giving up —
+        // enough to ride out the brief window before the Rust→daemon pipe is
+        // wired. Short ceiling so a genuinely wedged daemon surfaces fast
+        // rather than hanging the version display for 30s.
+        getVersion: 5000,
     };
+    // Actions that are PURE READS and therefore safe to auto-re-send if the
+    // first post is lost. Why a post gets lost: at startup the WebView can
+    // call `window.ipc.postMessage` after `window.ipc` is injected but BEFORE
+    // the Rust host has wired its message handler to the daemon's stdin — the
+    // post is accepted by WebView2 and silently dropped downstream, so no
+    // response ever comes and the callback times out. That's the real cause of
+    // "getVersion got dropped" (Bob 2026-06-03) — a startup race in our own
+    // bridge, not a mysterious msger behavior. Re-sending a read is harmless
+    // (the daemon ignores a duplicate response — _msgapiServiceResolve no-ops
+    // when the callback is already gone). WRITES are NOT listed: re-sending a
+    // send/saveDraft/delete/move/flag could double-apply.
+    var RESENDABLE = {
+        getVersion: 1, getAccounts: 1, getFolders: 1, getUnifiedInbox: 1, getMessages: 1,
+        getSettings: 1, getAutocompleteSettings: 1, getDiagnostics: 1, getOutboxStatus: 1,
+        getSyncPending: 1, getCalendars: 1, getCalendarEvents: 1, getTasks: 1,
+        getPrimaryAccount: 1, getThreadMessages: 1, getPriorityLists: 1
+    };
+    var RESEND_INTERVAL_MS = 2000;
     function callNode(action, params) {
         var id = String(++_callbackId);
+        var msgStr = JSON.stringify(Object.assign({ _action: action, _cbid: id }, params || {}));
         return new Promise(function(resolve, reject) {
-            var timer = setTimeout(function() {
+            function send() {
+                if (window.ipc && window.ipc.postMessage) {
+                    // Trace BEFORE the call so a slow daemon-receive shows up as
+                    // ipc-send + N s before the daemon logs `[ipc] ←`. Skip the
+                    // trace event itself to avoid recursion.
+                    if (action !== "logClientEvent") _traceIpcSend(action, id);
+                    window.ipc.postMessage(msgStr);
+                    return true;
+                }
+                return false;
+            }
+            var entry = { resolve: resolve, reject: reject, timer: null, resend: null };
+            _callbacks[id] = entry;
+            entry.timer = setTimeout(function() {
                 delete _callbacks[id];
+                if (entry.resend) clearInterval(entry.resend);
                 reject(new Error("mailxapi timeout: " + action));
             }, ACTION_TIMEOUT_MS[action] || 30000);
-            _callbacks[id] = { resolve: resolve, reject: reject, timer: timer };
-            var msg = Object.assign({ _action: action, _cbid: id }, params || {});
-            if (window.ipc && window.ipc.postMessage) {
-                // Trace BEFORE the actual call so a slow daemon-receive shows
-                // up as ipc-send wall-clock + N seconds before the daemon
-                // logs `[ipc] ←`. Skip tracing on the trace event itself so
-                // we don't recurse.
-                if (action !== "logClientEvent") _traceIpcSend(action, id);
-                window.ipc.postMessage(JSON.stringify(msg));
-            } else {
-                clearTimeout(timer);
+            var sent = send();
+            if (!sent && !RESENDABLE[action]) {
+                // Channel object not injected yet AND not safe to wait/re-send
+                // (a write) → fail now rather than risk it.
+                clearTimeout(entry.timer);
                 delete _callbacks[id];
                 reject(new Error("No IPC channel available"));
+                return;
+            }
+            // Re-send pure reads until a response lands or the ceiling fires —
+            // heals a startup-race drop (and a not-yet-injected window.ipc).
+            if (RESENDABLE[action]) {
+                entry.resend = setInterval(send, RESEND_INTERVAL_MS);
             }
         });
     }
@@ -84,6 +124,7 @@
         if (!cb) return;
         delete _callbacks[id];
         clearTimeout(cb.timer);
+        if (cb.resend) clearInterval(cb.resend);
         cb.resolve(value);
     };
 
@@ -93,6 +134,7 @@
         if (!cb) return;
         delete _callbacks[id];
         clearTimeout(cb.timer);
+        if (cb.resend) clearInterval(cb.resend);
         cb.reject(new Error(error));
     };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/rmfmail",
-  "version": "1.1.212",
+  "version": "1.1.214",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",