@bobfrankston/mailx 1.0.110 → 1.0.112

package/client/app.js

@@ -5,7 +5,7 @@
 import { initFolderTree, refreshFolderTree } from "./components/folder-tree.js";
 import { initMessageList, loadMessages, loadUnifiedInbox, loadSearchResults, reloadCurrentFolder, getSelectedMessages } from "./components/message-list.js";
 import { showMessage, getCurrentMessage } from "./components/message-viewer.js";
-import { connectWebSocket, onWsEvent, triggerSync, getAccounts, getFolders, deleteMessage, undeleteMessage, restartServer, rebuildServer } from "./lib/api-client.js";
+import { connectWebSocket, onWsEvent, triggerSync, getAccounts, getFolders, deleteMessages, undeleteMessage, restartServer, rebuildServer } from "./lib/api-client.js";
 // ── New message badge (favicon + title) ──
 let baseTitle = "mailx";
 let lastSeenCount = 0;
@@ -309,10 +309,19 @@ async function deleteSelectedMessages() {
             if (lastRow)
                 nextRow = (lastRow.nextElementSibling || lastRow.previousElementSibling);
         }
-        // Delete all selected
+        // Delete all selected — bulk operation, one IMAP session
+        // Group by account
+        const byAccount = new Map();
+        for (const msg of selected) {
+            const uids = byAccount.get(msg.accountId) || [];
+            uids.push(msg.uid);
+            byAccount.set(msg.accountId, uids);
+        }
+        for (const [accountId, uids] of byAccount) {
+            await deleteMessages(accountId, uids);
+        }
+        // Remove rows from DOM
         for (const msg of selected) {
-            await deleteMessage(msg.accountId, msg.uid);
-            // Remove row from DOM
             if (mlBody)
                 mlBody.querySelector(`.ml-row[data-uid="${msg.uid}"]`)?.remove();
         }

package/client/components/folder-tree.js

@@ -2,7 +2,7 @@
  * Folder tree component -- renders account folders with hierarchy,
  * expand/collapse, and optional unified inbox.
  */
-import { getAccounts, getFolders, moveMessage, markFolderRead, createFolder, renameFolder, deleteFolder, emptyFolder } from "../lib/api-client.js";
+import { getAccounts, getFolders, moveMessage, moveMessages, markFolderRead, createFolder, renameFolder, deleteFolder, emptyFolder } from "../lib/api-client.js";
 import { showContextMenu } from "./context-menu.js";
 let onFolderSelect;
 let onUnifiedInbox = null;
