@bobfrankston/mailx 1.0.313 → 1.0.324

package/bin/build-icon-ico.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * Wrap client/icon.png into client/icon.ico using the ICO-with-embedded-PNG
+ * format (Windows Vista+). No image decoding needed — Windows accepts a PNG
+ * bitstream inside an ICONDIR + ICONDIRENTRY prelude, so we can hand-roll the
+ * binary without any imaging dependency.
+ *
+ * Run: node bin/build-icon-ico.js
+ *
+ * Output: client/icon.ico derived from client/icon.png. Re-run whenever the
+ * source PNG changes.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+const root = path.resolve(import.meta.dirname, "..");
+const src = path.join(root, "client", "icon.png");
+const dst = path.join(root, "client", "icon.ico");
+
+if (!fs.existsSync(src)) {
+    console.error(`build-icon-ico: source not found: ${src}`);
+    process.exit(1);
+}
+
+const png = fs.readFileSync(src);
+
+// Parse PNG IHDR for width / height. PNG magic (8 bytes) + IHDR chunk length
+// (4 bytes) + "IHDR" (4 bytes), then width (4) + height (4) at offsets 16/20.
+if (png.length < 24 || png.toString("ascii", 12, 16) !== "IHDR") {
+    console.error("build-icon-ico: source is not a PNG (missing IHDR)");
+    process.exit(1);
+}
+let width = png.readUInt32BE(16);
+let height = png.readUInt32BE(20);
+if (width > 256) width = 256;
+if (height > 256) height = 256;
+
+// ICONDIR (6 bytes): reserved=0, type=1 (icon), count=1
+// ICONDIRENTRY (16 bytes per image):
+//   width (1 byte, 0 = 256), height (1 byte, 0 = 256), palette (0), reserved (0),
+//   planes (1), bpp (32), size (4), offset (4)
+const dir = Buffer.alloc(6);
+dir.writeUInt16LE(0, 0);
+dir.writeUInt16LE(1, 2);
+dir.writeUInt16LE(1, 4);
+
+const entry = Buffer.alloc(16);
+entry.writeUInt8(width === 256 ? 0 : width, 0);
+entry.writeUInt8(height === 256 ? 0 : height, 1);
+entry.writeUInt8(0, 2); // palette
+entry.writeUInt8(0, 3); // reserved
+entry.writeUInt16LE(1, 4); // color planes
+entry.writeUInt16LE(32, 6); // bpp
+entry.writeUInt32LE(png.length, 8); // image data size
+entry.writeUInt32LE(22, 12); // offset = 6 (dir) + 16 (entry)
+
+const ico = Buffer.concat([dir, entry, png]);
+fs.writeFileSync(dst, ico);
+console.log(`build-icon-ico: wrote ${dst} (${ico.length} bytes, ${width}×${height} PNG-embedded)`);

package/bin/mailx.js

@@ -23,7 +23,15 @@ import net from "node:net";
 import { ports } from "@bobfrankston/miscinfo";
 import { showMessageBox, showService, setAppName, setAppIcon } from "@bobfrankston/mailx-host";
 setAppName("mailx");
-setAppIcon(path.resolve(import.meta.dirname, "..", "client", "icon.png"));
+// Prefer the .ico (Windows Explorer / taskbar-pin shortcut uses the embedded
+// icon resource of the pinned exe, or a Windows icon resource referenced
+// via PKEY_AppUserModel_RelaunchIconResource — PNG can't play either role).
+// Fall back to PNG for the in-window / tao-level icon on non-Windows.
+{
+    const icoPath = path.resolve(import.meta.dirname, "..", "client", "icon.ico");
+    const pngPath = path.resolve(import.meta.dirname, "..", "client", "icon.png");
+    setAppIcon(fs.existsSync(icoPath) ? icoPath : pngPath);
+}
 const PORT = ports.mailx;
 const args = process.argv.slice(2);
 // Normalize: accept both -flag and --flag
@@ -227,6 +235,24 @@ if (hasFlag("kill")) {
             }
         }
         catch { /* */ }
