@bobfrankston/rmfmail 1.1.2 → 1.1.4

package/packages/mailx-imap/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";
@@ -216,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) {
@@ -2928,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);
@@ -3078,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);