@bobfrankston/mailx 1.0.327 → 1.0.333

package/bin/mailx.js

@@ -964,7 +964,13 @@ async function main() {
     // version-mismatch auto-upgrade actually transparent to the user.
     writeInstanceFile(process.pid);
     const __cleanupInstance = () => {
-        clearInstanceFile();
+        // Only clear if WE are still the registered instance. Prevents the
+        // restart-daemon sequence (clear → spawn → new daemon writes its
+        // own entry → we exit) from deleting the replacement's claim on
+        // the way out.
+        const inst = readInstanceFile();
+        if (inst && inst.pid === process.pid)
+            clearInstanceFile();
         try {
             handle.close();
         }
@@ -1004,20 +1010,26 @@ 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.
+        // Restart the daemon in-place without npm install. Subtle: the new
+        // mailx's startup-time instance check sees the instance.json we
+        // wrote and bails with "already running" if versions match —
+        // skipping the new process entirely. Clear the instance file
+        // FIRST so the replacement can claim the slot, THEN spawn, THEN
+        // gracefully shut this process down. The exit handler guards
+        // against clobbering the replacement's entry (see __cleanupInstance
+        // below — only clears if instance.json's PID still matches ours).
         if (req._action === "restartDaemon") {
             handle.send({ _cbid: req._cbid, ok: true, status: "restarting" });
             try {
+                clearInstanceFile();
                 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");
+                // Give the spawn a moment to take hold before we start
+                // tearing things down — otherwise IMAP disconnects could
+                // race with the new process's startup handshake.
+                await new Promise(r => setTimeout(r, 800));
             }
             catch (e) {
                 console.error(`  [restart] Spawn failed: ${e.message}`);

package/client/android.html

@@ -150,6 +150,7 @@
                     <button class="tb-btn" id="btn-delete" title="Delete">🗑</button>
                     <button class="tb-btn" id="btn-spam" title="Mark as spam" hidden>⚠</button>
                     <button class="tb-btn" id="btn-flag" title="Flag">⚑</button>
+                    <button class="tb-btn" id="btn-mark-unread" title="Mark unread">◉</button>
                     <span style="flex:1"></span>
                     <button class="mv-action mv-action-primary" id="mv-edit-draft" hidden>Edit & Send</button>
                     <a class="mv-unsubscribe" id="mv-unsubscribe" hidden>Unsubscribe</a>

package/client/app.js

@@ -175,7 +175,11 @@ alertDismiss?.addEventListener("click", hideAlert);
 function showRestartForConfigBanner() {
     if (!alertBanner || !alertText)
         return;
-    alertText.textContent = "accounts.jsonc changed — restart to apply.";
+    // Timestamp in the banner so repeated / spurious fires are visually
+    // distinguishable (and the user can see when the change actually
+    // happened, useful for debugging false triggers).
+    const ts = new Date().toLocaleTimeString([], { hour12: false });
+    alertText.textContent = `[${ts}] accounts.jsonc changed — restart to apply.`;
     alertBanner.hidden = false;
     alertBanner.dataset.key = "config-restart";
     // Avoid duplicate buttons across repeat changes.
@@ -899,6 +903,25 @@ async function refreshSpamButtonVisibility() {
 document.addEventListener("mailx-message-shown", refreshSpamButtonVisibility);
 document.addEventListener("mailx-folder-changed", refreshSpamButtonVisibility);
 document.getElementById("btn-compose")?.addEventListener("click", () => openCompose("new"));
+document.getElementById("btn-mark-unread")?.addEventListener("click", () => {
+    // Toggle \Seen on the currently-selected message. Mirrors the R
+    // keyboard shortcut and the right-click "Mark unread" menu item, but
+    // as a visible toolbar button so users discover the behavior.
+    const sel = messageState.getSelected();
+    if (!sel)
+        return;
+    const isSeen = sel.flags.includes("\\Seen");
+    const newFlags = isSeen
+        ? sel.flags.filter((f) => f !== "\\Seen")
+        : [...sel.flags, "\\Seen"];
+    updateFlags(sel.accountId, sel.uid, newFlags).then(() => {
+        sel.flags = newFlags;
+        messageState.updateMessageFlags(sel.accountId, sel.uid, newFlags);
+        const row = document.querySelector(`.ml-row[data-uid="${sel.uid}"][data-account-id="${sel.accountId}"]`);
+        if (row)
+            row.classList.toggle("unread", !newFlags.includes("\\Seen"));
+    }).catch(() => { });
+});
 document.getElementById("btn-reply")?.addEventListener("click", () => openCompose("reply"));
 document.getElementById("btn-reply-all")?.addEventListener("click", () => openCompose("replyAll"));
 document.getElementById("btn-forward")?.addEventListener("click", () => openCompose("forward"));
@@ -1589,7 +1612,10 @@ async function openJsoncEditor(initialFile) {
     const panel = document.createElement("div");
     panel.className = "mailx-modal mailx-modal-wide";
     panel.innerHTML = `
-        <div class="mailx-modal-title">Edit config file</div>
+        <div class="mailx-modal-title">
+            <span class="mailx-modal-title-text">Edit config file</span>
+            <button type="button" class="mailx-modal-close" id="jsonc-close" title="Close (Esc)" aria-label="Close">&times;</button>
+        </div>
         <label class="mailx-modal-label">File
             <select class="mailx-modal-input" id="jsonc-file">
                 <option value="accounts.jsonc">accounts.jsonc — accounts (shared via Google Drive)</option>
@@ -1701,6 +1727,7 @@ async function openJsoncEditor(initialFile) {
         }
     };
     document.addEventListener("keydown", onKey, true);
+    panel.querySelector("#jsonc-close").addEventListener("click", close);
     panel.querySelectorAll(".mailx-modal-btn").forEach(btn => {
         btn.addEventListener("click", async () => {
             const action = btn.dataset.action;

package/client/index.html

@@ -130,6 +130,7 @@
                     <button class="tb-btn" id="btn-delete" title="Delete (Del)">🗑</button>
                     <button class="tb-btn" id="btn-spam" title="Mark as spam — move to configured spam folder" hidden>⚠</button>
                     <button class="tb-btn" id="btn-flag" title="Flag">⚑</button>
+                    <button class="tb-btn" id="btn-mark-unread" title="Mark unread (R)">◉</button>
                     <span style="flex:1"></span>
                     <button class="mv-action mv-action-primary" id="mv-edit-draft" hidden>Edit & Send</button>
                     <a class="mv-unsubscribe" id="mv-unsubscribe" hidden>Unsubscribe</a>

package/client/styles/components.css

@@ -544,12 +544,39 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
 }
 .mailx-modal-wide {
     width: 80vw;
-    max-width: 900px;
-    max-height: 85vh;
+    max-width: 95vw;
+    max-height: 95vh;
+    height: 85vh;
+    resize: both;
+    overflow: auto;
+    min-width: 480px;
+    min-height: 320px;
 }
 .mailx-modal-title {
     font-size: var(--font-size-lg);
     font-weight: 600;
+    display: flex;
+    align-items: center;
+    gap: var(--gap-sm);
+}
+.mailx-modal-title-text {
+    flex: 1;
+}
+.mailx-modal-close {
+    appearance: none;
+    background: transparent;
+    border: none;
+    color: var(--color-text-muted);
+    font-size: 20px;
+    line-height: 1;
+    cursor: pointer;
+    padding: 2px 8px;
+    border-radius: var(--radius-sm);
+
+    &:hover {
+        background: var(--color-bg-surface);
+        color: var(--color-text);
+    }
 }
 .mailx-modal-label {
     display: flex;
@@ -568,7 +595,8 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     font-size: var(--font-size-base);
 }
 .mailx-modal-textarea {
-    min-height: 50vh;
+    flex: 1;
+    min-height: 200px;
     resize: vertical;
     font-family: var(--font-mono);
     font-size: 13px;
@@ -594,6 +622,7 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     display: grid;
     grid-template-columns: minmax(0, 1fr) minmax(240px, 360px);
     gap: var(--gap-md);
+    flex: 1;
     min-height: 0;
 
     &:has(.mailx-help-collapsed) {

package/package.json

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

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

@@ -53,6 +53,10 @@ export declare class ImapManager extends EventEmitter {
     deleteOnServer(accountId: string, folderPath: string, uid: number): Promise<void>;
     /** Search messages on the IMAP server — returns matching UIDs */
     searchOnServer(accountId: string, mailboxPath: string, criteria: any): Promise<number[]>;
+    /** Server-side search that also materializes any UIDs we don't yet have
+     *  locally. Returns the full result after upsert, so the caller can
+     *  render hits that fall outside the history window. */
+    searchAndFetchOnServer(accountId: string, folderId: number, mailboxPath: string, criteria: any): Promise<number[]>;
     /** Create a fresh IMAP client for an account (public access for API endpoints) */
     createPublicClient(accountId: string): any;
     /** Persistent operational connections — one per account, reused for all operations */

package/packages/mailx-imap/index.js

@@ -241,6 +241,41 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
+    /** Server-side search that also materializes any UIDs we don't yet have
+     *  locally. Returns the full result after upsert, so the caller can
+     *  render hits that fall outside the history window. */
+    async searchAndFetchOnServer(accountId, folderId, mailboxPath, criteria) {
+        const client = this.createClient(accountId);
+        try {
+            const uids = await client.searchMessages(mailboxPath, criteria);
+            if (uids.length === 0)
+                return [];
+            const have = new Set(this.db.getUidsForFolder(accountId, folderId));
+            const missing = uids.filter(u => !have.has(u));
+            if (missing.length > 0) {
+                // Fetch in chunks so a large hit-set doesn't over-long a single command.
+                const folder = this.db.getFolders(accountId).find(f => f.id === folderId);
+                if (folder) {
+                    const CHUNK = 500;
+                    for (let i = 0; i < missing.length; i += CHUNK) {
+                        const range = missing.slice(i, i + CHUNK).join(",");
+                        const fetched = await client.fetchMessages(mailboxPath, range, { source: false });
+                        if (fetched?.length) {
+                            await this.storeMessages(accountId, folderId, folder, fetched, 0);
+                        }
+                    }
+                    this.db.recalcFolderCounts(folderId);
+                }
+            }
+            return uids;
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
     /** Create a fresh IMAP client for an account (public access for API endpoints) */
     createPublicClient(accountId) {
         return this.createClient(accountId);
@@ -694,16 +729,11 @@ export class ImapManager extends EventEmitter {
         let messages;
         const firstSync = highestUid === 0;
         const historyDays = getHistoryDays(accountId);
-        // IMAP: historyDays=0 (unlimited) is dangerous — "SEARCH SINCE 1970"
-        // asks the server to enumerate every message, which Dovecot times out
-        // on (300s). Cap at 90 days for IMAP. Gmail API handles 0 fine via
-        // pagination. The first-sync cap (30) applies when starting from
-        // scratch so the UI isn't empty for minutes.
-        const isGmail = this.isGmailAccount(accountId);
-        const MAX_IMAP_DAYS = 90;
+        // historyDays=0 means "all". On first sync we still cap at 30 days
+        // so the UI isn't empty for minutes while SEARCH SINCE 1970 runs
+        // through a years-old mailbox. Once we have any local messages, the
+        // backfill below extends the window in 90-day chunks per sync cycle.
         let effectiveDays = historyDays;
-        if (historyDays === 0 && !isGmail)
-            effectiveDays = MAX_IMAP_DAYS;
         if (effectiveDays === 0 && firstSync)
             effectiveDays = 30;
         const startDate = effectiveDays > 0
@@ -747,15 +777,25 @@ export class ImapManager extends EventEmitter {
                     console.error(`  ${folder.path}: gap detection failed: ${e.message}`);
                 }
             }
-            // Backfill: if historyDays extends further back than our oldest message, fetch the gap
+            // Backfill: if the history window reaches further back than our
+            // oldest local message, fetch the gap. Chunk 90 days per sync
+            // cycle so historyDays=0 catches up incrementally instead of
+            // asking Dovecot for SEARCH SINCE 1970 in one go.
             const oldestDate = this.db.getOldestDate(accountId, folderId);
             if (oldestDate > 0 && startDate.getTime() < oldestDate) {
-                const existingUids = new Set(this.db.getUidsForFolder(accountId, folderId));
-                const backfill = await client.fetchMessageByDate(folder.path, startDate, new Date(oldestDate), { source: false });
-                const newBackfill = backfill.filter((m) => !existingUids.has(m.uid));
-                if (newBackfill.length > 0) {
-                    console.log(`  ${folder.path}: backfilling ${newBackfill.length} older messages`);
-                    messages.push(...newBackfill);
+                try {
+                    const CHUNK_MS = 90 * 86400000;
+                    const chunkStart = new Date(Math.max(startDate.getTime(), oldestDate - CHUNK_MS));
+                    const existingUids = new Set(this.db.getUidsForFolder(accountId, folderId));
+                    const backfill = await client.fetchMessageByDate(folder.path, chunkStart, new Date(oldestDate), { source: false });
+                    const newBackfill = backfill.filter((m) => !existingUids.has(m.uid));
+                    if (newBackfill.length > 0) {
+                        console.log(`  ${folder.path}: backfilling ${newBackfill.length} older messages (${chunkStart.toISOString().slice(0, 10)} → ${new Date(oldestDate).toISOString().slice(0, 10)})`);
+                        messages.push(...newBackfill);
+                    }
+                }
+                catch (e) {
+                    console.error(`  ${folder.path}: backfill failed: ${e.message}`);
                 }
             }
         }
@@ -1120,9 +1160,13 @@ export class ImapManager extends EventEmitter {
             // Incremental: fetch messages since last known UID.
             // Gmail "UIDs" are hashed (not chronological), so fetchSince
             // returns messages in hash order — they can be from ANY date.
-            // Filter by the history window so years-old messages don't
-            // suddenly flood the inbox on every incremental sync.
-            messages = await api.fetchSince(folder.path, highestUid, { source: false });
+            // Pass the date window so the provider can page the whole range
+            // (otherwise Gmail's default 200-id cap truncates high-volume
+            // inboxes to ~10 days regardless of historyDays).
+            const fetchOpts = { source: false };
+            if (effectiveDays > 0)
+                fetchOpts.since = startDate;
+            messages = await api.fetchSince(folder.path, highestUid, fetchOpts);
             if (effectiveDays > 0) {
                 const cutoff = startDate.getTime();
                 const before = messages.length;
@@ -1131,6 +1175,29 @@ export class ImapManager extends EventEmitter {
                     console.log(`  [api] ${accountId}/${folder.path}: filtered ${before - messages.length} messages older than ${effectiveDays}d`);
                 }
             }
+            // Backfill: if the history window reaches further back than our
+            // oldest local message, fetch the gap. Mirrors the IMAP path —
+            // otherwise a user who started with historyDays=30 and later
+            // sets it to 0 (or 365) never actually sees older mail. Cap
+            // each sync cycle at 90 days so unlimited-history accounts
+            // catch up incrementally instead of paging the whole mailbox.
+            const oldestDate = this.db.getOldestDate(accountId, folder.id);
+            if (oldestDate > 0 && startDate.getTime() < oldestDate) {
+                try {
+                    const CHUNK_MS = 90 * 86400000;
+                    const chunkStart = new Date(Math.max(startDate.getTime(), oldestDate - CHUNK_MS));
+                    const existingUids = new Set(this.db.getUidsForFolder(accountId, folder.id));
+                    const backfill = await api.fetchByDate(folder.path, chunkStart, new Date(oldestDate), { source: false });
+                    const newBackfill = backfill.filter(m => !existingUids.has(m.uid));
+                    if (newBackfill.length > 0) {
+                        console.log(`  [api] ${accountId}/${folder.path}: backfilling ${newBackfill.length} older messages (${chunkStart.toISOString().slice(0, 10)} → ${new Date(oldestDate).toISOString().slice(0, 10)})`);
+                        messages.push(...newBackfill);
+                    }
+                }
+                catch (e) {
+                    console.error(`  [api] ${accountId}/${folder.path}: backfill failed: ${e.message}`);
+                }
+            }
         }
         else {
             // First sync: fetch by date range

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

@@ -9,7 +9,10 @@ import type { Folder, AutocompleteRequest, AutocompleteResponse, AutocompleteSet
 export declare class MailxService {
     private db;
     private imapManager;
+    private _accountsCache;
     constructor(db: MailxDB, imapManager: ImapManager);
+    /** Return accounts from cache — load once, reuse until configChanged. */
+    private getCachedAccounts;
     getAccounts(): any[];
     getFolders(accountId: string): Folder[];
     getUnifiedInbox(page?: number, pageSize?: number): any;

package/packages/mailx-service/index.js

@@ -74,17 +74,32 @@ async function detectEmailProvider(domain) {
 export class MailxService {
     db;
     imapManager;
+    // Cached accounts — loadSettings() reads from the cloud-mounted
+    // accounts.jsonc, which can stall on a flaky GDrive File Stream.
+    // Refresh on configChanged (fs.watch) so edits still land.
+    _accountsCache = null;
     constructor(db, imapManager) {
         this.db = db;
         this.imapManager = imapManager;
+        // Invalidate account cache when accounts.jsonc changes on disk or GDrive.
+        this.imapManager.on?.("configChanged", (filename) => {
+            if (filename === "accounts.jsonc")
+                this._accountsCache = null;
+        });
+    }
+    /** Return accounts from cache — load once, reuse until configChanged. */
+    getCachedAccounts() {
+        if (!this._accountsCache)
+            this._accountsCache = loadAccounts();
+        return this._accountsCache;
     }
     // ── Accounts ──
     getAccounts() {
         const dbAccounts = this.db.getAccounts();
-        const settings = loadSettings();
+        const cfgs = this.getCachedAccounts();
         // Order by settings (accounts.jsonc is the source of truth for order)
         const ordered = [];
-        for (const cfg of settings.accounts) {
+        for (const cfg of cfgs) {
             const a = dbAccounts.find(d => d.id === cfg.id);
             if (a)
                 ordered.push({ ...a, label: cfg.label, defaultSend: cfg.defaultSend || false, identityDomains: cfg.identityDomains || [], spam: cfg.spam || "" });
@@ -270,11 +285,37 @@ export class MailxService {
     async unsubscribeOneClick(url) {
         if (!/^https:\/\//i.test(url))
             throw new Error("one-click unsubscribe requires an https URL");
-        const resp = await fetch(url, {
+        // RFC 8058 POST with List-Unsubscribe=One-Click body. A User-Agent
+        // header appeases servers that reject anonymous clients as "malformed".
+        const headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "User-Agent": "mailx/1.0 (https://github.com/BobFrankston/mailx)",
+        };
+        let resp = await fetch(url, {
             method: "POST",
-            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            headers,
             body: "List-Unsubscribe=One-Click",
+            redirect: "follow",
         });
+        // Some mailers advertise List-Unsubscribe-Post but their endpoint
+        // actually only handles GET (older RFC 2369 style). Fall back once
+        // on 4xx so the user doesn't have to open the URL manually.
+        if (!resp.ok && resp.status >= 400 && resp.status < 500) {
+            const body = await resp.text().catch(() => "");
+            console.log(`  [unsub] POST ${url} → ${resp.status} ${resp.statusText}; body: ${body.slice(0, 200)}`);
+            try {
+                const fallback = await fetch(url, { method: "GET", headers, redirect: "follow" });
+                if (fallback.ok) {
+                    return { ok: true, status: fallback.status, statusText: `${fallback.statusText} (via GET)` };
+                }
+                const fbody = await fallback.text().catch(() => "");
+                console.log(`  [unsub] GET ${url} → ${fallback.status} ${fallback.statusText}; body: ${fbody.slice(0, 200)}`);
+                // Surface the server's own error so the UI shows the real reason.
+                return { ok: false, status: fallback.status, statusText: (fbody.trim().split("\n")[0] || fallback.statusText).slice(0, 200) };
+            }
+            catch { /* fall through to POST error */ }
+            return { ok: false, status: resp.status, statusText: (body.trim().split("\n")[0] || resp.statusText).slice(0, 200) };
+        }
         return { ok: resp.ok, status: resp.status, statusText: resp.statusText };
     }
     async updateFlags(accountId, uid, flags) {
@@ -301,11 +342,8 @@ export class MailxService {
     async search(q, page = 1, pageSize = 50, scope = "all", accountId, folderId) {
         if (!q.trim())
             return { items: [], total: 0, page, pageSize };
-        if (scope === "server" && accountId) {
-            const folders = this.db.getFolders(accountId);
-            const folder = folderId ? folders.find(f => f.id === folderId) : folders.find(f => f.specialUse === "inbox");
-            if (!folder)
-                return { items: [], total: 0, page, pageSize };
+        if (scope === "server") {
+            // Parse qualifiers once; SEARCH runs per folder.
             const criteria = {};
             const fromMatch = q.match(/from:(\S+)/i);
             const toMatch = q.match(/to:(\S+)/i);
@@ -319,11 +357,41 @@ export class MailxService {
                 criteria.subject = subjectMatch[1].trim();
             if (bodyText)
                 criteria.body = bodyText;
-            const uids = await this.imapManager.searchOnServer(accountId, folder.path, criteria);
-            const items = uids.slice((page - 1) * pageSize, page * pageSize)
-                .map(uid => this.db.getMessageByUid(accountId, uid, folderId))
-                .filter(Boolean);
-            return { items, total: uids.length, page, pageSize };
+            // Server search spans every selectable folder on every enabled
+            // account — otherwise a message that got moved / was in Sent /
+            // only exists in an archive folder silently fails to turn up.
+            // Each folder runs as its own SEARCH; we dedupe by messageId.
+            const dbAccounts = accountId
+                ? [{ id: accountId }]
+                : this.db.getAccounts();
+            const seen = new Set();
+            const items = [];
+            let total = 0;
+            for (const acct of dbAccounts) {
+                const folders = this.db.getFolders(acct.id)
+                    .filter((f) => !(f.flags || []).some((x) => /noselect/i.test(x)));
+                const results = await Promise.allSettled(folders.map(f => this.imapManager.searchAndFetchOnServer(acct.id, f.id, f.path, criteria)
+                    .then(uids => ({ folderId: f.id, uids }))));
+                for (const r of results) {
+                    if (r.status !== "fulfilled")
+                        continue;
+                    for (const uid of r.value.uids) {
+                        const msg = this.db.getMessageByUid(acct.id, uid, r.value.folderId);
+                        if (!msg)
+                            continue;
+                        const key = msg.messageId || `${acct.id}:${r.value.folderId}:${uid}`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        items.push(msg);
+                        total++;
+                    }
+                }
+            }
+            // Newest first, then paginate.
+            items.sort((a, b) => (b.date?.getTime?.() || 0) - (a.date?.getTime?.() || 0));
+            const sliced = items.slice((page - 1) * pageSize, page * pageSize);
+            return { items: sliced, total, page, pageSize };
         }
         else if (scope === "current" && accountId && folderId) {
             return this.db.searchMessages(q, page, pageSize, accountId, folderId);
@@ -368,8 +436,17 @@ export class MailxService {
     }
     // ── Send ──
     async send(msg) {
-        const settings = loadSettings();
-        const account = settings.accounts.find(a => a.id === msg.from);
+        // Local-first: the critical path is validate → build raw → queue
+        // locally. Everything else (contacts recording, IMAP APPEND,
+        // SMTP) happens after the IPC ACK. Settings come from cache so
+        // a stalled GDrive mount doesn't block the send.
+        const accounts = this.getCachedAccounts();
+        let account = accounts.find(a => a.id === msg.from);
+        if (!account) {
+            // Cache miss — invalidate and try one authoritative read.
+            this._accountsCache = null;
+            account = this.getCachedAccounts().find(a => a.id === msg.from);
+        }
         if (!account)
             throw new Error(`Unknown account: ${msg.from}`);
         // Vet every recipient address — refuse to send if any field contains a
@@ -456,14 +533,23 @@ export class MailxService {
         }
         this.imapManager.queueOutgoingLocal(account.id, rawMessage);
         console.log(`  Queued locally: ${msg.subject} via ${account.id} from ${fromHeader}`);
-        for (const addr of msg.to)
-            this.db.recordSentAddress(addr.name, addr.address);
-        if (msg.cc)
-            for (const addr of msg.cc)
-                this.db.recordSentAddress(addr.name, addr.address);
-        if (msg.bcc)
-            for (const addr of msg.bcc)
-                this.db.recordSentAddress(addr.name, addr.address);
+        // Contacts recording is off the critical path — deferred until after
+        // the IPC ACK so a slow DB write can't stall the send.
+        setImmediate(() => {
+            try {
+                for (const addr of msg.to)
+                    this.db.recordSentAddress(addr.name, addr.address);
+                if (msg.cc)
+                    for (const addr of msg.cc)
+                        this.db.recordSentAddress(addr.name, addr.address);
+                if (msg.bcc)
+                    for (const addr of msg.bcc)
+                        this.db.recordSentAddress(addr.name, addr.address);
+            }
+            catch (e) {
+                console.error(`  recordSentAddress failed: ${e?.message || e}`);
+            }
+        });
     }
     // ── Delete / Move / Undelete ──
     async deleteMessage(accountId, uid) {

package/packages/mailx-settings/index.js

@@ -440,11 +440,23 @@ export function loadAccounts() {
     if (!accounts)
         accounts = readJsonc(localPath);
     if (accounts?.accounts || Array.isArray(accounts)) {
-        // Cache shared to local for offline fallback
+        // Cache shared to local for offline fallback — but ONLY if the
+        // content actually differs. Unconditionally writing on every load
+        // retriggers fs.watch on the local copy, which fires the config-
+        // changed banner and cloud-poll cycle even when nothing changed.
+        // Result: "accounts.jsonc changed" notification firing constantly.
         if (sharedDir !== LOCAL_DIR && fs.existsSync(sharedPath)) {
             try {
-                fs.mkdirSync(LOCAL_DIR, { recursive: true });
-                fs.writeFileSync(localPath, fs.readFileSync(sharedPath, "utf-8"));
+                const sharedContent = fs.readFileSync(sharedPath, "utf-8");
+                let localContent = "";
+                try {
+                    localContent = fs.readFileSync(localPath, "utf-8");
+                }
+                catch { /* missing */ }
+                if (sharedContent !== localContent) {
+                    fs.mkdirSync(LOCAL_DIR, { recursive: true });
+                    fs.writeFileSync(localPath, sharedContent);
+                }
             }
             catch { /* ignore */ }
         }