npm - @bobfrankston/mailx - Versions diffs - 1.0.244 → 1.0.246 - Mend

@bobfrankston/mailx 1.0.244 → 1.0.246

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 (10) hide show

package/client/.msger-window.json +1 -1
package/client/app.js +6 -2
package/client/components/message-viewer.js +9 -1
package/package.json +7 -7
package/packages/mailx-imap/index.d.ts +10 -5
package/packages/mailx-imap/index.js +58 -49
package/packages/mailx-imap/providers/gmail-api.js +24 -5
package/packages/mailx-store-web/android-bootstrap.js +7 -0
package/packages/mailx-store-web/imap-web-provider.d.ts +9 -0
package/packages/mailx-store-web/imap-web-provider.js +45 -8

package/client/.msger-window.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"height":1344,"width":2151,"x":~~419~~,"y":~~152~~}
1	+ {"height":1344,"width":2151,"x":736,"y":147}

package/client/app.js CHANGED Viewed

@@ -221,9 +221,12 @@ document.getElementById("btn-back")?.addEventListener("click", () => {
     document.getElementById("message-list")?.classList.remove("narrow-hidden");
 });
 // Close folder panel when a folder is selected (narrow mode)
+// Also reset narrow navigation: show message list, hide viewer
 document.getElementById("folder-tree")?.addEventListener("click", (e) => {
     if (window.innerWidth <= 768 && e.target.closest(".ft-folder")) {
         document.querySelector(".folder-panel")?.classList.remove("open");
+        document.getElementById("message-viewer")?.classList.remove("narrow-active");
+        document.getElementById("message-list")?.classList.remove("narrow-hidden");
     }
 });
 // Close folder overlay when user clicks outside it (narrow mode OR
