@bobfrankston/mailx 1.0.353 → 1.0.355

package/client/app.js

@@ -5,7 +5,7 @@
 import { initFolderTree, refreshFolderTree, updateFolderCounts, setFolderSynced, getFolderSynced } from "./components/folder-tree.js";
 import { initMessageList, loadMessages, loadUnifiedInbox, loadSearchResults, reloadCurrentFolder, getSelectedMessages, markBodiesCached } from "./components/message-list.js";
 import { showMessage, getCurrentMessage, initViewer } from "./components/message-viewer.js";
-import { connectWebSocket, onWsEvent, triggerSync, syncAccount, reauthenticate, getAccounts, getFolders, deleteMessages, undeleteMessage, restartServer, getSyncPending, getVersion, getSettings, saveSettings, getAutocompleteSettings, saveAutocompleteSettings, repairAccounts, updateFlags, markAsSpamMessages, logClientEvent } from "./lib/api-client.js";
+import { connectWebSocket, onWsEvent, triggerSync, syncAccount, reauthenticate, getAccounts, getFolders, deleteMessages, undeleteMessage, restartServer, getSyncPending, getVersion, getSettings, saveSettings, getAutocompleteSettings, saveAutocompleteSettings, repairAccounts, updateFlags, markAsSpamMessages, logClientEvent, sendMessage as apiSendMessage } from "./lib/api-client.js";
 import * as messageState from "./lib/message-state.js";
 // ── New message badge (favicon + title) ──
 let baseTitle = "mailx";