+        // Kill orphaned msgernative.exe windows. When the node process dies
+        // without cascade-killing its WebView child (old crash, forced
+        // taskkill, etc.), the msgernative.exe stays on screen and looks
+        // like a live mailx. mailx -kill should leave no trace.
+        // Scoped to exes launched for mailx by filtering CommandLine — don't
+        // touch msger windows started by other apps (msga, bbs, etc.).
+        try {
+            const ps = execSync(`powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"name='msgernative.exe'\\" | Where-Object { $_.CommandLine -match 'mailx' -or $_.Path -match 'mailx' } | Select-Object -ExpandProperty ProcessId"`, { encoding: "utf-8" }).trim();
+            for (const pid of ps.split("\n").map(s => s.trim()).filter(s => /^\d+$/.test(s))) {
+                try {
+                    execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" });
+                    console.log(`Killed PID ${pid} (mailx msgernative/WebView)`);
+                    killed++;
+                }
+                catch { /* */ }
+            }
+        }
+        catch { /* */ }
     }
     else {
         try {
@@ -903,12 +929,20 @@ async function main() {
     }
     catch { /* no saved geometry — use defaults */ }
     const rootPkgVersion = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8")).version;
+    // Prefer .ico over .png for the window icon: on Windows, the .ico
+    // path doubles as the PKEY_AppUserModel_RelaunchIconResource value
+    // so taskbar pins use mailx's icon instead of msgernative's embedded
+    // resource. msger auto-detects the .ico extension and wires the
+    // relaunch icon after window creation.
+    const __iconIco = path.join(clientDir, "icon.ico");
+    const __iconPng = path.join(clientDir, "icon.png");
+    const __iconPath = fs.existsSync(__iconIco) ? __iconIco : __iconPng;
     const handle = showService({
         title: `mailx v${rootPkgVersion}`,
         url: "index.html",
         contentDir: clientDir,
         initScript: mailxapiScript,
-        icon: path.join(clientDir, "icon.png"),
+        icon: __iconPath,
         aumid: "com.frankston.mailx",
         size: savedGeometry
             ? { width: savedGeometry.width, height: savedGeometry.height }
@@ -921,8 +955,21 @@ async function main() {
     // Register ourselves as the live instance so subsequent `mailx` invocations
     // can detect version-mismatch and upgrade us (see top of file). Clear on
     // any of: SIGINT, SIGTERM, normal exit.
+    //
+    // Critical: the SIGTERM handler must *close the WebView child process*
+    // (handle.close() → kills msgernative.exe) before Node exits. Without
+    // this, the auto-upgrade leaves the old WebView orphaned on screen and
+    // the user sees an apparently frozen "old mailx" while the new Node is
+    // trying to spawn a second one. Cascade-killing the child makes the
+    // version-mismatch auto-upgrade actually transparent to the user.
     writeInstanceFile(process.pid);
-    const __cleanupInstance = () => { clearInstanceFile(); };
+    const __cleanupInstance = () => {
+        clearInstanceFile();
+        try {
+            handle.close();
+        }
+        catch { /* already gone */ }
+    };
     process.once("exit", __cleanupInstance);
     process.once("SIGINT", () => { __cleanupInstance(); process.exit(0); });
     process.once("SIGTERM", () => { __cleanupInstance(); process.exit(0); });
@@ -957,6 +1004,27 @@ async function main() {
             handle.send({ _cbid: req._cbid, result: { ok: true } });
             return;
         }
+        // Restart the daemon in-place without npm install. Spawn a fresh
+        // detached child running `mailx`, then gracefully shut this process
+        // down. The new daemon's version-mismatch / startup flow (see top
+        // of bin/mailx.ts) will either take over instantly (version same)
+        // or auto-upgrade through the instance-file cascade. Used when the
+        // user edits accounts.jsonc and needs the change to take effect
+        // without a terminal round-trip.
+        if (req._action === "restartDaemon") {
+            handle.send({ _cbid: req._cbid, ok: true, status: "restarting" });
+            try {
+                const { spawn: spawnChild } = await import("child_process");
+                const child = spawnChild("mailx", [], { detached: true, stdio: "ignore", shell: true });
+                child.unref();
+                console.log("  [restart] Spawned fresh daemon; shutting down current");
+            }
+            catch (e) {
+                console.error(`  [restart] Spawn failed: ${e.message}`);
+            }
+            gracefulShutdown("User requested restart");
+            return;
+        }
         // Auto-update action: run npm install then restart
         if (req._action === "performUpdate") {
             handle.send({ _cbid: req._cbid, ok: true, status: "updating" });

package/client/app.js

@@ -15,12 +15,16 @@ function updateBadge(count) {
     badgeCount = count;
     // Update title
     document.title = count > 0 ? `(${count}) ${baseTitle}` : baseTitle;
-    // Update favicon with badge
+    // Generate a single badge bitmap used for both the favicon (visible on
+    // browser tabs / mobile homescreen) AND the Windows taskbar overlay
+    // icon (visible as a Thunderbird-style corner pill on the taskbar
+    // button when running via msger). Rendered once, consumed twice.
     const canvas = document.createElement("canvas");
     canvas.width = 32;
     canvas.height = 32;
     const ctx = canvas.getContext("2d");
-    // Draw base icon (envelope)
+    // Base envelope icon (always drawn — so the favicon is a recognizable
+    // mailx icon even at 0 count).
     ctx.fillStyle = "#4a7ccc";
     ctx.fillRect(2, 8, 28, 20);
     ctx.fillStyle = "#6a9cec";
@@ -30,12 +34,11 @@ function updateBadge(count) {
     ctx.lineTo(30, 8);
     ctx.fill();
     if (count > 0) {
-        // Red badge circle
+        // Red badge circle with count
         ctx.fillStyle = "#e33";
         ctx.beginPath();
         ctx.arc(24, 8, 8, 0, Math.PI * 2);
         ctx.fill();
-        // Badge number
         ctx.fillStyle = "#fff";
         ctx.font = "bold 11px sans-serif";
         ctx.textAlign = "center";
@@ -49,7 +52,25 @@ function updateBadge(count) {
         link.rel = "icon";
         document.head.appendChild(link);
     }
-    link.href = canvas.toDataURL();
+    const dataUrl = canvas.toDataURL("image/png");
+    link.href = dataUrl;
+    // Also push to the Windows taskbar overlay via msger's IPC helper —
+    // no-op on Linux/Mac. For count=0, render a dedicated "no-overlay"
+    // icon that's all-transparent so the base icon shows cleanly.
+    try {
+        const msgapi = window.msgapi;
+        if (msgapi?.setTaskbarOverlay) {
+            if (count > 0) {
+                // strip "data:image/png;base64," prefix → base64 only
+                const b64 = dataUrl.split(",")[1] || "";
+                msgapi.setTaskbarOverlay(b64, `${count} unread`);
+            }
+            else {
+                msgapi.setTaskbarOverlay("", "");
+            }
+        }
+    }
+    catch { /* msgapi unavailable in browser fallback */ }
 }
 async function updateNewMessageCount() {
     try {
@@ -148,6 +169,48 @@ function hideAlert() {
     }
 }
 alertDismiss?.addEventListener("click", hideAlert);
+/** Show the alert banner with a "Restart" button wired to the mailxapi
+ *  restartDaemon action. Used when a watched config file whose changes
+ *  don't apply live (accounts.jsonc) has been modified. */
+function showRestartForConfigBanner() {
+    if (!alertBanner || !alertText)
+        return;
+    alertText.textContent = "accounts.jsonc changed — restart to apply.";
+    alertBanner.hidden = false;
+    alertBanner.dataset.key = "config-restart";
+    // Avoid duplicate buttons across repeat changes.
+    const existing = alertBanner.querySelector("#alert-restart-btn");
+    if (existing)
+        return;
+    const btn = document.createElement("button");
+    btn.id = "alert-restart-btn";
+    btn.textContent = "Restart now";
+    btn.style.cssText = "margin-left: 12px; padding: 3px 12px; cursor: pointer;";
+    btn.addEventListener("click", async () => {
+        btn.disabled = true;
+        btn.textContent = "Restarting…";
+        try {
+            const ipc = window.mailxapi;
+            if (ipc?.restartDaemon) {
+                await ipc.restartDaemon();
+                // Service is going down; the WebView should reload shortly
+                // when the replacement daemon takes over. Force a reload
+                // after a short delay in case the event doesn't arrive.
+                setTimeout(() => location.reload(), 2000);
+            }
+            else {
+                // Non-IPC (server/browser mode) — location reload won't
+                // restart the daemon but at least gives the user feedback.
+                location.reload();
+            }
+        }
+        catch (e) {
+            btn.textContent = `Failed: ${e?.message || e}`;
+            btn.disabled = false;
+        }
+    });
+    alertText.after(btn);
+}
 // ── Wire up components ──
 const folderTree = document.getElementById("folder-tree");
 let currentFolderSpecialUse = "";
@@ -770,32 +833,46 @@ document.getElementById("btn-flag")?.addEventListener("click", async () => {
     }
 });
 async function spamSelectedMessages() {
+    console.log("[spam] click — finding selection");
     const selected = getSelectedMessages();
     if (selected.length === 0) {
         const current = getCurrentMessage();
-        if (!current)
+        if (!current) {
+            console.warn("[spam] no message selected and none in viewer — nothing to do");
+            alert("No message selected. Click a message first, then the spam button.");
             return;
+        }
         selected.push({ accountId: current.accountId, uid: current.message.uid, folderId: current.message.folderId });
     }
+    console.log(`[spam] marking ${selected.length} message(s):`, selected);
     const statusSync = document.getElementById("status-sync");
+    // Optimistic: remove from list immediately so the user sees action happen.
+    // If the IPC fails, put them back. This matches local-first — the server
+    // sync is a background detail, the user's action should feel instant.
+    const snapshot = [...selected];
+    messageState.removeMessages(selected);
     try {
         const byAccount = new Map();
-        for (const msg of selected) {
+        for (const msg of snapshot) {
             const uids = byAccount.get(msg.accountId) || [];
             uids.push(msg.uid);
             byAccount.set(msg.accountId, uids);
         }
         for (const [accountId, uids] of byAccount) {
-            await markAsSpamMessages(accountId, uids);
+            const result = await markAsSpamMessages(accountId, uids);
+            console.log(`[spam] ${accountId}: moved ${result?.moved ?? uids.length} to folderId=${result?.targetFolderId}`);
         }
         if (statusSync)
-            statusSync.textContent = `Spam: ${selected.length} queued — pending server sync`;
-        messageState.removeMessages(selected);
+            statusSync.textContent = `Spam: ${snapshot.length} queued — pending server sync`;
     }
     catch (e) {
+        console.error(`[spam] failed:`, e);
         if (statusSync)
-            statusSync.textContent = `Spam failed: ${e.message}`;
-        console.error(`Spam failed: ${e.message}`);
+            statusSync.textContent = `Spam failed: ${e?.message || e}`;
+        alert(`Mark-as-spam failed: ${e?.message || e}\n\n${selected.length} message(s) stayed in the list; check Settings → account spam folder and accounts.jsonc.`);
+        // Best-effort restore: re-set the messages we optimistically removed.
+        // removeMessages has no inverse in message-state, so we'll rely on the
+        // next folder reload to repopulate. Surface the failure clearly.
     }
 }
 document.getElementById("btn-spam")?.addEventListener("click", spamSelectedMessages);
@@ -1197,8 +1274,14 @@ onWsEvent((event) => {
         case "configChanged":
             // A watched config file was modified — could be user edit via the
             // JSONC editor, a GDrive sync, or mailx itself saving (e.g.
-            // allowlist update on "allow sender"). Show in the status bar
-            // briefly, NOT as an error banner — it's informational.
+            // allowlist update on "allow sender").
+            //
+            // For accounts.jsonc specifically, surface a sticky banner with a
+            // Restart button — the file change has no effect on the running
+            // daemon (IMAP connections, token caches, sync loops use the old
+            // config snapshot), and users shouldn't need `mailx -kill` just
+            // to apply an edit. For other files (allowlist / clients /
+            // config) the service handles live, a status-bar flash suffices.
             if (statusSync) {
                 statusSync.textContent = `${event.filename} updated`;
                 setTimeout(() => {
@@ -1206,6 +1289,9 @@ onWsEvent((event) => {
                         statusSync.textContent = "";
                 }, 8000);
             }
+            if (event.filename && /accounts\.jsonc/i.test(String(event.filename))) {
+                showRestartForConfigBanner();
+            }
             break;
         case "cloudError":
             // Cloud read/write failed (Google Drive auth/network/etc.). Show a

package/client/components/message-list.js

@@ -71,17 +71,24 @@ export function initMessageList(handler) {
     // Infinite scroll
     const body = document.getElementById("ml-body");
     if (body) {
-        // Touch scroll vs tap: track finger movement at the container level and
-        // flag "we were scrolling" so row click handlers can bail out. WebView
-        // sometimes fires click on touchend even when the user dragged — which
-        // was opening a message just from scrolling the list.
+        // Touch scroll vs tap: the WebView occasionally synthesizes a click on
+        // touchend even when the user clearly scrolled, which opened a message
+        // just from swiping the list. Multi-signal detection so a scroll is
+        // reliably classified:
+        //   1. touchmove movement ≥ TAP_SLOP — the primary signal
+        //   2. actual scrollTop change between touchstart and touchend — always
+        //      set the flag when the container moved, even if touchmove never
+        //      fired (some Android builds coalesce events under momentum)
+        //   3. longer TAP_SLOP (15px) — fingers are wide; 10px was too twitchy
         let touchStartY = 0;
         let touchStartX = 0;
-        const TAP_SLOP = 10;
+        let touchStartScrollTop = 0;
+        const TAP_SLOP = 15;
         body.addEventListener("touchstart", (e) => {
             const t = e.touches[0];
             touchStartY = t.clientY;
             touchStartX = t.clientX;
+            touchStartScrollTop = body.scrollTop;
             touchWasScroll = false;
         }, { passive: true });
         body.addEventListener("touchmove", (e) => {
@@ -90,6 +97,13 @@ export function initMessageList(handler) {
                 touchWasScroll = true;
             }
         }, { passive: true });
+        body.addEventListener("touchend", () => {
+            // If the container actually scrolled during this touch, the user
+            // was scrolling regardless of how small their finger movement was.
+            if (body.scrollTop !== touchStartScrollTop) {
+                touchWasScroll = true;
+            }
+        }, { passive: true });
         body.addEventListener("scroll", () => {
             if (loading)
                 return;

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 { getVersion, getSettings, getAccounts, searchContacts, sendMessage, saveDraft as apiSaveDraft, deleteDraft } from "../lib/api-client.js";
+import { getSettings, getAccounts, searchContacts, sendMessage, saveDraft as apiSaveDraft, deleteDraft } from "../lib/api-client.js";
 /** Close compose window */
 function closeCompose() {
     window.close();
@@ -45,15 +45,37 @@ async function loadEditorAssets(type) {
     }
 }
 // ── Determine editor type from settings ──
+//
+// Compose must open fast. The previous flow awaited getVersion() then
+// getSettings() sequentially before the editor was even loaded — any
+// service-side stall (busy sync, slow IMAP, hung OAuth refresh) turned
+// "click Reply" into a multi-second / multi-minute wait with a blank
+// compose window. Local-first: read the editor-type preference from a
+// tiny localStorage cache that we update whenever getSettings succeeds
+// in the background. Default to quill on first run / cache miss.
 let editorType = "quill";
 let appSettings = null;
 try {
-    await getVersion(); // verify server is up
-    appSettings = await getSettings();
-    if (appSettings.ui?.editor === "tiptap")
-        editorType = "tiptap";
+    const cached = localStorage.getItem("mailx-editor-type");
+    if (cached === "tiptap" || cached === "quill")
+        editorType = cached;
 }
-catch { /* default to quill */ }
+catch { /* private-mode / SecurityError — default quill */ }
+// Refresh the cache asynchronously — doesn't block compose open.
+(async () => {
+    try {
+        appSettings = await getSettings();
+        const next = appSettings?.ui?.editor === "tiptap" ? "tiptap" : "quill";
+        try {
+            localStorage.setItem("mailx-editor-type", next);
+        }
+        catch { /* */ }
+        // Note: we don't hot-swap the editor if the preference changed while
+        // compose was opening — the old type is already instantiated. Next
+        // compose open will pick up the new preference.
+    }
+    catch { /* non-fatal */ }
+})();
 await loadEditorAssets(editorType);
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
@@ -382,26 +404,63 @@ function scheduleDraftSave() {
         clearTimeout(draftDebounceTimer);
     draftDebounceTimer = setTimeout(() => { draftDebounceTimer = null; saveDraft(); }, DRAFT_INPUT_DEBOUNCE_MS);
 }
-// ── Initialize: always fetch real accounts from the API before applying init, then
-//    start the auto-save timer. Callers like message-viewer's Edit Draft pass
-//    init.accounts=[], so we can't trust what's in the init blob. ──
+// ── Initialize: local-first population.
+//
+// Reply / Reply-All / Forward callers pre-populate `init.accounts` with the
+// full account list (app.ts:openCompose). In that common case we do NOT need
+// to call getAccounts() — everything required to fill the compose form is
+// already in sessionStorage and reads synchronously. That turns "click Reply"
+// into an instant-open instead of "wait for getAccounts IPC to respond,
+// which can take >120s when the service is busy syncing / hung on IMAP".
+//
+// getAccounts is still called (non-blocking) to refresh the dropdown with
+// the freshest data — and it IS awaited only in the fallback path where
+// init doesn't have an account list (message-viewer's Edit Draft passes
+// init.accounts=[]).
 (async () => {
-    let accounts = [];
-    try {
-        accounts = await getAccounts();
-    }
-    catch (e) {
-        console.error("Failed to load accounts:", e);
-    }
     const stored = sessionStorage.getItem("composeInit");
     if (stored) {
         sessionStorage.removeItem("composeInit");
         const init = JSON.parse(stored);
-        if (!init.accounts || init.accounts.length === 0)
-            init.accounts = accounts;
-        applyInit(init);
+        if (init.accounts && init.accounts.length > 0) {
+            // Happy path — init is complete. Apply immediately. Kick
+            // getAccounts in the background to refresh the dropdown if the
+            // user keeps compose open long enough for the result.
+            applyInit(init);
+            getAccounts().then((fresh) => {
+                if (Array.isArray(fresh) && fresh.length > 0) {
+                    init.accounts = fresh;
+                    // Re-populate the From dropdown only — don't clobber
+                    // anything the user may have already typed.
+                    try {
+                        populateFromOptions(fresh);
+                    }
+                    catch { /* */ }
+                }
+            }).catch(() => { });
+        }
+        else {
+            // Edit Draft / other callers that didn't pre-fill accounts.
+            // Have to wait on getAccounts here — the From dropdown needs it.
+            let fresh = [];
+            try {
+                fresh = await getAccounts();
+            }
+            catch (e) {
+                console.error("Failed to load accounts:", e);
+            }
+            init.accounts = fresh;
+            applyInit(init);
+        }
     }
     else {
+        let accounts = [];
+        try {
+            accounts = await getAccounts();
+        }
+        catch (e) {
+            console.error("Failed to load accounts:", e);
+        }
         populateFromOptions(accounts);
         toInput.focus();
     }

package/client/lib/mailxapi.js

@@ -118,6 +118,20 @@
         aiTransform: function(req) {
             return callNode("aiTransform", req);
         },
+        // Restart the background service so edits to accounts.jsonc /
+        // allowlist.jsonc / other live config take effect without the user
+        // having to type `mailx -kill`. The service spawns a fresh detached
+        // daemon and then exits; the new daemon takes over.
+        restartDaemon: function() {
+            return new Promise(function(resolve) {
+                var id = String(++_callbackId);
+                _callbacks[id] = { resolve: resolve, reject: resolve, timer: setTimeout(function() {
+                    delete _callbacks[id];
+                    resolve({ ok: true, status: "service-gone" });
+                }, 5000) };
+                try { window.ipc.postMessage(JSON.stringify({ _action: "restartDaemon", _cbid: id })); } catch(e) { resolve({ ok: false }); }
+            });
+        },
         searchContacts: function(query) {
             return callNode("searchContacts", { query: query });
         },

package/client/styles/components.css

@@ -396,7 +396,10 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     &:hover { background: var(--color-bg-hover); }
     &.selected { background: var(--color-brand); color: var(--color-brand-dark); font-weight: 500; }
     &.unread {
-        font-weight: 600;
+        /* Thunderbird-level emphasis: true bold (700) rather than semibold
+         *  (600). At smaller row heights the weight contrast is the cue the
+         *  eye tracks — color shifts alone read as noise on a dense list. */
+        font-weight: 700;
         color: var(--color-unread);
     }
 }
@@ -479,7 +482,7 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
 }
 .ml-thread-popup-item:hover { background: var(--color-bg-hover); }
 .ml-thread-popup-item.unread .ml-thread-popup-from,
-.ml-thread-popup-item.unread .ml-thread-popup-subject { font-weight: 600; }
+.ml-thread-popup-item.unread .ml-thread-popup-subject { font-weight: 700; }
 .ml-thread-popup-from {
     grid-column: 1;
     grid-row: 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.313",
+  "version": "1.0.324",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -12,7 +12,7 @@
     "client"
   ],
   "scripts": {
-    "build": "npm run build --workspaces --if-present && tsc -p bin",
+    "build": "npm run build --workspaces --if-present && tsc -p bin && node bin/build-icon-ico.js",
     "watch": "tsc -w",
     "start": "node --watch packages/mailx-server/index.js",
     "start:prod": "node packages/mailx-server/index.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.7",
     "@bobfrankston/miscinfo": "^1.0.9",
     "@bobfrankston/oauthsupport": "^1.0.24",
-    "@bobfrankston/msger": "^0.1.342",
+    "@bobfrankston/msger": "^0.1.343",
     "@bobfrankston/mailx-host": "^0.1.3",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
@@ -88,7 +88,7 @@
       "@bobfrankston/iflow-node": "^0.1.7",
       "@bobfrankston/miscinfo": "^1.0.9",
       "@bobfrankston/oauthsupport": "^1.0.24",
-      "@bobfrankston/msger": "^0.1.342",
+      "@bobfrankston/msger": "^0.1.343",
       "@bobfrankston/mailx-host": "^0.1.3",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",

package/packages/mailx-imap/index.d.ts

@@ -249,6 +249,7 @@ export declare class ImapManager extends EventEmitter {
     /** Stop Outbox worker */
     stopOutboxWorker(): void;
     private configWatchers;
+    private cloudPollTimers;
     /** Watch the local config files for external changes. On change, emit
      *  configChanged so the UI can show a "restart to apply" banner. Uses
      *  a debounce to coalesce rapid writes from save tools. */

package/packages/mailx-imap/index.js

@@ -564,6 +564,11 @@ export class ImapManager extends EventEmitter {
         const folders = await client.getFolderList();
         console.log(`  [diag] ${accountId}: getFolderList done in ${Date.now() - t0}ms (${folders.length} folders)`);
         const specialFolders = client.getSpecialFolders(folders);
+        // Collect server paths so we can prune anything the server no longer
+        // has (user-renamed / -deleted / case-flipped a folder from another
+        // client). IMAP paths are case-sensitive, so "Foo" → "foo" is a real
+        // delete+create of two distinct mailboxes.
+        const serverPaths = new Set();
         for (const folder of folders) {
             // Skip non-selectable folders (virtual parents like "Added", "Added2")
             const flags = folder.flags;
@@ -584,6 +589,34 @@ export class ImapManager extends EventEmitter {
             else if (specialFolders.archive === folder.path)
                 specialUse = "archive";
             this.db.upsertFolder(accountId, folder.path, folder.name || folder.path.split(folder.delimiter || "/").pop() || folder.path, specialUse, folder.delimiter || "/");
+            serverPaths.add(folder.path);
+        }
+        // Prune: any local folder whose exact path (case-sensitive) isn't in
+        // the server's list has been deleted or renamed server-side. Safety
+        // rails: only prune when the server returned a non-empty list (empty
+        // result is more likely a transient protocol / auth error than "all
+        // your folders were deleted"). Never prune INBOX under any
+        // circumstances — even a broken server response shouldn't make us
+        // drop the account's primary mailbox. All other special-use folders
+        // ARE prunable: if the user actually deleted Sent on the server,
+        // we should reflect that locally, and the next sync will re-detect
+        // the server's real Sent folder and re-upsert.
+        if (folders.length > 0) {
+            const localFolders = this.db.getFolders(accountId);
+            const stale = localFolders.filter(f => !serverPaths.has(f.path) &&
+                f.specialUse !== "inbox");
+            for (const f of stale) {
+                console.log(`  [sync] ${accountId}: pruning stale folder "${f.path}" (id=${f.id}) — no longer on server`);
+                try {
+                    this.db.deleteFolder(f.id);
+                }
+                catch (e) {
+                    console.error(`  [sync] ${accountId}: prune failed for "${f.path}": ${e.message}`);
+                }
+            }
+            if (stale.length > 0) {
+                this.emit("folderCountsChanged", accountId, {});
+            }
         }
         this.emit("syncProgress", accountId, "folders", 100);
         // Notify UI that folder structure changed — triggers tree re-render
@@ -2847,6 +2880,7 @@ export class ImapManager extends EventEmitter {
     }
     // ── Config file watcher ──
     configWatchers = [];
+    cloudPollTimers = [];
     /** Watch the local config files for external changes. On change, emit
      *  configChanged so the UI can show a "restart to apply" banner. Uses
      *  a debounce to coalesce rapid writes from save tools. */
@@ -2875,6 +2909,55 @@ export class ImapManager extends EventEmitter {
                 console.error(`  [watch] Failed to watch ${filename}: ${e.message}`);
             }
         }
+        // GDrive has no push/watch for arbitrary Drive files, so edits on
+        // another device (or via Drive web) never fire fs.watch locally.
+        // Poll the cloud copies of the replicated-to-cloud config files
+        // (accounts.jsonc, allowlist.jsonc, clients.jsonc) every 3 minutes,
+        // compare to local, and write-through on difference. The local
+        // fs.watch above then picks up the write and emits configChanged.
+        // config.jsonc is per-machine / local-only — never polled.
+        const cloudFiles = ["accounts.jsonc", "allowlist.jsonc", "clients.jsonc"];
+        const CLOUD_POLL_MS = 3 * 60 * 1000;
+        const pollCloud = async () => {
+            let cloudRead;
+            try {
+                ({ cloudRead } = await import("@bobfrankston/mailx-settings"));
+            }
+            catch {
+                return; /* cloud module unavailable */
+            }
+            for (const filename of cloudFiles) {
+                try {
+                    const cloudContent = await cloudRead(filename);
+                    if (!cloudContent)
+                        continue;
+                    const localPath = path.join(configDir, filename);
+                    let localContent = null;
+                    try {
+                        localContent = fs.readFileSync(localPath, "utf-8");
+                    }
+                    catch { /* missing */ }
+                    if (localContent === cloudContent)
+                        continue;
+                    // Cloud copy differs — write through so watchers / downstream
+                    // readers see the new value. fs.watch above will fire and
+                    // emit configChanged → UI banner.
+                    fs.writeFileSync(localPath, cloudContent);
+                    console.log(`  [cloud-poll] ${filename} updated from cloud copy`);
+                }
+                catch (e) {
+                    // Drive unreachable, auth expired, file missing in cloud —
+                    // silent retry on next tick; no user-visible fallout.
+                    console.log(`  [cloud-poll] ${filename} check skipped: ${e?.message || e}`);
+                }
+            }
+        };
+        // First poll ~10s after startup, then every 3 min.
+        setTimeout(() => {
+            pollCloud();
+            const interval = setInterval(pollCloud, CLOUD_POLL_MS);
+            this.cloudPollTimers.push(interval);
+        }, 10_000);
     }
     /** Stop all config file watchers */
     stopWatchingConfig() {
@@ -2885,6 +2968,13 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
         this.configWatchers = [];
+        for (const t of this.cloudPollTimers) {
+            try {
+                clearInterval(t);
+            }
+            catch { /* ignore */ }
+        }
+        this.cloudPollTimers = [];
     }
     // ── Google Contacts Sync ──
     contactsSyncToken = null;

package/packages/mailx-service/index.js

@@ -587,16 +587,33 @@ export class MailxService {
             throw new Error("Folder not found");
         const client = this.imapManager.createPublicClient(accountId);
         try {
-            if (client.deleteMailbox) {
-                await client.deleteMailbox(folder.path);
+            try {
+                if (client.deleteMailbox) {
+                    await client.deleteMailbox(folder.path);
+                }
+                else {
+                    await client.withConnection(async () => {
+                        await client.client.mailboxDelete(folder.path);
+                    });
+                }
             }
-            else {
-                await client.withConnection(async () => {
-                    await client.client.mailboxDelete(folder.path);
-                });
+            catch (e) {
+                // Server already doesn't have this folder — common case when
+                // the user deleted / renamed it from another client and mailx
+                // is still showing the stale local row. Silently treat as
+                // success and proceed with local cleanup; the user's intent
+                // ("make this go away") is met either way.
+                const msg = String(e?.message || e || "").toLowerCase();
+                const alreadyGone = /nonexistent|does not exist|no such|not found|NO \[.*\] Mailbox|404/i.test(msg);
+                if (!alreadyGone)
+                    throw e;
+                console.log(`  [folder] ${accountId} delete "${folder.path}": server says already gone — cleaning local DB`);
             }
             this.db.deleteFolder(folderId);
-            await client.logout();
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
         }
         finally {
             try {
@@ -647,6 +664,16 @@ export class MailxService {
     }
     // ── Drafts ──
     async saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId) {
+        // Local-first: commit the draft to the local filesystem synchronously
+        // and return immediately. The IMAP APPEND (and the previous-draft
+        // delete) run in the background. Previously this method awaited IMAP
+        // inline, which produced the 30/120s `mailxapi timeout: saveDraft`
+        // the user reported — every IMAP stall (slow server, hung OAuth,
+        // maxed connection pool) froze autosave. The local `.eml` written
+        // below is the user's crash-safety net; IMAP is a sync target, not
+        // a prerequisite. X-Mailx-Draft-ID is carried in the MIME headers
+        // so the reconciler can de-duplicate on the server by header search
+        // even without the previousDraftUid round-trip.
         const settings = loadSettings();
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
@@ -663,7 +690,8 @@ export class MailxService {
             `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: quoted-printable`,
         ].filter(h => h !== null).join("\r\n");
         const raw = `${headers}\r\n\r\n${bodyEncoded}`;
-        // Save local editing copy — crash recovery, keep last 3
+        // Local commit: write editing copy to disk. Crash recovery lives in
+        // the last 3 files. Synchronous fs (~ms) so the caller returns fast.
         try {
             const editingDir = path.join(getConfigDir(), "sending", accountId, "editing");
             fs.mkdirSync(editingDir, { recursive: true });
@@ -677,9 +705,16 @@ export class MailxService {
                 fs.unlinkSync(path.join(editingDir, files.shift()));
             }
         }
-        catch { /* ignore */ }
-        const draftUid = await this.imapManager.saveDraft(accountId, raw, previousDraftUid, id);
-        return { draftUid, draftId: id };
+        catch { /* non-fatal — draft stays in memory at least */ }
+        // Background reconcile to server Drafts folder. Fire-and-forget —
+        // the ACK to the client is already on its way.
+        this.imapManager.saveDraft(accountId, raw, previousDraftUid, id).catch((e) => {
+            console.error(`  [draft] background IMAP save failed for ${id}: ${e?.message || e}`);
+            // Surface as an event so the UI can show a status-bar hint without
+            // blocking the caller. Draft is preserved on disk regardless.
+            this.emit?.("draftSaveDeferred", { accountId, draftId: id, error: String(e?.message || e) });
+        });
+        return { draftUid: null, draftId: id };
     }
     async deleteDraft(accountId, draftUid, draftId) {
         await this.imapManager.deleteDraft(accountId, draftUid, draftId);