@bobfrankston/mailx 1.0.327 → 1.0.336

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/compose/compose.js

@@ -80,6 +80,45 @@ await loadEditorAssets(editorType);
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
 const editor = await createEditor(container, editorType);
+// Ctrl+scroll / Ctrl+= / Ctrl+- / Ctrl+0 zoom for the compose editor body.
+// Persists per-session in localStorage so zoom survives window pop/close cycles.
+(() => {
+    const STORAGE_KEY = "mailx.compose.zoom";
+    const MIN = 0.5, MAX = 3, STEP = 0.1;
+    let zoom = parseFloat(localStorage.getItem(STORAGE_KEY) || "1") || 1;
+    const applyZoom = () => {
+        container.style.fontSize = `${zoom}em`;
+        localStorage.setItem(STORAGE_KEY, String(zoom));
+    };
+    applyZoom();
+    container.addEventListener("wheel", (e) => {
+        if (!e.ctrlKey)
+            return;
+        e.preventDefault();
+        const delta = e.deltaY < 0 ? STEP : -STEP;
+        zoom = Math.min(MAX, Math.max(MIN, Math.round((zoom + delta) * 10) / 10));
+        applyZoom();
+    }, { passive: false });
+    document.addEventListener("keydown", (e) => {
+        if (!(e.ctrlKey || e.metaKey))
+            return;
+        if (e.key === "=" || e.key === "+") {
+            zoom = Math.min(MAX, zoom + STEP);
+            applyZoom();
+            e.preventDefault();
+        }
+        else if (e.key === "-") {
+            zoom = Math.max(MIN, zoom - STEP);
+            applyZoom();
+            e.preventDefault();
+        }
+        else if (e.key === "0") {
+            zoom = 1;
+            applyZoom();
+            e.preventDefault();
+        }
+    });
+})();
 // ── Populate from init data ──
 // From field is a free-text input with a <datalist> of known accounts. The
 // user can pick a preset or type an arbitrary "Name <addr@domain>" — no

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.336",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -39,7 +39,7 @@
     "@bobfrankston/tcp-transport": "^0.1.4",
     "@bobfrankston/node-tcp-transport": "^0.1.4",
     "@bobfrankston/smtp-direct": "^0.1.4",
-    "@bobfrankston/mailx-sync": "^0.1.7"
+    "@bobfrankston/mailx-sync": "^0.1.8"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6"
@@ -103,7 +103,7 @@
       "@bobfrankston/tcp-transport": "^0.1.4",
       "@bobfrankston/node-tcp-transport": "^0.1.4",
       "@bobfrankston/smtp-direct": "^0.1.4",
-      "@bobfrankston/mailx-sync": "^0.1.7"
+      "@bobfrankston/mailx-sync": "^0.1.8"
     }
   }
 }

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 */
@@ -183,7 +187,11 @@ export declare class ImapManager extends EventEmitter {
         uid: number;
         folderId: number;
     }[]): Promise<void>;
