@bobfrankston/mailx 1.0.409 → 1.0.413

package/client/components/message-viewer.js

@@ -373,8 +373,8 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
             if (anyUrl) {
                 unsubBtn.hidden = false;
                 unsubBtn.textContent = oneClick && httpUrl ? "Unsubscribe (1-click)" : "Unsubscribe";
-                unsubBtn.title = anyUrl;
-                unsubBtn.href = "#";
+                unsubBtn.removeAttribute("title");
+                unsubBtn.href = httpUrl || mailUrl || "#";
                 unsubBtn.onclick = async (e) => {
                     e.preventDefault();
                     const status = document.getElementById("status-sync");

package/package.json

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

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

@@ -177,6 +177,12 @@ export declare class ImapManager extends EventEmitter {
     private reconnectOps;
     /** Handle sync errors — classify and emit appropriate UI events */
     private handleSyncError;
+    /** Fetch ONLY new messages above highestUid for one account's INBOX —
+     *  the IDLE callback's hot path. Skips gap detection, backfill, and the
+     *  server reconcile (each of which fetches a full UID list — multi-second
+     *  on a large mailbox). The 5-minute STATUS poll path still runs full
+     *  `syncFolder` so deletions and gaps eventually reconcile. */
+    syncInboxNewOnly(accountId: string): Promise<void>;
     /** Sync just INBOX for each account (fast check for new mail) */
     syncInbox(): Promise<void>;
     /** Quick inbox check — per-account lightweight probe.

package/packages/mailx-imap/index.js

@@ -1540,6 +1540,46 @@ export class ImapManager extends EventEmitter {
             this.emit("accountError", accountId, errMsg, errMsg, isOAuth);
         }
     }
+    /** Fetch ONLY new messages above highestUid for one account's INBOX —
+     *  the IDLE callback's hot path. Skips gap detection, backfill, and the
+     *  server reconcile (each of which fetches a full UID list — multi-second
+     *  on a large mailbox). The 5-minute STATUS poll path still runs full
+     *  `syncFolder` so deletions and gaps eventually reconcile. */
+    async syncInboxNewOnly(accountId) {
+        if (this.isGmailAccount(accountId))
+            return; // IDLE is IMAP-only
+        const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+        if (!inbox)
+            return;
+        try {
+            await this.withConnection(accountId, async (client) => {
+                const highestUid = this.db.getHighestUid(accountId, inbox.id);
+                if (highestUid === 0) {
+                    // First sync — fall through to full path so the date-windowed
+                    // backfill runs. `syncFolder` handles the no-highestUid case.
+                    await this.syncFolder(accountId, inbox.id, client);
+                    return;
+                }
+                const fetched = await client.fetchMessagesSinceUid(inbox.path, highestUid, { source: false });
+                const fresh = fetched.filter((m) => m.uid > highestUid);
+                if (fresh.length === 0)
+                    return;
+                const stored = await this.storeMessages(accountId, inbox.id, inbox, fresh, highestUid);
+                if (stored > 0) {
+                    this.db.recalcFolderCounts(inbox.id);
+                    const updated = this.db.getFolders(accountId).find(f => f.id === inbox.id);
+                    this.emit("folderCountsChanged", accountId, {
+                        [inbox.id]: { total: updated?.totalCount || 0, unread: updated?.unreadCount || 0 }
+                    });
+                    this.emit("folderSynced", accountId, inbox.id, Date.now());
+                    console.log(`  [idle-fast] ${accountId}: stored ${stored} new message(s)`);
+                }
+            });
+        }
+        catch (e) {
+            console.error(`  [idle-fast] ${accountId}: ${e.message}`);
+        }
+    }
     /** Sync just INBOX for each account (fast check for new mail) */
     async syncInbox() {
         if (this.inboxSyncing)
@@ -1783,8 +1823,10 @@ export class ImapManager extends EventEmitter {
                 const watchClient = this.createClient(accountId);
                 const stop = await watchClient.watchMailbox("INBOX", (newCount) => {
                     console.log(`  [idle] ${accountId}: ${newCount} new message(s)`);
-                    // Sync just INBOX for speed — full sync runs on the configured interval
-                    this.syncInbox().catch(e => console.error(`  [idle] sync error: ${e.message}`));
+                    // Fetch only the new UIDs — the heavyweight gap/reconcile
+                    // path runs on the 5-minute STATUS poll, so EXISTS lands
+                    // in the UI in roughly one round-trip.
+                    this.syncInboxNewOnly(accountId).catch(e => console.error(`  [idle] sync error: ${e.message}`));
                 });
                 this.watchers.set(accountId, async () => {
                     await stop();

package/packages/mailx-service/index.js

@@ -278,11 +278,12 @@ export class MailxService {
                 parseListUnsubscribe(parsed2.headers));
             listUnsubscribe = listUnsubscribeHttp || listUnsubscribeMail;
         }
-        // EML path: read the real on-disk path from `envelope.bodyPath` (DB
-        // is authoritative since v1.0.361 — files are opaque UUIDs, not the
-        // old {folderId}/{uid}.eml layout). Synthesizing the legacy path
-        // here showed users a path that doesn't exist.
-        const emlPath = envelope.bodyPath || "";
+        // EML path: re-read the row after the fetch — `fetchMessageBody`
+        // writes the body to disk and updates `body_path` on success, but the
+        // `envelope` snapshot above pre-dates that write, so trusting it
+        // hides the Source button on every just-opened message.
+        const refreshed = this.db.getMessageByUid(accountId, uid, folderId);
+        const emlPath = refreshed?.bodyPath || envelope.bodyPath || "";
         return {
             ...envelope, bodyHtml, bodyText, hasRemoteContent, remoteAllowed: allowRemote,
             attachments, emlPath, deliveredTo, returnPath,