@bobfrankston/mailx 1.0.338 → 1.0.339

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.338",
+  "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,11 +3066,9 @@ 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]+$/, "");
+        // 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;