@bobfrankston/mailx 1.0.442 → 1.0.443

package/client/app.js

@@ -696,9 +696,17 @@ async function openCompose(mode) {
     sessionStorage.setItem("composeInit", JSON.stringify(init));
     // Inline compose: load compose.html in an overlay iframe (same origin, same IPC)
     // Popup windows don't work in IPC mode (custom protocol doesn't propagate to child windows)
-    showComposeOverlay();
+    // Title reflects mode + subject so the user can see what they're replying to
+    // ("Re: Stars of STEM 2026" instead of just "Compose"). Forward shows the
+    // forward target subject; new compose stays generic.
+    const titlePrefix = mode === "reply" ? "Reply" :
+        mode === "replyAll" ? "Reply All" :
+            mode === "forward" ? "Forward" :
+                "Compose";
+    const titleSubject = mode === "new" ? "" : (msg?.subject || init.subject || "");
+    showComposeOverlay(titleSubject ? `${titlePrefix}: ${titleSubject}` : titlePrefix);
 }
-function showComposeOverlay() {
+function showComposeOverlay(title = "Compose") {
     const wrapper = document.createElement("div");
     wrapper.className = "compose-overlay";
     // Full-screen on small/short screens, floating on larger
@@ -712,7 +720,7 @@ function showComposeOverlay() {
     // Title bar — drag to move, close button
     const titleBar = document.createElement("div");
     titleBar.style.cssText = "display:flex;align-items:center;justify-content:space-between;padding:4px 8px;background:#e8ecf0;border-radius:8px 8px 0 0;cursor:move;user-select:none;flex-shrink:0;";
-    titleBar.textContent = "Compose";
+    titleBar.textContent = title;
     const closeBtn = document.createElement("button");
     closeBtn.textContent = "✕";
     closeBtn.title = "Save draft and close";

package/client/compose/compose.js

@@ -92,10 +92,59 @@ catch { /* private-mode / SecurityError — default quill */ }
     }
     catch { /* non-fatal */ }
 })();
-await loadEditorAssets(editorType);
+// Whatever happens in editor init, surface failures to the mailx log.
+// Until this round the failures were swallowed silently — Quill CDN
+// timing out or createEditor throwing left the iframe with empty body
+// + dead buttons (because the rest of the script after the await never
+// ran). With logClientEvent here, the failure mode is visible in the
+// service log instead of "Reply just shows blank compose".
+let editor;
+try {
+    await loadEditorAssets(editorType);
+}
+catch (e) {
+    logClientEvent("compose-editor-assets-failed", { type: editorType, error: String(e?.message || e) });
+    throw e;
+}
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
-const editor = await createEditor(container, editorType);
+try {
+    editor = await createEditor(container, editorType);
+}
+catch (e) {
+    logClientEvent("compose-editor-create-failed", { type: editorType, error: String(e?.message || e) });
+    // Render a minimal contenteditable fallback so the user can still type
+    // SOMETHING. Without this, an editor failure leaves the compose form
+    // half-functional (To/Cc/Bcc work, body doesn't) and the user doesn't
+    // know why. The fallback is a plain div — no toolbar, no rich text.
+    container.innerHTML = `<div class="compose-fallback-editor" contenteditable="true" style="border:1px solid #c00;padding:8px;min-height:200px;background:#fff" data-fallback="true"></div>`;
+    const fallback = container.querySelector(".compose-fallback-editor");
+    editor = {
+        root: fallback,
+        setHtml: (html) => { fallback.innerHTML = html; },
+        getHtml: () => fallback.innerHTML,
+        getText: () => fallback.innerText,
+        focus: () => fallback.focus(),
+        setCursor: () => { },
+        getScrollContainer: () => fallback,
+        onContentChange: (handler) => { fallback.addEventListener("input", handler); },
+        onKeyDown: (handler) => { fallback.addEventListener("keydown", handler); },
+        insertTextAtCursor: (text) => {
+            const sel = window.getSelection();
+            if (sel && sel.rangeCount > 0) {
+                const range = sel.getRangeAt(0);
+                range.deleteContents();
+                range.insertNode(document.createTextNode(text));
+            }
+            else {
+                fallback.append(document.createTextNode(text));
+            }
+        },
+    };
+    // Surface the failure to the user in the status bar so they know
+    // why the toolbar is missing and the editor is plain.
+    setTimeout(() => showDraftStatus(`Editor failed to load (${editorType}). Plain-text fallback in use. Open log for details.`, true), 0);
+}
 // Ctrl+scroll / Ctrl+= / Ctrl+- / Ctrl+0 zoom for the compose editor body.
 // Persists per-session in localStorage so zoom survives window pop/close cycles.
 (() => {

package/package.json

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

package/packages/mailx-service/index.js

@@ -559,11 +559,23 @@ export class MailxService {
         // in PATH) fall back to the OS default handler so the user still gets
         // *some* editor. Report which one ran so the UI can say "Opening in
         // Word…" vs "Opening in default editor…".
-        const { spawnSync, spawn } = await import("node:child_process");
+        //
+        // CRITICAL: must use async spawn (not spawnSync). spawnSync blocks
+        // the Node event loop until the spawned process exits — and on
+        // Windows, `cmd /c start ... <gui-app>` sometimes does not return
+        // immediately when the GUI app hangs around. That froze the entire
+        // mailx IPC bridge on Edit-in-Word click; subsequent clicks
+        // (Discard, X, anything) hung waiting for a response that never
+        // came back. Async spawn launches and returns immediately;
+        // success/failure of the GUI launch is invisible from here, but
+        // the file is written and the watcher is armed regardless.
+        const { spawn } = await import("node:child_process");
         const tryLaunch = (cmd, args) => {
             try {
-                const r = spawnSync(cmd, args, { stdio: "ignore", windowsHide: true });
-                return r.status === 0 && !r.error;
+                const child = spawn(cmd, args, { detached: true, stdio: "ignore", windowsHide: true });
+                child.on("error", () => { });
+                child.unref();
+                return true;
             }
             catch {
                 return false;