@bobfrankston/mailx-imap 0.1.43 → 0.1.45

package/index.d.ts

@@ -67,6 +67,11 @@ export declare class ImapManager extends EventEmitter {
     private accountErrorShown;
     private syncing;
     private inboxSyncing;
+    /** Wall-clock of ImapManager construction. Used by the lazy-folder-sync
+     *  gate so non-priority folders defer their first-sync until ~3 min
+     *  past startup, when the event loop has quieted down. Each restart
+     *  resets this; the gate auto-lifts as time passes. */
+    private _startupAt;
     /** Use native IMAP client instead of imapflow. Set to true to enable. */
     useNativeClient: boolean;
     /** Per-account health counters. Incremented when the server misbehaves
@@ -374,45 +379,8 @@ export declare class ImapManager extends EventEmitter {
     private _prefetchBodies;
     /** Get the body store for direct access */
     getBodyStore(): FileMessageStore;
-    /** Bulk trash messages — local-first, single IMAP connection for all */
-    trashMessages(accountId: string, messages: {
-        uid: number;
-        folderId: number;
-    }[]): Promise<void>;
-    /** Bulk move messages — queues the IMAP action only. The service layer
-     *  (MailxService.moveMessages) owns the local DB mutation via
-     *  updateMessageFolder; this method used to ALSO deleteMessage here,
-     *  which wiped the row the service just updated — the message vanished
-     *  on the next reconcile and "spam folder empty" was the symptom. */
-    moveMessages(accountId: string, messages: {
-        uid: number;
-        folderId: number;
-    }[], targetFolderId: number): Promise<void>;
-    /** Debounced sync actions — batches rapid local changes into one IMAP operation */
-    private syncActionTimers;
-    private debounceSyncActions;
-    /** Move a message to Trash (delete) — local-first, queues IMAP sync */
-    trashMessage(accountId: string, folderId: number, uid: number): Promise<void>;
-    /** Move a message between folders — queues IMAP sync only. Service
-     *  layer owns the local DB update (see MailxService.moveMessage). */
-    moveMessage(accountId: string, uid: number, fromFolderId: number, toFolderId: number): Promise<void>;
     /** Move message across accounts using iflow's moveMessageToServer */
     moveMessageCrossAccount(fromAccountId: string, uid: number, fromFolderId: number, toAccountId: string, toFolderId: number): Promise<void>;
-    /** Undelete — move from Trash back to original folder. Local-first:
-     *  the row was moved (not deleted) on trash, so we just move it back
-     *  in the local DB and reconcile the IMAP queue. Two cases:
-     *    (a) the to-trash MOVE is still pending — cancel it; the server
-     *        never saw the delete, so no counter-action is needed.
-     *    (b) the to-trash MOVE drained — the message is now in Trash on
-     *        the server with a new uid. Queue a counter-move from
-     *        trash → original. The IMAP processor's fetchByUid in trash
-     *        will use the local membership uid (which the reconciler
-     *        rebound to the server's new trash uid via Message-ID match).
-     *        If reconcile hasn't run yet (unlikely race), action retries
-     *        until it does. */
-    undeleteMessage(accountId: string, uid: number, originalFolderId: number): Promise<void>;
-    /** Update flags — local-first, queues IMAP sync */
-    updateFlagsLocal(accountId: string, uid: number, folderId: number, flags: string[]): Promise<void>;
     /** Process pending sync actions for an account */
     processSyncActions(accountId: string): Promise<void>;
     /** Find a folder by specialUse, case-insensitive */

package/index.js

@@ -5,7 +5,7 @@
  */
 import { createAutoImapConfig, CompatImapClient } from "@bobfrankston/iflow-direct";
 import { authenticateOAuth } from "@bobfrankston/oauthsupport";
-import { FileMessageStore, parseSerial } from "@bobfrankston/mailx-store";
+import { FileMessageStore, parseSerial, storeBus } from "@bobfrankston/mailx-store";
 import { loadSettings, getStorePath, getConfigDir, getHistoryDays, getPrefetch } from "@bobfrankston/mailx-settings";
 import { EventEmitter } from "node:events";
 import * as fs from "node:fs";
@@ -142,6 +142,11 @@ export class ImapManager extends EventEmitter {
     accountErrorShown = new Set();
     syncing = false;
     inboxSyncing = false;
+    /** Wall-clock of ImapManager construction. Used by the lazy-folder-sync
+     *  gate so non-priority folders defer their first-sync until ~3 min
+     *  past startup, when the event loop has quieted down. Each restart
+     *  resets this; the gate auto-lifts as time passes. */
+    _startupAt = Date.now();
     /** Use native IMAP client instead of imapflow. Set to true to enable. */
     useNativeClient = false;
     // Connection management: see withConnection() below.
@@ -211,6 +216,22 @@ export class ImapManager extends EventEmitter {
                 console.log(`  [reconcile-cancel] ${info.accountId} ${info.fromFolderId}/${info.fromUid}: deferred delete cancelled (move-detect rebound to ${info.toFolderId}/${info.toUid})`);
             }
         });
