@bobfrankston/mailx 1.0.336 → 1.0.339

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

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

package/packages/mailx-host/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-host",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Host abstraction for mailx — dispatches to msger or msgview",
   "type": "module",
   "main": "index.js",

package/packages/mailx-host/types-shim.d.ts

@@ -0,0 +1,14 @@
+// Stub for `marked` — pulled in transitively via msger → msgcommon → markdown.ts.
+// mailx-host doesn't use marked at runtime; the type chain only references it
+// because msgcommon ships markdown.ts alongside its other modules. Without
+// this shim, tsc errors with "Cannot find module 'marked'" while building
+// mailx-host. The proper fix is `npm install` inside msgcommon (which has
+// marked declared as a dep) or installing marked at the mailx root; this
+// shim is a fallback so the build doesn't block on either.
+declare module "marked" {
+    export const marked: {
+        parse(input: string, opts?: any): string | Promise<string>;
+        Renderer: any;
+        [k: string]: any;
+    };
+}

package/packages/mailx-imap/index.js

@@ -1640,10 +1640,42 @@ export class ImapManager extends EventEmitter {
         // "gmail: 17266796 bodies cached" in the logs, which is the counter
         // spinning on the same 100 rows.
         if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
-            const existingPath = this.bodyStore.getMessagePath?.(accountId, folderId, uid);
-            if (existingPath)
-                this.db.updateBodyPath(accountId, uid, existingPath);
-            return this.bodyStore.getMessage(accountId, folderId, uid);
+            // COMINGLING GUARD: verify the cached body's Message-ID matches the
+            // DB row's messageId. If UIDVALIDITY changed server-side (mailbox
+            // recreated, server quirk) the same integer UID can point at a
+            // different message — the on-disk .eml becomes stale but hasMessage()
+            // still returns true. User-reported: "Peter Hoddie letter comingled
+            // with a much older letter." Check fixes it regardless of root cause.
+            const cached = await this.bodyStore.getMessage(accountId, folderId, uid);
+            const envelope = this.db.getMessageByUid(accountId, uid, folderId);
+            const expectedId = envelope?.messageId || "";
+            if (expectedId) {
+                // Scan headers only — Message-ID should land in the first few KB.
+                const head = cached.subarray(0, Math.min(cached.length, 16 * 1024)).toString("utf-8");
+                const m = head.match(/^Message-ID:\s*<([^>\r\n]+)>/im);
+                const cachedId = m ? `<${m[1]}>` : "";
+                if (cachedId && expectedId && cachedId !== expectedId) {
+                    console.error(`  [body] COMINGLING DETECTED ${accountId}/${folderId}/${uid}: expected ${expectedId}, cached ${cachedId} — dropping cache, re-fetching`);
+                    try {
+                        await this.bodyStore.deleteMessage(accountId, folderId, uid);
+                    }
+                    catch { /* */ }
+                    // fall through to re-fetch path
+                }
+                else {
+                    const existingPath = this.bodyStore.getMessagePath?.(accountId, folderId, uid);
+                    if (existingPath)
+                        this.db.updateBodyPath(accountId, uid, existingPath);
+                    return cached;
+                }
+            }
+            else {
+                // No messageId on the DB row (shouldn't happen but be permissive).
+                const existingPath = this.bodyStore.getMessagePath?.(accountId, folderId, uid);
+                if (existingPath)
+                    this.db.updateBodyPath(accountId, uid, existingPath);
+                return cached;
+            }
         }
         if (!this.configs.has(accountId))
             return null;
@@ -2969,10 +3001,20 @@ export class ImapManager extends EventEmitter {
         const files = ["accounts.jsonc", "allowlist.jsonc", "clients.jsonc", "config.jsonc"];
         const configDir = getConfigDir();
         const debounce = new Map();
+        // Cache the last-seen normalized content per file. fs.watch fires on
+        // metadata-only events (atime, attrib change) AND on no-op rewrites
+        // that land identical bytes — both would fire a spurious banner.
+        // Compare after the debounce window and only emit on a real change.
+        const normalize = (s) => s.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/[ \t\r\n]+$/, "");
+        const lastContent = new Map();
         for (const filename of files) {
             const full = path.join(configDir, filename);
             if (!fs.existsSync(full))
                 continue;
+            try {
+                lastContent.set(filename, normalize(fs.readFileSync(full, "utf-8")));
+            }
+            catch { /* */ }
             try {
                 const watcher = fs.watch(full, () => {
                     const prev = debounce.get(filename);
@@ -2980,7 +3022,32 @@ export class ImapManager extends EventEmitter {
                         clearTimeout(prev);
                     debounce.set(filename, setTimeout(() => {
                         debounce.delete(filename);
-                        console.log(`  [watch] ${filename} changed`);
+                        let current = "";
+                        try {
+                            current = normalize(fs.readFileSync(full, "utf-8"));
+                        }
+                        catch { /* missing */ }
+                        const previous = lastContent.get(filename) || "";
+                        if (current === previous) {
+                            console.log(`  [watch] ${filename} fs.watch fired but content unchanged — no banner`);
+                            return;
+                        }
+                        // Log a short diff hint so repeat-firings are diagnosable.
+                        const prevSize = previous.length;
+                        const curSize = current.length;
+                        const firstDiff = (() => {
+                            const n = Math.min(prevSize, curSize);
+                            for (let i = 0; i < n; i++)
+                                if (previous[i] !== current[i])
+                                    return i;
+                            return n;
+                        })();
+                        const prevSnip = previous.slice(Math.max(0, firstDiff - 20), firstDiff + 40).replace(/\n/g, "\\n");
+                        const curSnip = current.slice(Math.max(0, firstDiff - 20), firstDiff + 40).replace(/\n/g, "\\n");
+                        console.log(`  [watch] ${filename} changed: size ${prevSize}→${curSize}, first diff at byte ${firstDiff}`);
+                        console.log(`  [watch]   was: ${JSON.stringify(prevSnip)}`);
+                        console.log(`  [watch]   now: ${JSON.stringify(curSnip)}`);
+                        lastContent.set(filename, current);
                         this.emit("configChanged", filename);
                     }, 500));
                 });
@@ -2999,10 +3066,15 @@ 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() reused from the fs.watch block above — same intent:
+        // cloud round-trips that re-wrap newlines / add a trailing newline are
+        // semantically identical; don't overwrite local on those.
         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 */
@@ -3018,17 +3090,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);
                 }