@@ -755,10 +758,11 @@ window.addEventListener("message", (e) => {
     if (e.data?.type === "linkClick" && e.data.url) {
         const url = e.data.url;
         if (window.mailxapi?.platform === "android") {
-            // Android: use a hidden iframe to trigger OnNavigating which opens in Chrome
+            // Android: use mailxapi:// bridge scheme — OnNavigating intercepts it
+            // and opens in system browser. Raw http:// in sub-frames doesn't trigger OnNavigating.
             const f = document.createElement("iframe");
             f.style.display = "none";
-            f.src = url;
+            f.src = `mailxapi://openurl?url=${encodeURIComponent(url)}`;
             document.body.appendChild(f);
             setTimeout(() => f.remove(), 500);
         }

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

@@ -540,13 +540,21 @@ document.addEventListener("mouseover", e => {
     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 => {
+// Listen for both click and touchend since click may not fire on some Android WebViews
+function handleLinkTap(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 }, "*");
+}
+document.addEventListener("click", handleLinkTap, true);
+let lastTouchTarget = null;
+document.addEventListener("touchstart", e => { lastTouchTarget = e.target; }, true);
+document.addEventListener("touchend", e => {
+    if (lastTouchTarget && lastTouchTarget === e.target) handleLinkTap(e);
+    lastTouchTarget = null;
 }, true);
 </script>
 </head><body>${html}</body></html>`;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.244",
+  "version": "1.0.246",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,11 +20,11 @@
     "postinstall": "node bin/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow-direct": "^0.1.12",
-    "@bobfrankston/iflow-node": "^0.1.2",
+    "@bobfrankston/iflow-direct": "^0.1.13",
+    "@bobfrankston/iflow-node": "^0.1.3",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.22",
-    "@bobfrankston/msger": "^0.1.306",
+    "@bobfrankston/msger": "^0.1.307",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -74,11 +74,11 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/iflow-direct": "^0.1.12",
-      "@bobfrankston/iflow-node": "^0.1.2",
+      "@bobfrankston/iflow-direct": "^0.1.13",
+      "@bobfrankston/iflow-node": "^0.1.3",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.22",
-      "@bobfrankston/msger": "^0.1.306",
+      "@bobfrankston/msger": "^0.1.307",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

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

@@ -103,14 +103,19 @@ export declare class ImapManager extends EventEmitter {
     private handleSyncError;
     /** Sync just INBOX for each account (fast check for new mail) */
     syncInbox(): Promise<void>;
-    /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
-     *  If message count changed, triggers inbox sync for that account. */
-    private lastInboxCounts;
+    /** Quick inbox check — per-account lightweight probe.
+     *  If the probe value changed since last time, triggers an inbox sync.
+     *  The marker is only advanced after a successful sync so that a failed
+     *  sync doesn't eat the "new mail" signal and make us stop retrying. */
+    private lastInboxMarker;
     private quickCheckRunning;
+    /** Shared quick-check skeleton: probe → compare → sync-if-changed → advance marker.
+     *  `probe` returns the current marker value; `sync` runs only when it differs
+     *  from the previously stored value. Marker is advanced only after sync resolves. */
+    private quickCheck;
     /** Check a single account's inbox — uses its own connection, never blocked by sync */
     quickInboxCheckAccount(accountId: string): Promise<void>;
-    /** Quick Gmail inbox check — one lightweight API call to check for new messages */
-    private lastGmailInboxTop;
+    private quickImapCheck;
     private quickGmailCheck;
     /** Check all accounts (used by legacy callers) */
     quickInboxCheck(): Promise<void>;

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

@@ -1139,39 +1139,61 @@ export class ImapManager extends EventEmitter {
             this.inboxSyncing = false;
         }
     }
-    /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
-     *  If message count changed, triggers inbox sync for that account. */
-    lastInboxCounts = new Map();
+    /** Quick inbox check — per-account lightweight probe.
+     *  If the probe value changed since last time, triggers an inbox sync.
+     *  The marker is only advanced after a successful sync so that a failed
+     *  sync doesn't eat the "new mail" signal and make us stop retrying. */
+    lastInboxMarker = new Map();
     quickCheckRunning = new Set(); // per-account guard
-    /** Check a single account's inbox — uses its own connection, never blocked by sync */
-    async quickInboxCheckAccount(accountId) {
+    /** Shared quick-check skeleton: probe → compare → sync-if-changed → advance marker.
+     *  `probe` returns the current marker value; `sync` runs only when it differs
+     *  from the previously stored value. Marker is advanced only after sync resolves. */
+    async quickCheck(accountId, probe, sync) {
         if (this.quickCheckRunning.has(accountId))
             return;
         if (this.reauthenticating.has(accountId))
             return;
-        if (this.isGmailAccount(accountId)) {
-            return this.quickGmailCheck(accountId);
-        }
         this.quickCheckRunning.add(accountId);
-        let client = null;
         try {
-            const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
-            if (!inbox)
+            const current = await probe();
+            if (current === null || current === "")
                 return;
-            client = this.newClient(accountId);
-            const count = await client.getMessagesCount("INBOX");
-            const prev = this.lastInboxCounts.get(accountId) ?? count;
-            this.lastInboxCounts.set(accountId, count);
-            if (count !== prev) {
-                console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
-                await this.syncFolder(accountId, inbox.id, client);
+            const prev = this.lastInboxMarker.get(accountId);
+            if (prev === undefined || current !== prev) {
+                await sync(current, prev);
             }
-            await client.logout();
-            client = null;
+            // Only advance after sync succeeds — a thrown error skips this line
+            // and the next tick will see the same delta and retry.
+            this.lastInboxMarker.set(accountId, current);
         }
         catch {
             // Lightweight check — silently ignore errors
         }
+        finally {
+            this.quickCheckRunning.delete(accountId);
+        }
+    }
+    /** Check a single account's inbox — uses its own connection, never blocked by sync */
+    async quickInboxCheckAccount(accountId) {
+        if (this.isGmailAccount(accountId))
+            return this.quickGmailCheck(accountId);
+        return this.quickImapCheck(accountId);
+    }
+    async quickImapCheck(accountId) {
+        const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+        if (!inbox)
+            return;
+        let client = null;
+        try {
+            await this.quickCheck(accountId, async () => {
+                client = this.newClient(accountId);
+                return await client.getMessagesCount("INBOX");
+            }, async (count, prev) => {
+                if (prev !== undefined)
+                    console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
+                await this.syncFolder(accountId, inbox.id, client);
+            });
+        }
         finally {
             if (client) {
                 try {
@@ -1179,44 +1201,31 @@ export class ImapManager extends EventEmitter {
                 }
                 catch { /* */ }
             }
-            this.quickCheckRunning.delete(accountId);
         }
     }
-    /** Quick Gmail inbox check — one lightweight API call to check for new messages */
-    lastGmailInboxTop = new Map();
     async quickGmailCheck(accountId) {
-        if (this.quickCheckRunning.has(accountId))
+        const config = this.configs.get(accountId);
+        if (!config?.tokenProvider)
             return;
-        this.quickCheckRunning.add(accountId);
-        try {
-            const config = this.configs.get(accountId);
-            if (!config?.tokenProvider)
-                return;
+        const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+        if (!inbox)
+            return;
+        await this.quickCheck(accountId, async () => {
             const token = await config.tokenProvider();
-            // Single API call: get just the first message ID
             const res = await globalThis.fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages?q=in:inbox&maxResults=1`, { headers: { "Authorization": `Bearer ${token}` } });
             if (!res.ok)
-                return;
+                return null;
             const data = await res.json();
-            const topId = data.messages?.[0]?.id || "";
-            const prev = this.lastGmailInboxTop.get(accountId) ?? topId;
-            this.lastGmailInboxTop.set(accountId, topId);
-            if (topId && topId !== prev) {
+            return data.messages?.[0]?.id || null;
+        }, async (_topId, prev) => {
+            if (prev !== undefined)
                 console.log(`  [check] ${accountId} INBOX: new message detected`);
-                const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
-                if (inbox) {
-                    const api = this.getGmailProvider(accountId);
-                    await this.syncFolderViaApi(accountId, inbox, api);
-                    this.db.recalcFolderCounts(inbox.id);
-                    this.emit("folderCountsChanged", accountId, {});
-                    await api.close();
-                }
-            }
-        }
-        catch { /* lightweight — ignore errors */ }
-        finally {
-            this.quickCheckRunning.delete(accountId);
-        }
+            const api = this.getGmailProvider(accountId);
+            await this.syncFolderViaApi(accountId, inbox, api);
+            this.db.recalcFolderCounts(inbox.id);
+            this.emit("folderCountsChanged", accountId, {});
+            await api.close();
+        });
     }
     /** Check all accounts (used by legacy callers) */
     async quickInboxCheck() {

package/packages/mailx-imap/providers/gmail-api.js CHANGED Viewed

@@ -45,7 +45,11 @@ export class GmailApiProvider {
     }
     async fetch(path, options = {}) {
         const token = await this.tokenProvider();
-        for (let attempt = 0; attempt < 3; attempt++) {
+        const maxAttempts = 6;
+        const baseDelayMs = 1000;
+        const maxDelayMs = 60_000;
+        let lastStatus = 0;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
             const res = await globalThis.fetch(`${API}${path}`, {
                 ...options,
                 headers: {
@@ -55,9 +59,24 @@ export class GmailApiProvider {
                 },
             });
             if (res.status === 429 || res.status >= 500) {
-                // Rate limited or server error — back off and retry
-                const delay = (attempt + 1) * 2000;
-                console.log(`  [gmail] ${res.status} error, waiting ${delay / 1000}s...`);
+                lastStatus = res.status;
+                // Honor Retry-After if present (seconds or HTTP-date)
+                const retryAfter = res.headers.get("Retry-After");
+                let delay = baseDelayMs * Math.pow(2, attempt);
+                if (retryAfter) {
+                    const asInt = parseInt(retryAfter, 10);
+                    if (!isNaN(asInt))
+                        delay = asInt * 1000;
+                    else {
+                        const when = Date.parse(retryAfter);
+                        if (!isNaN(when))
+                            delay = Math.max(0, when - Date.now());
+                    }
+                }
+                // Full jitter to avoid synchronized retries
+                delay = Math.min(maxDelayMs, delay);
+                delay = Math.floor(delay * (0.5 + Math.random() * 0.5));
+                console.log(`  [gmail] ${res.status} (attempt ${attempt + 1}/${maxAttempts}), waiting ${(delay / 1000).toFixed(1)}s${retryAfter ? ` (Retry-After: ${retryAfter})` : ""}...`);
                 await new Promise(r => setTimeout(r, delay));
                 continue;
             }
@@ -67,7 +86,7 @@ export class GmailApiProvider {
             }
             return res.json();
         }
-        throw new Error("Gmail API: failed after 3 retries");
+        throw new Error(`Gmail API: failed after ${maxAttempts} retries (last status ${lastStatus})`);
     }
     async listFolders() {
         const data = await this.fetch("/labels");

package/packages/mailx-store-web/android-bootstrap.js CHANGED Viewed

@@ -618,6 +618,13 @@ export async function initAndroid() {
     setTimeout(() => {
         syncManager.syncAll().catch(e => console.error(`[android] Sync error: ${e.message}`));
     }, 1000);
+    // Periodic re-sync every 2 minutes (no IDLE on Android, so poll)
+    const SYNC_INTERVAL_MS = 2 * 60 * 1000;
+    setInterval(() => {
+        console.log("[sync] periodic poll");
+        vlog("periodic sync poll");
+        syncManager.syncAll().catch(e => console.error(`[android] Periodic sync error: ${e.message}`));
+    }, SYNC_INTERVAL_MS);
     console.log("[android] Initialization complete");
     emitEvent({ type: "connected" });
 }

package/packages/mailx-store-web/imap-web-provider.d.ts CHANGED Viewed

@@ -5,14 +5,23 @@
  * The native shell (MAUI) exposes TCP via window._nativeBridge.tcp.*; we alias it
  * to window.msgapi in initAndroid() because iflow-direct's BridgeTransport expects
  * that global name.
+ *
+ * Includes automatic retry on broken pipe / connection errors: if an operation fails
+ * with a connection-related error, we create a fresh client and retry once.
  */
 import { type ImapClientConfig } from "@bobfrankston/iflow-direct";
 import type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "./provider-types.js";
 export declare class ImapWebProvider implements MailProvider {
     private client;
+    private config;
+    private transportFactory;
     private specialFolders;
     private folderListCache;
     constructor(config: ImapClientConfig);
+    /** Create a fresh client (after broken pipe / connection error) */
+    private reconnect;
+    /** Run an operation with one retry on connection error */
+    private withRetry;
     listFolders(): Promise<ProviderFolder[]>;
     fetchSince(folder: string, sinceUid: number, options?: FetchOptions): Promise<ProviderMessage[]>;
     fetchByDate(folder: string, since: Date, before: Date, options?: FetchOptions, onChunk?: (msgs: ProviderMessage[]) => void): Promise<ProviderMessage[]>;

package/packages/mailx-store-web/imap-web-provider.js CHANGED Viewed

@@ -5,6 +5,9 @@
  * The native shell (MAUI) exposes TCP via window._nativeBridge.tcp.*; we alias it
  * to window.msgapi in initAndroid() because iflow-direct's BridgeTransport expects
  * that global name.
+ *
+ * Includes automatic retry on broken pipe / connection errors: if an operation fails
+ * with a connection-related error, we create a fresh client and retry once.
  */
 import { CompatImapClient, BridgeTransport } from "@bobfrankston/iflow-direct";
 /**
@@ -54,16 +57,50 @@ function toProviderMessage(m) {
         source: m.source || "",
     };
 }
+/** Check if an error is a connection/broken-pipe error worth retrying */
+function isConnectionError(e) {
+    const msg = (e?.message || "").toLowerCase();
+    return msg.includes("broken pipe") || msg.includes("not connected") ||
+        msg.includes("connection") || msg.includes("socket") ||
+        msg.includes("timeout") || msg.includes("econnreset") ||
+        msg.includes("epipe") || msg.includes("closed");
+}
 export class ImapWebProvider {
     client;
+    config;
+    transportFactory;
     specialFolders = {};
     folderListCache = null;
     constructor(config) {
-        const transportFactory = () => new BridgeTransport();
-        this.client = new CompatImapClient(config, transportFactory);
+        this.config = config;
+        this.transportFactory = () => new BridgeTransport();
+        this.client = new CompatImapClient(config, this.transportFactory);
+    }
+    /** Create a fresh client (after broken pipe / connection error) */
+    reconnect() {
+        console.log("[imap-web] reconnecting after connection error");
+        try {
+            this.client.logout();
+        }
+        catch { /* ignore */ }
+        this.client = new CompatImapClient(this.config, this.transportFactory);
+    }
+    /** Run an operation with one retry on connection error */
+    async withRetry(op, label) {
+        try {
+            return await op();
+        }
+        catch (e) {
+            if (isConnectionError(e)) {
+                console.warn(`[imap-web] ${label}: ${e.message} — reconnecting and retrying`);
+                this.reconnect();
+                return await op();
+            }
+            throw e;
+        }
     }
     async listFolders() {
-        const native = await this.client.getFolderList();
+        const native = await this.withRetry(() => this.client.getFolderList(), "listFolders");
         const special = this.client.getSpecialFolders(native);
         this.specialFolders = special;
         const result = native.map(f => toProviderFolder(f, this.specialFolders));
@@ -71,27 +108,27 @@ export class ImapWebProvider {
         return result;
     }
     async fetchSince(folder, sinceUid, options) {
-        const msgs = await this.client.fetchMessagesSinceUid(folder, sinceUid, { source: !!options?.source });
+        const msgs = await this.withRetry(() => this.client.fetchMessagesSinceUid(folder, sinceUid, { source: !!options?.source }), `fetchSince(${folder})`);
         return msgs.map(toProviderMessage);
     }
     async fetchByDate(folder, since, before, options, onChunk) {
         const wrappedChunk = onChunk ? (raw) => onChunk(raw.map(toProviderMessage)) : undefined;
-        const msgs = await this.client.fetchMessageByDate(folder, since, before, { source: !!options?.source }, wrappedChunk);
+        const msgs = await this.withRetry(() => this.client.fetchMessageByDate(folder, since, before, { source: !!options?.source }, wrappedChunk), `fetchByDate(${folder})`);
         return msgs.map(toProviderMessage);
     }
     async fetchByUids(folder, uids, options) {
         if (!uids.length)
             return [];
         const range = uids.join(",");
-        const msgs = await this.client.fetchMessages(folder, range, { source: !!options?.source });
+        const msgs = await this.withRetry(() => this.client.fetchMessages(folder, range, { source: !!options?.source }), `fetchByUids(${folder})`);
         return msgs.map(toProviderMessage);
     }
     async fetchOne(folder, uid, options) {
-        const msg = await this.client.fetchMessageByUid(folder, uid, { source: !!options?.source });
+        const msg = await this.withRetry(() => this.client.fetchMessageByUid(folder, uid, { source: !!options?.source }), `fetchOne(${folder}/${uid})`);
         return msg ? toProviderMessage(msg) : null;
     }
     async getUids(folder) {
-        return this.client.getUids(folder);
+        return this.withRetry(() => this.client.getUids(folder), `getUids(${folder})`);
     }
     async close() {
         try {