@bobfrankston/mailx 1.0.442 → 1.0.444

package/README.md

@@ -258,6 +258,10 @@ mailx -repair                 Re-sync message metadata (fix garbled subjects)
 mailx -rebuild                Wipe local cache and re-download everything from IMAP
 mailx -setup                  Interactive first-time setup (CLI)
 mailx -test                   Test IMAP/SMTP connectivity for all accounts
+mailx -reauth                 Clear cached OAuth tokens; next start re-consents
+mailx -lean-accounts          Strip defaulted fields from accounts.jsonc on
+                                Google Drive (port, tls, auth, enabled, ...).
+                                Add --dry-run to preview without writing.
 mailx -v                      Show version
 ```
 

package/bin/lean-accounts.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * lean-accounts.js — strip default-valued fields from an accounts.jsonc.
+ *
+ * Reads any accounts.jsonc (the one mailx writes when it bloats it with
+ * port: 993, tls: true, auth: "password", enabled: true, sig.html: false,
+ * etc.) and emits a compact form. Same logic as the Lean button in the
+ * config editor, but standalone so it works without mailx running.
+ *
+ * Usage:
+ *   node lean-accounts.js <path>           prints lean output to stdout
+ *   node lean-accounts.js <path> --inplace overwrites the file
+ *
+ * Drops:
+ *   - imap/smtp host/port/tls/auth that match the email's provider defaults
+ *   - imap/smtp user when it equals the email
+ *   - enabled: true (default)
+ *   - sig.html: false (default)
+ *   - per-account name when it matches the file-level "name"
+ *
+ * Promotes a shared "name" to file-level when every account has the same.
+ *
+ * Requires: jsonc-parser (any version that exports `parse` with comment+
+ * trailing-comma tolerance). The mailx repo's node_modules has it.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ── Provider defaults: same set mailx-settings uses ────────────────────────
+const PROVIDERS = {
+    "gmail.com": {
+        label: "Gmail",
+        imap: { host: "imap.gmail.com", port: 993, tls: true, auth: "oauth2" },
+        smtp: { host: "smtp.gmail.com", port: 587, tls: true, auth: "oauth2" },
+    },
+    "googlemail.com": {
+        label: "Gmail",
+        imap: { host: "imap.gmail.com", port: 993, tls: true, auth: "oauth2" },
+        smtp: { host: "smtp.gmail.com", port: 587, tls: true, auth: "oauth2" },
+    },
+    "outlook.com": {
+        label: "Outlook",
+        imap: { host: "outlook.office365.com", port: 993, tls: true, auth: "oauth2" },
+        smtp: { host: "smtp.office365.com", port: 587, tls: true, auth: "oauth2" },
+    },
+    "hotmail.com": {
+        label: "Outlook",
+        imap: { host: "outlook.office365.com", port: 993, tls: true, auth: "oauth2" },
+        smtp: { host: "smtp.office365.com", port: 587, tls: true, auth: "oauth2" },
+    },
+    "yahoo.com": {
+        label: "Yahoo",
+        imap: { host: "imap.mail.yahoo.com", port: 993, tls: true, auth: "oauth2" },
+        smtp: { host: "smtp.mail.yahoo.com", port: 587, tls: true, auth: "oauth2" },
+    },
+    "icloud.com": {
+        label: "iCloud",
+        imap: { host: "imap.mail.me.com", port: 993, tls: true, auth: "oauth2" },
+        smtp: { host: "smtp.mail.me.com", port: 587, tls: true, auth: "oauth2" },
+    },
+};
+
+function denormalizeAccount(acct, globalName) {
+    const domain = (acct.email || "").split("@")[1]?.toLowerCase() || "";
+    const provider = PROVIDERS[domain];
+    const out = {};
+    out.id = acct.id;
+    if (acct.label && acct.label !== provider?.label && acct.label !== acct.id) out.label = acct.label;
+    out.email = acct.email;
+    if (acct.name && acct.name !== globalName) out.name = acct.name;
+    if (acct.primary) out.primary = true;
+    if (acct.primaryCalendar !== undefined) out.primaryCalendar = acct.primaryCalendar;
+    if (acct.primaryTasks !== undefined) out.primaryTasks = acct.primaryTasks;
+    if (acct.primaryContacts !== undefined) out.primaryContacts = acct.primaryContacts;
+
+    const imapOut = {};
+    if (acct.imap?.host && acct.imap.host !== provider?.imap.host) imapOut.host = acct.imap.host;
+    if (acct.imap?.user && acct.imap.user !== acct.email) imapOut.user = acct.imap.user;
+    if (acct.imap?.password) imapOut.password = acct.imap.password;
+    if (acct.imap?.port && acct.imap.port !== (provider?.imap.port ?? 993)) imapOut.port = acct.imap.port;
+    if (acct.imap?.tls !== undefined && acct.imap.tls !== (provider?.imap.tls ?? true)) imapOut.tls = acct.imap.tls;
+    if (acct.imap?.auth && acct.imap.auth !== (provider?.imap.auth ?? "password")) imapOut.auth = acct.imap.auth;
+    if (Object.keys(imapOut).length > 0) out.imap = imapOut;
+
+    const smtpOut = {};
+    if (acct.smtp?.host && acct.smtp.host !== provider?.smtp.host) smtpOut.host = acct.smtp.host;
+    if (acct.smtp?.user && acct.smtp.user !== acct.email && acct.smtp.user !== acct.imap?.user) smtpOut.user = acct.smtp.user;
+    if (acct.smtp?.password) smtpOut.password = acct.smtp.password;
+    if (acct.smtp?.port && acct.smtp.port !== (provider?.smtp.port ?? 587)) smtpOut.port = acct.smtp.port;
+    if (acct.smtp?.tls !== undefined && acct.smtp.tls !== (provider?.smtp.tls ?? true)) smtpOut.tls = acct.smtp.tls;
+    if (acct.smtp?.auth && acct.smtp.auth !== (provider?.smtp.auth ?? "password")) smtpOut.auth = acct.smtp.auth;
+    if (Object.keys(smtpOut).length > 0) out.smtp = smtpOut;
+
+    if (acct.defaultSend) out.defaultSend = true;
+    if (acct.enabled === false) out.enabled = false;
+    if (acct.relayDomains?.length > 0) out.relayDomains = acct.relayDomains;
+    if (acct.deliveredToPrefix?.length > 0) out.deliveredToPrefix = acct.deliveredToPrefix;
+    if (acct.identityDomains?.length > 0) out.identityDomains = acct.identityDomains;
+
+    const syncContactsDefault = provider?.imap.auth === "oauth2";
+    if (acct.syncContacts !== undefined && acct.syncContacts !== syncContactsDefault) {
+        out.syncContacts = acct.syncContacts;
+    }
+    if (acct.signature) out.signature = acct.signature;
+    if (acct.sig?.text) {
+        out.sig = acct.sig.html ? { text: acct.sig.text, html: true } : { text: acct.sig.text };
+    }
+    return out;
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const inputPath = args.find(a => !a.startsWith("--"));
+    const inplace = args.includes("--inplace");
+    if (!inputPath) {
+        console.error("Usage: node lean-accounts.js <path-to-accounts.jsonc> [--inplace]");
+        process.exit(2);
+    }
+    if (!fs.existsSync(inputPath)) {
+        console.error(`File not found: ${inputPath}`);
+        process.exit(1);
+    }
+
+    // Resolve jsonc-parser from the local mailx repo's node_modules so the
+    // script doesn't require a global install. The repo root is two levels
+    // up from bin/ — and we walk up further if invoked from elsewhere.
+    let parseJsonc;
+    for (const dir of [
+        path.join(__dirname, "..", "node_modules", "jsonc-parser"),
+        path.join(__dirname, "..", "..", "node_modules", "jsonc-parser"),
+        path.join(process.cwd(), "node_modules", "jsonc-parser"),
+    ]) {
+        if (fs.existsSync(path.join(dir, "package.json"))) {
+            const mod = await import(pathToFileURL(path.join(dir, "lib", "esm", "main.js")).href).catch(() => null) ||
+                        await import("jsonc-parser").catch(() => null);
+            if (mod) { parseJsonc = mod.parse; break; }
+        }
+    }
+    if (!parseJsonc) {
+        try { parseJsonc = (await import("jsonc-parser")).parse; }
+        catch { console.error("jsonc-parser not found. Install or run from inside the mailx repo."); process.exit(1); }
+    }
+
+    const raw = fs.readFileSync(inputPath, "utf-8");
+    const errors = [];
+    const cfg = parseJsonc(raw, errors, { allowTrailingComma: true });
+    if (errors.length) {
+        console.error(`JSONC parse error: ${errors.map(e => JSON.stringify(e)).join(", ")}`);
+        process.exit(1);
+    }
+
+    const accounts = cfg?.accounts || (Array.isArray(cfg) ? cfg : []);
+    // Promote shared name to file-level when every entry has the same.
+    const names = new Set(accounts.map(a => a.name).filter(Boolean));
+    const sharedName = names.size === 1 ? [...names][0] : cfg?.name;
+    const lean = accounts.map(a => denormalizeAccount(a, sharedName));
+    const payload = sharedName ? { name: sharedName, accounts: lean } : { accounts: lean };
+    const output = JSON.stringify(payload, null, 2) + "\n";
+
+    if (inplace) {
+        fs.writeFileSync(inputPath, output);
+        console.error(`Wrote lean ${inputPath}`);
+    } else {
+        process.stdout.write(output);
+    }
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/bin/mailx.js

@@ -17,6 +17,9 @@
  *   mailx -repair            Re-sync metadata (fix corrupt subjects) keeping .eml files
  *   mailx -reauth            Clear cached OAuth tokens; next start re-consents
  *                             (use when new Google scopes have been added)
+ *   mailx -lean-accounts     Strip defaulted fields from the GDrive copy of
+ *                             accounts.jsonc (port, tls, auth, enabled, ...).
+ *                             Add --dry-run to preview without writing.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -89,7 +92,7 @@ function pidAlive(pid) {
 // on an old UI with no indication that the install has been upgraded.
 // Skip this logic for command-only flags (kill, rebuild, setup, ...) and for
 // the internal --daemon respawn.
-const __commandFlags = ["kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "import", "log", "reauth"];
+const __commandFlags = ["kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "import", "log", "reauth", "lean-accounts"];
 const __isCommandInvocation = process.argv.slice(2).some(a => __commandFlags.includes(a.replace(/^--?/, "")));
 if (!isDaemon && !__isCommandInvocation) {
     const inst = readInstanceFile();
@@ -147,8 +150,9 @@ const testMode = hasFlag("test");
 const rebuildMode = hasFlag("rebuild");
 const repairMode = hasFlag("repair");
 const importMode = hasFlag("import");
+const leanAccountsMode = hasFlag("lean-accounts");
 // Validate arguments
-const knownFlags = ["verbose", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "log", "import", "email", "mail", "daemon"];
+const knownFlags = ["verbose", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "log", "import", "lean-accounts", "email", "mail", "daemon"];
 for (const arg of args) {
     const flag = arg.replace(/^--?/, "");
     if (arg.startsWith("-") && !knownFlags.includes(flag)) {
@@ -363,6 +367,52 @@ if (repairMode) {
     console.log("  Run 'mailx' to re-sync from IMAP with correct encoding.");
     process.exit(0);
 }
+// Strip default-valued fields from the GDrive copy of accounts.jsonc.
+// Operates on the cloud version directly — the local ~/.mailx/accounts.jsonc
+// is just a cache and gets updated on the next mailx run anyway.
+if (leanAccountsMode) {
+    const { parse: parseJsonc } = await import("jsonc-parser");
+    const { initCloudConfig, normalizeAccount, denormalizeAccount } = await import("@bobfrankston/mailx-settings");
+    const { cloudRead, cloudWrite } = await import("@bobfrankston/mailx-settings");
+    await initCloudConfig("gdrive");
+    const raw = await cloudRead("accounts.jsonc");
+    if (!raw) {
+        console.error("No accounts.jsonc found in GDrive.");
+        process.exit(1);
+    }
+    const errors = [];
+    const cfg = parseJsonc(raw, errors, { allowTrailingComma: true });
+    if (errors.length) {
+        console.error(`JSONC parse error: ${errors.map((e) => JSON.stringify(e)).join(", ")}`);
+        process.exit(1);
+    }
+    const accountsRaw = cfg?.accounts || (Array.isArray(cfg) ? cfg : []);
+    if (accountsRaw.length === 0) {
+        console.error("No accounts found in GDrive accounts.jsonc.");
+        process.exit(1);
+    }
+    const globalName = cfg?.name;
+    const normalized = accountsRaw.map(a => normalizeAccount(a, globalName));
+    const names = new Set(normalized.map((a) => a.name).filter(Boolean));
+    const sharedName = names.size === 1 ? [...names][0] : globalName;
+    const lean = normalized.map((a) => denormalizeAccount(a, sharedName));
+    const payload = sharedName ? { name: sharedName, accounts: lean } : { accounts: lean };
+    const output = JSON.stringify(payload, null, 2);
+    const before = raw.length;
+    const after = output.length;
+    console.log(`Read ${accountsRaw.length} account(s) from GDrive.`);
+    console.log(`Before: ${before} bytes`);
+    console.log(`After:  ${after} bytes (${Math.round(100 * (1 - after / before))}% smaller)`);
+    if (process.argv.includes("--dry-run") || process.argv.includes("-n")) {
+        console.log("--- Lean output (dry run, not written) ---");
+        console.log(output);
+    }
+    else {
+        await cloudWrite("accounts.jsonc", output);
+        console.log("Wrote lean accounts.jsonc back to GDrive.");
+    }
+    process.exit(0);
+}
 // Import accounts from a local file into GDrive
 if (importMode) {
     const importPath = args.find(a => !a.startsWith("-"));

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";
@@ -1916,23 +1924,22 @@ document.addEventListener("keydown", (e) => {
         e.preventDefault();
         openCompose("new");
     }
-    // Ctrl+F = Forward
-    if (e.ctrlKey && e.key === "f") {
-        e.preventDefault();
-        openCompose("forward");
-    }
-    // Ctrl+R = Reply
-    if (e.ctrlKey && e.key === "r" && !e.shiftKey) {
+    // Ctrl+R = Reply (without Shift)
+    if (e.ctrlKey && e.key === "r" && !e.shiftKey && !e.altKey && !e.metaKey) {
         e.preventDefault();
         openCompose("reply");
     }
     // Ctrl+Shift+R = Reply All
-    if (e.ctrlKey && e.shiftKey && e.key === "R") {
+    if (e.ctrlKey && e.shiftKey && e.key === "R" && !e.altKey && !e.metaKey) {
         e.preventDefault();
         openCompose("replyAll");
     }
-    // Ctrl+F = Forward
-    if (e.ctrlKey && e.key.toLowerCase() === "f" && !e.shiftKey) {
+    // Ctrl+F = Forward (without Shift). Use toLowerCase so a Caps-Lock or
+    // shifted state doesn't bypass us. Single handler — the previous
+    // duplicate fired openCompose twice, which double-loaded the compose
+    // iframe and the second copy got an empty sessionStorage (the first
+    // had already consumed it), producing an empty Forward form.
+    if (e.ctrlKey && !e.shiftKey && !e.altKey && !e.metaKey && (e.key === "f" || e.key === "F")) {
         e.preventDefault();
         openCompose("forward");
     }

package/client/components/message-viewer.js

@@ -1113,6 +1113,17 @@ ${csp}
         if (t && (t.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName))) return;
         // Zoom keys handled by parent-side installPreviewControls; don't double-send.
         if (e.ctrlKey && (e.key === "=" || e.key === "+" || e.key === "-" || e.key === "0")) return;
+        // Preventing the iframe's default for keys we forward to the parent
+        // is essential — the parent's preventDefault on the synthetic
+        // keydown can't suppress the browser's reaction to the ORIGINAL
+        // event (Ctrl+R reload, Ctrl+F find, etc.). Suppress here so the
+        // browser doesn't act before the parent processes the action.
+        var k = (e.key || "").toLowerCase();
+        var isShortcut = e.ctrlKey && !e.altKey && !e.metaKey && (
+            k === "r" || k === "f" || k === "n" || k === "a" || k === "d" ||
+            k === "z" || k === "y" || k === "k"
+        );
+        if (isShortcut) e.preventDefault();
         window.parent.postMessage({
             type: "previewKey",
             key: e.key, code: e.code,

package/client/compose/compose.js

@@ -92,10 +92,62 @@ catch { /* private-mode / SecurityError — default quill */ }
     }
     catch { /* non-fatal */ }
 })();
-await loadEditorAssets(editorType);
+// Whatever happens in editor init, surface failures to the mailx log
+// AND fall through to a plain-contenteditable fallback so the rest of
+// the compose script (Discard, X, Send, save-draft) still runs. Earlier
+// versions re-threw asset-load failures, which left compose with dead
+// buttons and the user with no recourse — exactly the "Reply window
+// won't close" symptom we hit when Quill's CDN was unreachable.
+let editor;
+let editorAssetError = null;
+try {
+    await loadEditorAssets(editorType);
+}
+catch (e) {
+    editorAssetError = e;
+    logClientEvent("compose-editor-assets-failed", { type: editorType, error: String(e?.message || e) });
+}
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
-const editor = await createEditor(container, editorType);
+try {
+    if (editorAssetError)
+        throw editorAssetError;
+    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.444",
   "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;