+        // Bridge legacy EventEmitter "folderCountsChanged" to the Store bus
+        // so subscribers can listen on a single mechanism. Done in-class
+        // rather than at every call site (~20 emit points in this file) to
+        // keep the diff small and avoid a per-call regression risk during
+        // the refactor. The Store bus is the long-term home; once every
+        // consumer subscribes via the bus, the legacy listeners in
+        // bin/mailx.ts get retired and the `this.emit("folderCountsChanged"...)`
+        // calls can convert in bulk.
+        this.on("folderCountsChanged", (accountId, payload) => {
+            storeBus.publish({
+                topic: `account:${accountId}`,
+                kind: "folderCountsChanged",
+                accountId,
+                folderId: payload?.folderId,
+            });
+        });
     }
     /** Get OAuth access token for an account (for SMTP auth) */
     async getOAuthToken(accountId) {
@@ -1716,12 +1737,37 @@ export class ImapManager extends EventEmitter {
             // timeout abandons a stalled command instead of waiting out
             // Dovecot's 300s server-side inactivity timer; the next sync tick
             // retries on a fresh socket.
-            const remaining = folders.filter(f => f.specialUse !== "inbox");
+            // 2026-05-13: defer first-sync of non-priority folders by default
+            // (C119 lazy folder sync). On bobma with 90+ folders, doing a
+            // first-sync of every folder on every startup hammers the IMAP
+            // socket buffer and pegs the daemon's event loop processing
+            // FETCH literals — user clicks get a 20+ second IPC delay
+            // because no IPC can squeeze in between FETCH chunks. Now: only
+            // special-use folders (Sent/Drafts/Archive/Junk/Trash) + folders
+            // mailx has previously seen (highestUid > 0, i.e. tracked
+            // across the prior session) sync automatically. First-sync of
+            // a "never-touched" non-special folder is deferred until the
+            // user opens that folder (on-demand syncFolder call) or until
+            // ~3 minutes after startup when the event loop is quiet.
+            const STARTUP_LAZY_DELAY_MS = 3 * 60 * 1000;
+            const startupQuietPoint = (this._startupAt || 0) + STARTUP_LAZY_DELAY_MS;
+            const isLazyEligible = (f) => {
+                if (f.specialUse && priorityOrder.includes(f.specialUse))
+                    return false;
+                if (this.db.getHighestUid(accountId, f.id) > 0)
+                    return false;
+                return true;
+            };
+            const remaining = folders.filter(f => f.specialUse !== "inbox" && !(isLazyEligible(f) && Date.now() < startupQuietPoint));
             remaining.sort((a, b) => {
                 const pa = priorityOrder.indexOf(a.specialUse || "") >= 0 ? priorityOrder.indexOf(a.specialUse || "") : 5;
                 const pb = priorityOrder.indexOf(b.specialUse || "") >= 0 ? priorityOrder.indexOf(b.specialUse || "") : 5;
                 return pa - pb;
             });
+            const deferredCount = folders.filter(f => f.specialUse !== "inbox" && isLazyEligible(f) && Date.now() < startupQuietPoint).length;
+            if (deferredCount > 0) {
+                console.log(`  [sync] ${accountId}: deferring first-sync of ${deferredCount} non-priority folder(s) until ${new Date(startupQuietPoint).toLocaleTimeString()} or user opens them`);
+            }
             const CONCURRENCY = 2;
             // First-sync of a fresh account on a cold Dovecot is dominated by
             // `UID SEARCH SINCE 30-days-ago`, which can take 5+ minutes on a
@@ -2898,131 +2944,6 @@ export class ImapManager extends EventEmitter {
     getBodyStore() {
         return this.bodyStore;
     }
-    /** Bulk trash messages — local-first, single IMAP connection for all */
-    async trashMessages(accountId, messages) {
-        if (messages.length === 0)
-            return;
-        const trash = this.findFolder(accountId, "trash");
-        // Tombstone each Message-ID so sync won't re-import the source-folder
-        // row before the server-side MOVE completes. Cleared on permanent
-        // failure (clearTombstoneForUid in processSyncActions).
-        for (const msg of messages) {
-            const env = this.db.getMessageByUid(accountId, msg.uid, msg.folderId);
-            if (env?.messageId)
-                this.db.addTombstone(accountId, env.messageId, env.subject || "");
-        }
-        // Local first — move to trash folder locally so the row stays
-        // visible in Trash and Ctrl+Z can restore it. Body file stays in
-        // its original folder dir; the next sync rebinds path on
-        // membership uid change. Old behavior was `db.deleteMessage` +
-        // `unlinkBodyFile` which made undelete impossible (no row to
-        // restore, no body to read). For folders that ARE the trash
-        // already, fall through to hard delete (the action will EXPUNGE
-        // and reconciliation cleans up).
-        for (const msg of messages) {
-            if (trash && trash.id !== msg.folderId) {
-                this.db.moveMessageLocal(accountId, msg.uid, msg.folderId, trash.id);
-            }
-            else {
-                this.unlinkBodyFile(accountId, msg.uid, msg.folderId).catch(() => { });
-                this.db.deleteMessage(accountId, msg.uid, "user-initiated trash (already in trash → expunge)", "mailx-imap trashMessages");
-            }
-        }
-        console.log(`  Trashed ${messages.length} messages locally (moved to trash folder, body files retained)`);
-        // Queue IMAP actions
-        for (const msg of messages) {
-            if (trash && trash.id !== msg.folderId) {
-                this.db.queueSyncAction(accountId, "move", msg.uid, msg.folderId, { targetFolderId: trash.id });
-            }
-            else {
-                this.db.queueSyncAction(accountId, "delete", msg.uid, msg.folderId);
-            }
-        }
-        // Recalc folder counts so the tree badge updates immediately instead
-        // of showing stale numbers until the next full sync.
-        const sourceFolderIds = new Set(messages.map(m => m.folderId));
-        for (const fid of sourceFolderIds)
-            this.db.recalcFolderCounts(fid);
-        if (trash)
-            this.db.recalcFolderCounts(trash.id);
-        this.emit("folderCountsChanged", accountId, {});
-        // Process all queued actions in one IMAP session
-        this.debounceSyncActions(accountId);
-    }
-    /** Bulk move messages — queues the IMAP action only. The service layer
-     *  (MailxService.moveMessages) owns the local DB mutation via
-     *  updateMessageFolder; this method used to ALSO deleteMessage here,
-     *  which wiped the row the service just updated — the message vanished
-     *  on the next reconcile and "spam folder empty" was the symptom. */
-    async moveMessages(accountId, messages, targetFolderId) {
-        if (messages.length === 0)
-            return;
-        for (const msg of messages) {
-            this.db.queueSyncAction(accountId, "move", msg.uid, msg.folderId, { targetFolderId });
-        }
-        console.log(`  [move] ${accountId}: queued IMAP MOVE for ${messages.length} message(s) → folder ${targetFolderId}`);
-        this.debounceSyncActions(accountId);
-    }
-    /** Debounced sync actions — batches rapid local changes into one IMAP operation */
-    syncActionTimers = new Map();
-    debounceSyncActions(accountId) {
-        const existing = this.syncActionTimers.get(accountId);
-        if (existing)
-            clearTimeout(existing);
-        this.syncActionTimers.set(accountId, setTimeout(() => {
-            this.syncActionTimers.delete(accountId);
-            this.processSyncActions(accountId).catch(() => { });
-        }, 1000));
-    }
-    /** Move a message to Trash (delete) — local-first, queues IMAP sync */
-    async trashMessage(accountId, folderId, uid) {
-        const trash = this.findFolder(accountId, "trash");
-        // Tombstone the Message-ID so sync won't re-import the row in the
-        // source folder before the server-side move completes. Cleared on
-        // permanent failure of the queued sync_action (see processSyncActions
-        // catch block, where clearTombstoneForUid runs after attempts >= 5)
-        // so the user sees the row reappear when their action didn't take.
-        const env = this.db.getMessageByUid(accountId, uid, folderId);
-        if (env?.messageId)
-            this.db.addTombstone(accountId, env.messageId, env.subject || "");
-        // Local first — move to trash folder so the row stays visible in
-        // Trash and Ctrl+Z can restore. Body file retained for undelete.
-        // If we're already in trash (or no trash configured), fall through
-        // to hard delete + EXPUNGE.
-        if (trash && trash.id !== folderId) {
-            this.db.moveMessageLocal(accountId, uid, folderId, trash.id);
-        }
-        else {
-            this.unlinkBodyFile(accountId, uid, folderId).catch(() => { });
-            this.db.deleteMessage(accountId, uid, "user-initiated trash (already in trash → expunge)", "mailx-imap trashMessage");
-        }
-        // Queue IMAP action + log the resolution so "I deleted a message and
-        // now it's in neither trash nor deleted" is diagnosable from the log.
-        if (trash && trash.id !== folderId) {
-            const trashFolder = this.db.getFolders(accountId).find(f => f.id === trash.id);
-            this.db.queueSyncAction(accountId, "move", uid, folderId, { targetFolderId: trash.id });
-            console.log(`  [trash] ${accountId} UID ${uid}: queued MOVE to "${trashFolder?.path || trash.path}" (id=${trash.id}, specialUse=trash)`);
-        }
-        else {
-            this.db.queueSyncAction(accountId, "delete", uid, folderId);
-            console.log(`  [trash] ${accountId} UID ${uid}: queued EXPUNGE in folder ${folderId} (already in trash or no trash configured)`);
-        }
-        // Folder counts moved — refresh both source and trash so the
-        // tree badges update immediately, not at the next sync.
-        this.db.recalcFolderCounts(folderId);
-        if (trash && trash.id !== folderId)
-            this.db.recalcFolderCounts(trash.id);
-        this.emit("folderCountsChanged", accountId, {});
-        // Debounced sync — batches multiple deletes into one IMAP session
-        this.debounceSyncActions(accountId);
-    }
-    /** Move a message between folders — queues IMAP sync only. Service
-     *  layer owns the local DB update (see MailxService.moveMessage). */
-    async moveMessage(accountId, uid, fromFolderId, toFolderId) {
-        this.db.queueSyncAction(accountId, "move", uid, fromFolderId, { targetFolderId: toFolderId });
-        console.log(`  [move] ${accountId}: queued IMAP MOVE UID ${uid} folder ${fromFolderId} → ${toFolderId}`);
-        this.debounceSyncActions(accountId);
-    }
     /** Move message across accounts using iflow's moveMessageToServer */
     async moveMessageCrossAccount(fromAccountId, uid, fromFolderId, toAccountId, toFolderId) {
         const fromFolders = this.db.getFolders(fromAccountId);
@@ -3048,52 +2969,6 @@ export class ImapManager extends EventEmitter {
             });
         });
     }
