@bobfrankston/mailx 1.0.443 → 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

@@ -1924,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,23 +92,26 @@ catch { /* private-mode / SecurityError — default quill */ }
     }
     catch { /* non-fatal */ }
 })();
-// 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".
+// 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) });
-    throw e;
 }
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
 try {
+    if (editorAssetError)
+        throw editorAssetError;
     editor = await createEditor(container, editorType);
 }
 catch (e) {

package/package.json

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