@@ -1144,6 +1144,40 @@ if (ftFilterInput) {
 }
 // ── Open links from email body in system browser ──
 window.addEventListener("message", (e) => {
+    // Relay traces from iframes (compose) to Node via our working bridge.
+    // The iframe calls logClientEvent which tries its own bridge first; if
+    // that path is broken it also posts here as backup. Tag gets a `via-relay`
+    // suffix when the iframe couldn't reach its own bridge — that alone
+    // diagnoses whether the iframe bridge works.
+    if (e.data?.type === "mailx-trace" && typeof e.data.tag === "string") {
+        const relayTag = e.data.bridged ? e.data.tag : `${e.data.tag} (via-relay)`;
+        logClientEvent(relayTag, e.data.data);
+        return;
+    }
+    // Compose-send relay: iframe posts the send request here because its own
+    // bridge call to sendMessage was failing to reach Node. This window's
+    // bridge is proven (getAccounts / getOutboxStatus run every few seconds
+    // with no failures), so we do the IPC from here and post the result back
+    // to the iframe via its source. `e.source` is the iframe's window; use it
+    // so targeting works even if the iframe moves in the DOM.
+    if (e.data?.type === "mailx-compose-send" && e.data.id && e.data.body) {
+        const src = e.source;
+        const id = e.data.id;
+        logClientEvent("relay-compose-send-received", { id });
+        (async () => {
+            try {
+                await apiSendMessage(e.data.body);
+                logClientEvent("relay-compose-send-ok", { id });
+                src?.postMessage({ type: "mailx-compose-send-result", id, ok: true }, "*");
+            }
+            catch (err) {
+                const msg = err?.message || String(err);
+                logClientEvent("relay-compose-send-error", { id, error: msg });
+                src?.postMessage({ type: "mailx-compose-send-result", id, ok: false, error: msg }, "*");
+            }
+        })();
+        return;
+    }
     if (e.data?.type === "openLink" && e.data.url) {
         window.open(e.data.url, "_blank", "noopener,noreferrer");
     }

package/client/compose/compose.css

@@ -75,6 +75,14 @@ body {
     padding: var(--gap-xs) 0;
 }
 
+/* HTML `hidden` attribute is display:none by UA default, but the `display:
+   flex` above wins specificity-wise and the row stays visible. Restore the
+   expected hide behavior — the Cc/Bcc toggle buttons flip `hidden` to
+   reveal/conceal the rows, which is pointless if CSS forces them on. */
+.compose-field[hidden] {
+    display: none;
+}
+
 .compose-field label {
     flex: 0 0 60px;
     font-size: var(--font-size-sm);

package/client/compose/compose.js

@@ -4,7 +4,7 @@
  * Receives init data via window.opener.postMessage or URL params.
  */
 import { createEditor } from "./editor.js";
-import { getSettings, getAccounts, searchContacts, sendMessage, saveDraft as apiSaveDraft, deleteDraft, logClientEvent } from "../lib/api-client.js";
+import { getSettings, getAccounts, searchContacts, saveDraft as apiSaveDraft, deleteDraft, logClientEvent } from "../lib/api-client.js";
 // Very first line the iframe runs — if this doesn't reach Node, the iframe
 // itself isn't loading or the bridge is completely broken.
 logClientEvent("compose-module-loaded", { href: location.href, version: window.mailxVersion || "?" });
@@ -621,26 +621,46 @@ document.getElementById("btn-send")?.addEventListener("click", () => {
     if (statusEl)
         statusEl.textContent = "";
     const sendStart = Date.now();
-    let ipcPromise;
     logClientEvent("compose-send-pre-ipc");
-    try {
-        ipcPromise = sendMessage(body);
-        logClientEvent("compose-send-ipc-invoked", { promiseType: typeof ipcPromise, isThenable: !!(ipcPromise && typeof ipcPromise.then === "function") });
-    }
-    catch (e) {
-        const msg = e?.message || String(e);
-        logClientEvent("compose-send-sync-throw", { error: msg });
-        console.error(`[compose] Send threw synchronously: ${msg}`);
-        if (sendBtn) {
-            sendBtn.disabled = false;
-            sendBtn.textContent = "Send";
+    // Parent-window relay for send. Empirical observation: Android (direct
+    // in-process SMTP) sends reliably; desktop (iframe → parent.mailxapi →
+    // msger → Node → service) has sendMessage IPCs failing to reach Node
+    // for reasons still unknown (iframe bridge behaves differently from the
+    // top frame in msger's WebView2 for this specific call). Meanwhile the
+    // parent window's bridge is proven — getAccounts / getOutboxStatus run
+    // through it every few seconds with no failures.
+    //
+    // Fix: the iframe doesn't touch the bridge at all for send. It posts
+    // a request to the parent, and the parent calls the real sendMessage
+    // from its own frame. Parent posts the result back. This bypasses
+    // whatever is wrong with iframe-scoped IPC.
+    const ipcPromise = new Promise((resolve, reject) => {
+        const reqId = `send-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const timer = setTimeout(() => {
+            window.removeEventListener("message", onMsg);
+            reject(new Error("parent-relay send timeout (120s)"));
+        }, 120000);
+        const onMsg = (ev) => {
+            if (!ev.data || ev.data.type !== "mailx-compose-send-result" || ev.data.id !== reqId)
+                return;
+            clearTimeout(timer);
+            window.removeEventListener("message", onMsg);
+            if (ev.data.ok)
+                resolve();
+            else
+                reject(new Error(ev.data.error || "unknown"));
+        };
+        window.addEventListener("message", onMsg);
+        try {
+            parent.postMessage({ type: "mailx-compose-send", id: reqId, body }, "*");
+            logClientEvent("compose-send-ipc-invoked", { via: "parent-relay", reqId });
         }
-        if (statusEl)
-            statusEl.textContent = `Send failed: ${msg}`;
-        else
-            alert(`Send failed: ${msg}`);
-        return;
-    }
+        catch (e) {
+            clearTimeout(timer);
+            window.removeEventListener("message", onMsg);
+            reject(e);
+        }
+    });
     Promise.resolve(ipcPromise)
         .then(() => {
         logClientEvent("compose-send-ipc-resolved", { ms: Date.now() - sendStart });

package/client/lib/api-client.js

@@ -130,18 +130,32 @@ export function emptyFolder(accountId, folderId) {
     return ipc().emptyFolder?.(accountId, folderId);
 }
 /** Ship a named event to the Node log as `[client] <tag> <data>`. Fire and
- *  forget — never awaits, never throws, never blocks the caller. If the IPC
- *  bridge is unavailable, the call is a no-op so tracing calls scattered
- *  through the UI don't become failure points themselves. */
+ *  forget — never awaits, never throws, never blocks the caller. Tries two
+ *  paths so a broken primary channel can't swallow the trace:
+ *    1. Direct bridge call (self / opener / parent mailxapi).
+ *    2. parent.postMessage fallback — the main window listens and relays.
+ *  The fallback matters because the whole point of tracing is to diagnose
+ *  a broken iframe bridge; a single-path tracer that goes through that same
+ *  bridge is useless in exactly the case we need it. */
 export function logClientEvent(tag, data) {
+    let delivered = false;
     try {
         const bridge = typeof globalThis.mailxapi !== "undefined" && globalThis.mailxapi?.isApp ? globalThis.mailxapi
             : window.opener?.mailxapi?.isApp ? window.opener.mailxapi
                 : window.parent?.mailxapi?.isApp ? window.parent.mailxapi
                     : null;
-        bridge?.logClientEvent?.(tag, data);
+        if (bridge?.logClientEvent) {
+            bridge.logClientEvent(tag, data);
+            delivered = true;
+        }
     }
     catch { /* never throw from tracing */ }
+    try {
+        if (window.parent && window.parent !== window) {
+            window.parent.postMessage({ type: "mailx-trace", tag, data, bridged: delivered }, "*");
+        }
+    }
+    catch { /* */ }
 }
 export function sendMessage(body) {
     return ipc().sendMessage?.(body);

package/package.json

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