-    /** Undelete — move from Trash back to original folder. Local-first:
-     *  the row was moved (not deleted) on trash, so we just move it back
-     *  in the local DB and reconcile the IMAP queue. Two cases:
-     *    (a) the to-trash MOVE is still pending — cancel it; the server
-     *        never saw the delete, so no counter-action is needed.
-     *    (b) the to-trash MOVE drained — the message is now in Trash on
-     *        the server with a new uid. Queue a counter-move from
-     *        trash → original. The IMAP processor's fetchByUid in trash
-     *        will use the local membership uid (which the reconciler
-     *        rebound to the server's new trash uid via Message-ID match).
-     *        If reconcile hasn't run yet (unlikely race), action retries
-     *        until it does. */
-    async undeleteMessage(accountId, uid, originalFolderId) {
-        const trash = this.findFolder(accountId, "trash");
-        if (!trash)
-            throw new Error("No Trash folder found");
-        // Move locally back to the original folder.
-        const moved = this.db.moveMessageLocal(accountId, uid, trash.id, originalFolderId);
-        if (!moved) {
-            console.log(`  [undelete] ${accountId} UID ${uid}: no row in trash — nothing to restore locally (sync may have already pruned)`);
-        }
-        // (a) cancel still-pending to-trash action.
-        const pending = this.db.findPendingSyncAction(accountId, "move", uid, originalFolderId, trash.id);
-        if (pending) {
-            this.db.completeSyncAction(pending.id);
-            console.log(`  [undelete] ${accountId} UID ${uid}: cancelled pending MOVE to trash (server never saw delete)`);
-            this.emit("folderCountsChanged", accountId, {});
-            return;
-        }
-        // (b) queue counter-move from trash → original.
-        this.db.queueSyncAction(accountId, "move", uid, trash.id, { targetFolderId: originalFolderId });
-        console.log(`  [undelete] ${accountId} UID ${uid}: queued counter-MOVE trash → folder ${originalFolderId}`);
-        this.debounceSyncActions(accountId);
-        this.emit("folderCountsChanged", accountId, {});
-    }
-    /** Update flags — local-first, queues IMAP sync */
-    async updateFlagsLocal(accountId, uid, folderId, flags) {
-        this.db.updateMessageFlags(accountId, uid, flags);
-        this.db.queueSyncAction(accountId, "flags", uid, folderId, { flags });
-        // User-visible pink-dot pending state stays until the action drains.
-        // The 30-second periodic tick was too slow — opening one message to
-        // auto-mark-as-read left it pink for half a minute. Same 1-second
-        // debounce as moves/deletes batches rapid flag churn without the
-        // visual lag.
-        this.debounceSyncActions(accountId);
-    }
     /** Process pending sync actions for an account */
     async processSyncActions(accountId) {
         const actions = this.db.getPendingSyncActions(accountId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,9 +9,9 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/mailx-types": "^0.1.11",
+    "@bobfrankston/mailx-types": "^0.1.13",
     "@bobfrankston/mailx-settings": "^0.1.16",
-    "@bobfrankston/mailx-store": "^0.1.23",
+    "@bobfrankston/mailx-store": "^0.1.24",
     "@bobfrankston/iflow-direct": "^0.1.44",
     "@bobfrankston/tcp-transport": "^0.1.6",
     "@bobfrankston/smtp-direct": "^0.1.8",
@@ -37,9 +37,9 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/mailx-types": "^0.1.11",
+      "@bobfrankston/mailx-types": "^0.1.13",
       "@bobfrankston/mailx-settings": "^0.1.16",
-      "@bobfrankston/mailx-store": "^0.1.23",
+      "@bobfrankston/mailx-store": "^0.1.24",
       "@bobfrankston/iflow-direct": "^0.1.44",
       "@bobfrankston/tcp-transport": "^0.1.6",
       "@bobfrankston/smtp-direct": "^0.1.8",