-    /** Bulk move messages — local-first, single IMAP connection for all */
+    /** Bulk move messages — queues the IMAP action only. The service layer
+     *  (MailxService.moveMessages) owns the local DB mutation via
+     *  updateMessageFolder; this method used to ALSO deleteMessage here,
+     *  which wiped the row the service just updated — the message vanished
+     *  on the next reconcile and "spam folder empty" was the symptom. */
     moveMessages(accountId: string, messages: {
         uid: number;
         folderId: number;
@@ -193,7 +201,8 @@ export declare class ImapManager extends EventEmitter {
     private debounceSyncActions;
     /** Move a message to Trash (delete) — local-first, queues IMAP sync */
     trashMessage(accountId: string, folderId: number, uid: number): Promise<void>;
-    /** Move a message between folders — local-first, queues IMAP sync */
+    /** Move a message between folders — queues IMAP sync only. Service
+     *  layer owns the local DB update (see MailxService.moveMessage). */
     moveMessage(accountId: string, uid: number, fromFolderId: number, toFolderId: number): Promise<void>;
     /** Move message across accounts using iflow's moveMessageToServer */
     moveMessageCrossAccount(fromAccountId: string, uid: number, fromFolderId: number, toAccountId: string, toFolderId: number): Promise<void>;
@@ -214,7 +223,13 @@ export declare class ImapManager extends EventEmitter {
      *  Tries the specific UID first, then falls back to searchByHeader so orphaned copies
      *  from earlier failed autosaves are cleaned up at the same time. */
     deleteDraft(accountId: string, draftUid: number, draftId?: string): Promise<void>;
-    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP */
+    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP.
+     *  Single path: write `~/.mailx/outbox/<acct>/*.ltr` synchronously, then
+     *  kick processLocalQueue. The file IS the queue — durable across crashes,
+     *  visible in the filesystem, consumed by the existing outbox worker that
+     *  handles both IMAP-APPEND (non-Gmail) and direct SMTP (Gmail). The old
+     *  sync_actions "send" branch was removed because it duplicated the same
+     *  work and risked double-send when both paths fired on the same message. */
     queueOutgoingLocal(accountId: string, rawMessage: string): void;
     /** Guard against concurrent processSendActions for the same account */
     private sendingAccounts;

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
@@ -1985,27 +2052,18 @@ export class ImapManager extends EventEmitter {
         // Process all queued actions in one IMAP session
         this.debounceSyncActions(accountId);
     }
-    /** Bulk move messages — local-first, single IMAP connection for all */
+    /** Bulk move messages — queues the IMAP action only. The service layer
+     *  (MailxService.moveMessages) owns the local DB mutation via
+     *  updateMessageFolder; this method used to ALSO deleteMessage here,
+     *  which wiped the row the service just updated — the message vanished
+     *  on the next reconcile and "spam folder empty" was the symptom. */
     async moveMessages(accountId, messages, targetFolderId) {
         if (messages.length === 0)
             return;
-        // Local first
-        for (const msg of messages) {
-            this.db.deleteMessage(accountId, msg.uid);
-        }
-        console.log(`  Moved ${messages.length} messages locally (→ folder ${targetFolderId})`);
-        // Queue IMAP actions
         for (const msg of messages) {
             this.db.queueSyncAction(accountId, "move", msg.uid, msg.folderId, { targetFolderId });
         }
-        // Recalc folder counts (source folders + destination) so the tree
-        // badge updates immediately.
-        const sourceFolderIds = new Set(messages.map(m => m.folderId));
-        for (const fid of sourceFolderIds)
-            this.db.recalcFolderCounts(fid);
-        this.db.recalcFolderCounts(targetFolderId);
-        this.emit("folderCountsChanged", accountId, {});
-        // Process all queued actions in one IMAP session
+        console.log(`  [move] ${accountId}: queued IMAP MOVE for ${messages.length} message(s) → folder ${targetFolderId}`);
         this.debounceSyncActions(accountId);
     }
     /** Debounced sync actions — batches rapid local changes into one IMAP operation */
@@ -2025,25 +2083,25 @@ export class ImapManager extends EventEmitter {
         // Local first — remove from DB immediately
         this.db.deleteMessage(accountId, uid);
         this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
-        console.log(`  Deleted message UID ${uid} locally`);
-        // Queue IMAP action
+        // Queue IMAP action + log the resolution so "I deleted a message and
+        // now it's in neither trash nor deleted" is diagnosable from the log.
         if (trash && trash.id !== folderId) {
+            const trashFolder = this.db.getFolders(accountId).find(f => f.id === trash.id);
             this.db.queueSyncAction(accountId, "move", uid, folderId, { targetFolderId: trash.id });
+            console.log(`  [trash] ${accountId} UID ${uid}: queued MOVE to "${trashFolder?.path || trash.path}" (id=${trash.id}, specialUse=trash)`);
         }
         else {
             this.db.queueSyncAction(accountId, "delete", uid, folderId);
+            console.log(`  [trash] ${accountId} UID ${uid}: queued EXPUNGE in folder ${folderId} (already in trash or no trash configured)`);
         }
         // Debounced sync — batches multiple deletes into one IMAP session
         this.debounceSyncActions(accountId);
     }
-    /** Move a message between folders — local-first, queues IMAP sync */
+    /** Move a message between folders — queues IMAP sync only. Service
+     *  layer owns the local DB update (see MailxService.moveMessage). */
     async moveMessage(accountId, uid, fromFolderId, toFolderId) {
-        // Local first
-        this.db.deleteMessage(accountId, uid);
-        console.log(`  Moved UID ${uid} locally (folder ${fromFolderId} → ${toFolderId})`);
-        // Queue IMAP action
         this.db.queueSyncAction(accountId, "move", uid, fromFolderId, { targetFolderId: toFolderId });
-        // Debounced sync — batches multiple moves into one IMAP session
+        console.log(`  [move] ${accountId}: queued IMAP MOVE UID ${uid} folder ${fromFolderId} → ${toFolderId}`);
         this.debounceSyncActions(accountId);
     }
     /** Move message across accounts using iflow's moveMessageToServer */
@@ -2154,13 +2212,26 @@ export class ImapManager extends EventEmitter {
                             break;
                         case "move": {
                             const target = folders.find(f => f.id === action.targetFolderId);
-                            if (target) {
-                                const msg = await client.fetchMessageByUid(folder.path, action.uid, { source: false });
-                                if (msg) {
-                                    await client.moveMessage(msg, folder.path, target.path);
-                                    console.log(`  [sync] Moved UID ${action.uid}: ${folder.path} → ${target.path}`);
-                                }
+                            if (!target) {
+                                // Target folder gone — treat as permanent failure so the
+                                // action doesn't loop forever. User must re-delete manually.
+                                console.error(`  [sync] Move target folder ${action.targetFolderId} missing — dropping action UID ${action.uid}`);
+                                throw new Error(`move target folder ${action.targetFolderId} not found`);
                             }
+                            const msg = await client.fetchMessageByUid(folder.path, action.uid, { source: false });
+                            if (!msg) {
+                                // Message no longer in source folder. Two real cases:
+                                //   (a) another client already moved/deleted it — nothing to do,
+                                //       just mark the action done.
+                                //   (b) the server is lying (transient SELECT miss) — the retry
+                                //       will pick it up. We can't tell these apart from one fetch,
+                                //       so log loud and treat as (a) after the first failure; the
+                                //       attempts counter handles (b) via the failSyncAction path.
+                                console.log(`  [sync] Move UID ${action.uid} in ${folder.path}: message gone (attempt ${action.attempts + 1}); dropping action`);
+                                break;
+                            }
+                            await client.moveMessage(msg, folder.path, target.path);
+                            console.log(`  [sync] Moved UID ${action.uid}: ${folder.path} → ${target.path}`);
                             break;
                         }
                         case "flags":
@@ -2342,13 +2413,23 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
-    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP */
+    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP.
+     *  Single path: write `~/.mailx/outbox/<acct>/*.ltr` synchronously, then
+     *  kick processLocalQueue. The file IS the queue — durable across crashes,
+     *  visible in the filesystem, consumed by the existing outbox worker that
+     *  handles both IMAP-APPEND (non-Gmail) and direct SMTP (Gmail). The old
+     *  sync_actions "send" branch was removed because it duplicated the same
+     *  work and risked double-send when both paths fired on the same message. */
     queueOutgoingLocal(accountId, rawMessage) {
-        // Use folderId=0 and uid=Date.now() as placeholder — the worker will handle the real IMAP append
-        this.db.queueSyncAction(accountId, "send", Date.now(), 0, { rawMessage });
-        console.log(`  [outbox] Queued locally for ${accountId}`);
-        // Try immediate processing
-        this.processSendActions(accountId).catch(() => { });
+        const outboxDir = path.join(getConfigDir(), "outbox", accountId);
+        fs.mkdirSync(outboxDir, { recursive: true });
+        const now = new Date();
+        const pad2 = (n) => String(n).padStart(2, "0");
+        const filename = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}-${String(Math.floor(Math.random() * 10000)).padStart(4, "0")}.ltr`;
+        const filePath = path.join(outboxDir, filename);
+        fs.writeFileSync(filePath, rawMessage);
+        console.log(`  [outbox] Queued ${filePath}`);
+        this.processLocalQueue(accountId).catch((e) => console.error(`  [outbox] processLocalQueue error: ${e?.message || e}`));
     }
     /** Guard against concurrent processSendActions for the same account */
     sendingAccounts = new Set();

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 */ }
         }