@@ -257,12 +257,20 @@ function renderNode(node, container, depth) {
             const statusEl = document.getElementById("status-sync");
             const crossAccount = toMove.some(m => m.accountId !== node.accountId);
             try {
-                let moved = 0;
-                for (const msg of toMove) {
-                    const targetAccountId = msg.accountId !== node.accountId ? node.accountId : undefined;
-                    await moveMessage(msg.accountId, msg.uid, node.id, targetAccountId);
-                    moved++;
+                if (crossAccount) {
+                    // Cross-account: must do one at a time
+                    for (const msg of toMove) {
+                        const targetAccountId = msg.accountId !== node.accountId ? node.accountId : undefined;
+                        await moveMessage(msg.accountId, msg.uid, node.id, targetAccountId);
+                    }
+                }
+                else {
+                    // Same account: bulk move
+                    const accountId = toMove[0].accountId;
+                    const uids = toMove.map(m => m.uid);
+                    await moveMessages(accountId, uids, node.id);
                 }
+                const moved = toMove.length;
                 if (statusEl)
                     statusEl.textContent = `Moved ${moved} message${moved > 1 ? "s" : ""} to ${node.name}`;
                 const treeContainer = document.getElementById("folder-tree");

package/client/lib/api-client.js

@@ -125,6 +125,27 @@ export function deleteMessage(accountId, uid) {
         return mailxapi.deleteMessage?.(accountId, uid);
     return api(`/message/${accountId}/${uid}`, { method: "DELETE" });
 }
+export function deleteMessages(accountId, uids) {
+    if (uids.length === 1)
+        return deleteMessage(accountId, uids[0]);
+    if (hasIPC)
+        return mailxapi.deleteMessages?.(accountId, uids);
+    return api("/messages/delete", {
+        method: "POST", body: JSON.stringify({ accountId, uids })
+    });
+}
+export function moveMessages(accountId, uids, targetFolderId, targetAccountId) {
+    if (uids.length === 1)
+        return moveMessage(accountId, uids[0], targetFolderId, targetAccountId);
+    if (hasIPC)
+        return mailxapi.moveMessages?.(accountId, uids, targetFolderId, targetAccountId);
+    const body = { accountId, uids, targetFolderId };
+    if (targetAccountId)
+        body.targetAccountId = targetAccountId;
+    return api("/messages/move", {
+        method: "POST", body: JSON.stringify(body)
+    });
+}
 export function undeleteMessage(accountId, uid, folderId) {
     if (hasIPC)
         return mailxapi.undeleteMessage?.(accountId, uid, folderId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.110",
+  "version": "1.0.112",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,7 +20,7 @@
     "postinstall": "node launcher/builder/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.43",
+    "@bobfrankston/iflow": "^1.0.44",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
     "@bobfrankston/rust-builder": "^0.1.3",

package/packages/mailx-api/index.js

@@ -148,7 +148,36 @@ export function createApiRouter(db, imapManager) {
             res.status(500).json({ error: e.message });
         }
     });
-    // ── Delete ──
+    // ── Bulk operations ──
+    router.post("/messages/delete", async (req, res) => {
+        try {
+            const { accountId, uids } = req.body;
+            await svc.deleteMessages(accountId, uids);
+            res.json({ ok: true, count: uids.length });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    router.post("/messages/move", async (req, res) => {
+        try {
+            const { accountId, uids, targetFolderId, targetAccountId } = req.body;
+            if (targetAccountId && targetAccountId !== accountId) {
+                // Cross-account: must do one at a time
+                for (const uid of uids) {
+                    await svc.moveMessage(accountId, uid, targetFolderId, targetAccountId);
+                }
+            }
+            else {
+                await svc.moveMessages(accountId, uids, targetFolderId);
+            }
+            res.json({ ok: true, count: uids.length });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // ── Delete (single — kept for backward compat) ──
     router.delete("/message/:accountId/:uid", async (req, res) => {
         try {
             await svc.deleteMessage(req.params.accountId, Number(req.params.uid));

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

@@ -86,6 +86,19 @@ export declare class ImapManager extends EventEmitter {
     fetchMessageBody(accountId: string, folderId: number, uid: number): Promise<Buffer | null>;
     /** 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 — local-first, single IMAP connection for all */
+    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 — local-first, queues IMAP sync */

package/packages/mailx-imap/index.js

@@ -822,6 +822,56 @@ 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");
+        // Local first — remove all from DB immediately
+        for (const msg of messages) {
+            this.db.deleteMessage(accountId, msg.uid);
+            this.bodyStore.deleteMessage(accountId, msg.folderId, msg.uid).catch(() => { });
+        }
+        console.log(`  Deleted ${messages.length} messages locally`);
+        // 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);
+            }
+        }
+        // Process all queued actions in one IMAP session
+        this.debounceSyncActions(accountId);
+    }
+    /** Bulk move messages — local-first, single IMAP connection for all */
+    async moveMessages(accountId, messages, targetFolderId) {
+        if (messages.length === 0)
+            return;
+        // Local first
+        for (const msg of messages) {
+            this.db.deleteMessage(accountId, msg.uid);
+        }
+        console.log(`  Moved ${messages.length} messages locally (→ folder ${targetFolderId})`);
+        // Queue IMAP actions
+        for (const msg of messages) {
+            this.db.queueSyncAction(accountId, "move", msg.uid, msg.folderId, { targetFolderId });
+        }
+        // Process all queued actions in one IMAP session
+        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");
@@ -836,8 +886,8 @@ export class ImapManager extends EventEmitter {
         else {
             this.db.queueSyncAction(accountId, "delete", uid, folderId);
         }
-        // Try immediate sync
-        this.processSyncActions(accountId).catch(() => { });
+        // Debounced sync — batches multiple deletes into one IMAP session
+        this.debounceSyncActions(accountId);
     }
     /** Move a message between folders — local-first, queues IMAP sync */
     async moveMessage(accountId, uid, fromFolderId, toFolderId) {
@@ -846,8 +896,8 @@ export class ImapManager extends EventEmitter {
         console.log(`  Moved UID ${uid} locally (folder ${fromFolderId} → ${toFolderId})`);
         // Queue IMAP action
         this.db.queueSyncAction(accountId, "move", uid, fromFolderId, { targetFolderId: toFolderId });
-        // Try immediate sync
-        this.processSyncActions(accountId).catch(() => { });
+        // Debounced sync — batches multiple moves into one IMAP session
+        this.debounceSyncActions(accountId);
     }
     /** Move message across accounts using iflow's moveMessageToServer */
     async moveMessageCrossAccount(fromAccountId, uid, fromFolderId, toAccountId, toFolderId) {

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

@@ -32,7 +32,9 @@ export declare class MailxService {
     reauthenticate(accountId: string): Promise<boolean>;
     send(msg: any): Promise<void>;
     deleteMessage(accountId: string, uid: number): Promise<void>;
+    deleteMessages(accountId: string, uids: number[]): Promise<void>;
     moveMessage(accountId: string, uid: number, targetFolderId: number, targetAccountId?: string): Promise<void>;
+    moveMessages(accountId: string, uids: number[], targetFolderId: number): Promise<void>;
     undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
     deleteOnServer(accountId: string, folderPath: string, uid: number): Promise<void>;
     createFolder(accountId: string, parentPath: string, name: string): Promise<void>;

package/packages/mailx-service/index.js

@@ -300,6 +300,15 @@ export class MailxService {
             throw new Error("Message not found");
         await this.imapManager.trashMessage(accountId, envelope.folderId, envelope.uid);
     }
+    async deleteMessages(accountId, uids) {
+        const messages = uids.map(uid => {
+            const env = this.db.getMessageByUid(accountId, uid);
+            if (!env)
+                return null;
+            return { uid: env.uid, folderId: env.folderId };
+        }).filter(m => m !== null);
+        await this.imapManager.trashMessages(accountId, messages);
+    }
     async moveMessage(accountId, uid, targetFolderId, targetAccountId) {
         const envelope = this.db.getMessageByUid(accountId, uid);
         if (!envelope)
@@ -311,6 +320,15 @@ export class MailxService {
             await this.imapManager.moveMessage(accountId, envelope.uid, envelope.folderId, targetFolderId);
         }
     }
+    async moveMessages(accountId, uids, targetFolderId) {
+        const messages = uids.map(uid => {
+            const env = this.db.getMessageByUid(accountId, uid);
+            if (!env)
+                return null;
+            return { uid: env.uid, folderId: env.folderId };
+        }).filter(m => m !== null);
+        await this.imapManager.moveMessages(accountId, messages, targetFolderId);
+    }
     async undeleteMessage(accountId, uid, folderId) {
         await this.imapManager.undeleteMessage(accountId, uid, folderId);
     }