@bobfrankston/mailx 1.0.333 → 1.0.338

package/client/app.js

@@ -482,27 +482,15 @@ document.getElementById("btn-factory-reset")?.addEventListener("click", async ()
 });
 async function openCompose(mode) {
     const current = getCurrentMessage();
-    // Reply / Reply-All / Forward all need an original message to populate
-    // From, To, Subject, and the quoted body. Two failure modes used to
-    // silently produce a blank compose:
-    //   (1) getCurrentMessage() returns null — viewer still loading, message
-    //       cleared mid-folder-switch, or fetch failed.
-    //   (2) currentMessage is set but is a stub — header metadata arrived
-    //       but body / from / subject haven't been populated yet.
-    // Bail out in both cases instead of opening an empty form.
-    if (mode === "reply" || mode === "replyAll" || mode === "forward") {
-        const m = current?.message;
-        const stubReason = !current ? "no current message" :
-            !m?.from ? "msg.from missing" :
-                !m?.subject && m?.subject !== "" ? "msg.subject missing" :
-                    (mode !== "forward" && !m?.messageId) ? "msg.messageId missing (can't thread reply)" :
-                        null;
-        if (stubReason) {
-            console.warn(`[compose] ${mode} ignored — ${stubReason}; current=`, current);
-            alert(`Cannot ${mode === "forward" ? "forward" : "reply to"} this message yet — ` +
-                `it's still loading (${stubReason}). Please wait a moment and try again.`);
-            return;
-        }
+    // Local-first: if the row is selected we already have its headers in the
+    // local DB. Populate the compose form unconditionally; the user can edit
+    // anything missing. Don't show "still loading" alerts — the message IS
+    // loaded (it's in the list), body is a separate fetch that isn't needed
+    // for Reply's headers. Missing fields become empty strings.
+    if ((mode === "reply" || mode === "replyAll" || mode === "forward") && !current) {
+        // Only true blocker: no message selected at all.
+        console.warn(`[compose] ${mode} — no message selected`);
+        return;
     }
     const accounts = await getAccounts();
     const accountId = current?.accountId || accounts[0]?.id || "";
@@ -554,21 +542,31 @@ async function openCompose(mode) {
         console.log(`[compose] no identity match`);
         return undefined;
     }
+    // Defensive: msg.from / msg.to may be missing on rows that arrived before
+    // headers finished loading. Don't push undefined into init.to — that
+    // bubbles to the compose form as literal "undefined". Empty-out gracefully.
     if (msg && mode === "reply") {
-        init.to = [msg.from];
+        init.to = msg.from ? [msg.from] : [];
         init.subject = `Re: ${cleanSubject}`;
         init.bodyHtml = quoteBody(msg);
-        init.inReplyTo = msg.messageId;
-        init.references = [...(msg.references || []), msg.messageId];
+        init.inReplyTo = msg.messageId || "";
+        init.references = [...(msg.references || []), msg.messageId].filter(Boolean);
         init.fromAddress = detectReplyFrom();
     }
     else if (msg && mode === "replyAll") {
-        init.to = [msg.from, ...msg.to.filter((a) => a.address !== msg.from.address)];
-        init.cc = msg.cc || [];
+        const toList = msg.from ? [msg.from] : [];
+        if (Array.isArray(msg.to)) {
+            for (const a of msg.to) {
+                if (a?.address && a.address !== msg.from?.address)
+                    toList.push(a);
+            }
+        }
+        init.to = toList;
+        init.cc = Array.isArray(msg.cc) ? msg.cc : [];
         init.subject = `Re: ${cleanSubject}`;
         init.bodyHtml = quoteBody(msg);
-        init.inReplyTo = msg.messageId;
-        init.references = [...(msg.references || []), msg.messageId];
+        init.inReplyTo = msg.messageId || "";
+        init.references = [...(msg.references || []), msg.messageId].filter(Boolean);
         init.fromAddress = detectReplyFrom();
     }
     else if (msg && mode === "forward") {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.333",
+  "version": "1.0.338",
   "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

@@ -187,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;
@@ -197,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>;
@@ -218,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

@@ -2052,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 */
@@ -2092,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 */
@@ -2221,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":
@@ -2409,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();
@@ -2985,10 +2999,17 @@ export class ImapManager extends EventEmitter {
         // config.jsonc is per-machine / local-only — never polled.
         const cloudFiles = ["accounts.jsonc", "allowlist.jsonc", "clients.jsonc"];
         const CLOUD_POLL_MS = 3 * 60 * 1000;
+        // Normalize before comparing: strip BOM, CRLF→LF, trailing whitespace.
+        // Without this, cloud round-trips that re-wrap newlines or add a
+        // trailing newline trigger a local overwrite every poll, which fires
+        // fs.watch, which shows the spurious "accounts.jsonc changed" banner.
+        const normalize = (s) => s.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/[ \t\r\n]+$/, "");
         const pollCloud = async () => {
             let cloudRead;
+            let parseJsonc;
             try {
                 ({ cloudRead } = await import("@bobfrankston/mailx-settings"));
+                ({ parseJsonc } = await import("jsonc-parser").then(m => ({ parseJsonc: m.parse })));
             }
             catch {
                 return; /* cloud module unavailable */
@@ -3004,17 +3025,25 @@ export class ImapManager extends EventEmitter {
                         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.
+                    if (localContent !== null) {
+                        if (normalize(localContent) === normalize(cloudContent))
+                            continue;
+                        // Semantic check: parse both as JSONC and compare structures.
+                        // Catches reorderings that normalize() doesn't (e.g. JSON with
+                        // same keys in different order after a cloud-side re-serialize).
+                        try {
+                            const a = parseJsonc(localContent);
+                            const b = parseJsonc(cloudContent);
+                            if (a !== undefined && b !== undefined &&
+                                JSON.stringify(a) === JSON.stringify(b))
+                                continue;
+                        }
+                        catch { /* fall through to write */ }
+                    }
                     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}`);
                 }
             }

package/packages/mailx-settings/index.js

@@ -453,7 +453,11 @@ export function loadAccounts() {
                     localContent = fs.readFileSync(localPath, "utf-8");
                 }
                 catch { /* missing */ }
-                if (sharedContent !== localContent) {
+                // Normalize before comparing — GDrive-mounted copies often
+                // differ in BOM / line endings / trailing newline without any
+                // semantic change, and that triggered the spurious banner.
+                const norm = (s) => s.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/[ \t\r\n]+$/, "");
+                if (norm(sharedContent) !== norm(localContent)) {
                     fs.mkdirSync(LOCAL_DIR, { recursive: true });
                     fs.writeFileSync(localPath, sharedContent);
                 }