@bobfrankston/mailx 1.0.352 → 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 } 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";
@@ -524,6 +524,7 @@ document.getElementById("btn-factory-reset")?.addEventListener("click", async ()
     }
 });
 async function openCompose(mode) {
+    logClientEvent("openCompose-entry", { mode });
     const current = getCurrentMessage();
     // Local-first: if the row is selected we already have its headers in the
     // local DB. Populate the compose form unconditionally; the user can edit
@@ -1143,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,9 +4,13 @@
  * Receives init data via window.opener.postMessage or URL params.
  */
 import { createEditor } from "./editor.js";
-import { getSettings, getAccounts, searchContacts, sendMessage, saveDraft as apiSaveDraft, deleteDraft } 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 || "?" });
 /** Close compose window */
 function closeCompose() {
+    logClientEvent("compose-close");
     window.close();
 }
 // ── Load editor scripts dynamically ──
@@ -576,6 +580,11 @@ window.addEventListener("blur", () => {
     catch { /* */ }
 });
 document.getElementById("btn-send")?.addEventListener("click", () => {
+    // Loud tracing through the whole send pipeline. Every step ships a
+    // `[client] compose-send-*` event to the Node log so a "vanished message"
+    // report can be traced end-to-end without devtools. If the log stops
+    // at any step, that's where the pipeline broke.
+    logClientEvent("compose-send-click");
     const body = {
         from: getFromAccountId(),
         fromAddress: getFromAddress(),
@@ -587,10 +596,12 @@ document.getElementById("btn-send")?.addEventListener("click", () => {
         bodyText: editor.getText(),
         attachments: attachments.map(a => ({ filename: a.filename, mimeType: a.mimeType, dataBase64: a.dataBase64 })),
     };
+    logClientEvent("compose-send-body-built", { from: body.from, toCount: body.to.length, subjectLen: (body.subject || "").length, bodyHtmlLen: (body.bodyHtml || "").length, atts: body.attachments.length });
     // Local validity (one missing-To check) — must run before close so the
     // user gets an inline error instead of silent loss. Anything else (real
     // address validation, MIME assembly, disk write) happens server-side.
     if (!body.to.length) {
+        logClientEvent("compose-send-rejected-no-to");
         alert("Please add at least one To recipient.");
         return;
     }
@@ -610,25 +621,49 @@ document.getElementById("btn-send")?.addEventListener("click", () => {
     if (statusEl)
         statusEl.textContent = "";
     const sendStart = Date.now();
-    let ipcPromise;
-    try {
-        ipcPromise = sendMessage(body);
-    }
-    catch (e) {
-        const msg = e?.message || String(e);
-        console.error(`[compose] Send threw synchronously: ${msg}`);
-        if (sendBtn) {
-            sendBtn.disabled = false;
-            sendBtn.textContent = "Send";
+    logClientEvent("compose-send-pre-ipc");
+    // 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 });
         console.log(`[compose] Send IPC returned OK in ${Date.now() - sendStart}ms`);
         // Stop autosave only after ACK — if send threw we want the draft
         // autosave to keep the message safe.
@@ -643,6 +678,7 @@ document.getElementById("btn-send")?.addEventListener("click", () => {
     })
         .catch((e) => {
         const msg = e?.message || String(e);
+        logClientEvent("compose-send-ipc-rejected", { error: msg, ms: Date.now() - sendStart });
         console.error(`[compose] Send IPC failed after ${Date.now() - sendStart}ms: ${msg}`);
         if (sendBtn) {
             sendBtn.disabled = false;

package/client/lib/api-client.js

@@ -129,6 +129,34 @@ export function deleteFolder(accountId, folderId) {
 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. 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;
+        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/client/lib/mailxapi.js

@@ -86,6 +86,12 @@
             return callNode("undeleteMessage", { accountId: accountId, uid: uid, folderId: folderId });
         },
 
+        // Diagnostic tracing — callers (compose iframe, app, components) can
+        // ship arbitrary named events to the Node log. Surfaces as
+        // `[client] <tag> <data>` so a failing pipeline can be traced end
+        // to end in a single log file.
+        logClientEvent: function(tag, data) { return callNode("logClientEvent", { tag: tag, data: data }); },
+
         // Compose
         sendMessage: function(msg) { return callNode("sendMessage", msg); },
         saveDraft: function(params) { return callNode("saveDraft", params); },

package/package.json

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

package/packages/mailx-service/jsonrpc.js

@@ -128,6 +128,14 @@ async function dispatchAction(svc, action, p) {
             return { content: await svc.readConfigHelp(p.name) };
         case "unsubscribeOneClick":
             return await svc.unsubscribeOneClick(p.url);
+        // Client-side tracing — lets webview / iframe code ship events to the
+        // Node log so a "compose→send→vanished" report can be diagnosed without
+        // opening devtools. Every call shows up as `[client] <tag> <data>` in
+        // the main log. Keep it on the top of the switch so it's cheap + first
+        // to dispatch.
+        case "logClientEvent":
+            console.log(`  [client] ${p.tag || "?"}${p.data ? " " + JSON.stringify(p.data).slice(0, 400) : ""}`);
+            return { ok: true };
         // Settings
         case "getSettings":
             return svc.getSettings();