npm - @bobfrankston/mailx - Versions diffs - 1.0.235 → 1.0.237 - Mend

@bobfrankston/mailx 1.0.235 → 1.0.237

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/client/components/message-viewer.js +17 -1
package/package.json +3 -3
package/packages/mailx-imap/index.d.ts +9 -2
package/packages/mailx-imap/index.js +71 -11
package/packages/mailx-service/index.js +15 -2

package/client/components/message-viewer.js CHANGED Viewed

@@ -458,7 +458,14 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
     catch (e) {
         const err = e.message || "Unknown error";
         console.error("showMessage error:", e);
-        // Don't retry on "not found" or known errors — only on connection issues
+        // "Message was deleted from the server" — the service already dropped
+        // the local row. Remove it from the list so the UI advances to the next
+        // message instead of sitting on a stale error banner.
+        const isDeleted = /deleted from the server|isNotFound/.test(err);
+        if (isDeleted) {
+            state.removeMessages([{ accountId, uid }]);
+            return;
+        }
         const isNotFound = err.includes("not found") || err.includes("Not Found") || err.includes("404");
         if (!isNotFound && retryCount < 3) {
             retryCount++;
@@ -532,6 +539,15 @@ document.addEventListener("mouseover", e => {
     const a = e.target.closest("a[href]");
     window.parent.postMessage({ type: "linkHover", url: a ? a.href : "" }, "*");
 });
+// Intercept link clicks — Android WebView silently drops window.open, so forward to parent
+document.addEventListener("click", e => {
+    const a = e.target.closest("a[href]");
+    if (!a) return;
+    const url = a.href;
+    if (!url || url.startsWith("javascript:") || url.startsWith("#")) return;
+    e.preventDefault();
+    window.parent.postMessage({ type: "linkClick", url: url }, "*");
+}, true);
 </script>
 </head><body>${html}</body></html>`;
 }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.235",
+  "version": "1.0.237",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.2",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.22",
-    "@bobfrankston/msger": "^0.1.297",
+    "@bobfrankston/msger": "^0.1.299",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -78,7 +78,7 @@
       "@bobfrankston/iflow-node": "^0.1.2",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.22",
-      "@bobfrankston/msger": "^0.1.297",
+      "@bobfrankston/msger": "^0.1.299",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

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

@@ -132,9 +132,16 @@ export declare class ImapManager extends EventEmitter {
     /** Fetch a single message body on demand, caching in the store.
      *  Uses its own fresh connection — never blocked by background prefetch. */
     fetchMessageBody(accountId: string, folderId: number, uid: number): Promise<Buffer | null>;
-    /** Fetch message body via Gmail/Outlook API */
+    /** Fetch message body via Gmail/Outlook API.
+     *  Throws `MessageNotFoundError` when the server says the message is gone
+     *  (deleted from another device, for example). The caller uses that to
+     *  delete the stale row locally instead of showing a generic error. */
     private fetchMessageBodyViaApi;
-    /** Background body prefetch — download bodies for messages that don't have them */
+    /** Background body prefetch — download bodies for messages that don't have them.
+     *  Server-side deletions (isNotFound) aren't errors here: we delete the
+     *  stale row locally and keep going. Only unrelated errors (network,
+     *  auth, rate limits) count against the error budget, and the budget is
+     *  generous so a few transient failures don't kill the whole run. */
     private prefetchBodies;
     /** Get the body store for direct access */
     getBodyStore(): FileMessageStore;

package/packages/mailx-imap/index.js CHANGED Viewed

@@ -42,6 +42,15 @@ function insertHeaderBeforeBody(raw, line) {
     const nl = m[0].startsWith("\r\n") ? "\r\n" : "\n";
     return raw.slice(0, m.index) + nl + line + raw.slice(m.index);
 }
+/** Error thrown when a message body can't be fetched because the server says
+ *  the message is gone (deleted from another device, expunged, etc.). The
+ *  caller uses this to remove the stale local row instead of showing a
+ *  generic "fetch failed" error to the user. */
+function makeNotFoundError(accountId, folderId, uid) {
+    const err = new Error(`Message ${accountId}/${folderId}/${uid} not found on server`);
+    err.isNotFound = true;
+    return err;
+}
 /** Extract full error detail with provenance */
 function imapError(err) {
     const msg = err.message || err.reason || err.code || (typeof err === "string" ? err : "");
@@ -1332,7 +1341,12 @@ export class ImapManager extends EventEmitter {
             const msg = await client.fetchMessageByUid(folder.path, uid, { source: true });
             await client.logout();
             client = null;
-            if (!msg?.source)
+            if (!msg) {
+                // IMAP server says the UID is gone — message was deleted
+                // elsewhere. Raise NotFound so the caller can remove the row.
+                throw makeNotFoundError(accountId, folderId, uid);
+            }
+            if (!msg.source)
                 return null;
             const raw = Buffer.from(msg.source, "utf-8");
             const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
@@ -1340,6 +1354,15 @@ export class ImapManager extends EventEmitter {
             return raw;
         }
         catch (e) {
+            if (e?.isNotFound) {
+                if (client) {
+                    try {
+                        await client.logout();
+                    }
+                    catch { /* */ }
+                }
+                throw e;
+            }
             console.error(`  Body fetch error (${accountId}/${uid}): ${e.message}`);
             if (client) {
                 try {
@@ -1350,13 +1373,20 @@ export class ImapManager extends EventEmitter {
             return null;
         }
     }
-    /** Fetch message body via Gmail/Outlook API */
+    /** Fetch message body via Gmail/Outlook API.
+     *  Throws `MessageNotFoundError` when the server says the message is gone
+     *  (deleted from another device, for example). The caller uses that to
+     *  delete the stale row locally instead of showing a generic error. */
     async fetchMessageBodyViaApi(accountId, folderId, uid, folderPath) {
         try {
             const api = this.getGmailProvider(accountId);
             const msg = await api.fetchOne(folderPath, uid, { source: true });
             await api.close();
-            if (!msg?.source)
+            if (!msg) {
+                // fetchOne returned null — message doesn't exist on the server anymore
+                throw makeNotFoundError(accountId, folderId, uid);
+            }
+            if (!msg.source)
                 return null;
             const raw = Buffer.from(msg.source, "utf-8");
             const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
@@ -1364,38 +1394,68 @@ export class ImapManager extends EventEmitter {
             return raw;
         }
         catch (e) {
+            // Gmail API 404 → the message was deleted on the server
+            if (e?.isNotFound || /Gmail API 404|404|not found/i.test(e?.message || "")) {
+                throw makeNotFoundError(accountId, folderId, uid);
+            }
             console.error(`  [api] Body fetch error (${accountId}/${uid}): ${e.message}`);
             return null;
         }
     }
-    /** Background body prefetch — download bodies for messages that don't have them */
+    /** Background body prefetch — download bodies for messages that don't have them.
+     *  Server-side deletions (isNotFound) aren't errors here: we delete the
+     *  stale row locally and keep going. Only unrelated errors (network,
+     *  auth, rate limits) count against the error budget, and the budget is
+     *  generous so a few transient failures don't kill the whole run. */
     async prefetchBodies(accountId) {
-        // Fetch ALL missing bodies in one pass — don't wait for next sync cycle
         let totalFetched = 0;
+        let deleted = 0;
         let errors = 0;
+        const ERROR_BUDGET = 20;
         while (true) {
             const missing = this.db.getMessagesWithoutBody(accountId, 100);
             if (missing.length === 0)
                 break;
-            if (totalFetched === 0)
+            if (totalFetched === 0 && deleted === 0)
                 console.log(`  [prefetch] ${accountId}: ${missing.length}+ bodies to fetch`);
+            let madeProgress = false;
             for (const msg of missing) {
                 try {
                     const result = await this.fetchMessageBody(accountId, msg.folderId, msg.uid);
-                    if (result)
+                    if (result) {
                         totalFetched++;
+                        madeProgress = true;
+                    }
                 }
                 catch (e) {
+                    if (e?.isNotFound) {
+                        // Message deleted on the server — drop the stale row so
+                        // we stop re-asking. This also moves the loop forward
+                        // (next getMessagesWithoutBody call won't return it).
+                        try {
+                            this.db.deleteMessage(accountId, msg.uid);
+                            this.bodyStore.deleteMessage(accountId, msg.folderId, msg.uid).catch(() => { });
+                            deleted++;
+                            madeProgress = true;
+                        }
+                        catch { /* ignore */ }
+                        continue;
+                    }
                     errors++;
-                    if (errors >= 3) {
-                        console.error(`  [prefetch] ${accountId}: stopping after ${errors} errors (${totalFetched} cached)`);
+                    if (errors >= ERROR_BUDGET) {
+                        console.error(`  [prefetch] ${accountId}: stopping after ${errors} errors (${totalFetched} cached, ${deleted} pruned)`);
                         return;
                     }
                 }
             }
+            // Safety: if we made zero progress this iteration, bail — otherwise
+            // we'd loop forever on rows that keep failing without isNotFound.
+            if (!madeProgress)
+                break;
+        }
+        if (totalFetched > 0 || deleted > 0) {
+            console.log(`  [prefetch] ${accountId}: ${totalFetched} bodies cached, ${deleted} stale rows pruned (done)`);
         }
-        if (totalFetched > 0)
-            console.log(`  [prefetch] ${accountId}: ${totalFetched} bodies cached (done)`);
     }
     /** Get the body store for direct access */
     getBodyStore() {

package/packages/mailx-service/index.js CHANGED Viewed

@@ -141,13 +141,26 @@ export class MailxService {
             raw = await this.imapManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
         }
         catch (fetchErr) {
+            // Message was deleted from the server (another device, expunge, etc.) —
+            // drop the stale local row so the UI removes it instead of showing a
+            // confusing error. Throwing a tagged error lets the client react.
+            if (fetchErr?.isNotFound) {
+                try {
+                    this.db.deleteMessage(accountId, envelope.uid);
+                    this.db.recalcFolderCounts(envelope.folderId);
+                }
+                catch { /* ignore */ }
+                const err = new Error("Message was deleted from the server");
+                err.isNotFound = true;
+                throw err;
+            }
             return {
-                ...envelope, bodyHtml: "", bodyText: `[Message body unavailable: ${fetchErr.message || "IMAP connection failed"}]`,
+                ...envelope, bodyHtml: "", bodyText: `[Message body unavailable: ${fetchErr.message || "connection failed"}]`,
                 hasRemoteContent: false, remoteAllowed: false, attachments: [], emlPath: "", deliveredTo: "", returnPath: "", listUnsubscribe: ""
             };
         }
         if (!raw) {
-            bodyText = "[Message body not available — not cached locally and IMAP fetch failed. Try again or re-sync the folder.]";
+            bodyText = "[Message body not cached locally and the server fetch returned nothing. Try re-syncing the folder.]";
         }
         else {
             const parsed = await simpleParser(raw);