@bobfrankston/mailx-imap 0.1.91 → 0.1.93

package/index.d.ts

@@ -120,6 +120,21 @@ export declare class ImapManager extends EventEmitter {
     searchAndFetchOnServer(accountId: string, folderId: number, mailboxPath: string, criteria: any): Promise<number[]>;
     /** Create a fresh IMAP client for an account (public access for API endpoints) */
     createPublicClient(accountId: string): Promise<any>;
+    /** Create `fullPath` on the server, upsert the local folder row, re-sync
+     *  the folder list, and report whether the folder actually exists after. */
+    createFolderViaServer(accountId: string, fullPath: string, name: string, delimiter: string): Promise<boolean>;
+    /** Rename `oldPath` → `newPath` on the server and re-sync folders. */
+    renameFolderViaServer(accountId: string, oldPath: string, newPath: string): Promise<void>;
+    /** Delete `path` on the server (tolerating already-gone). Local folder-row
+     *  removal stays with the caller (it knows the folderId). */
+    deleteFolderViaServer(accountId: string, path: string): Promise<void>;
+    /** Expunge every message in `path` on the server. */
+    emptyFolderViaServer(accountId: string, path: string): Promise<void>;
+    /** Move a folder into Trash by IMAP RENAME, falling back to spilling its
+     *  messages into Trash root + deleting the empty folder when the server
+     *  forbids nesting under Trash. Self-contained on the worker. */
+    moveFolderToTrashViaServer(accountId: string, folderId: number, folderPath: string, targetPath: string, trashId: number, trashPath: string, delim: string): Promise<void>;
+    private spillFolderToTrashServer;
     /** Persistent slow-lane operational connection per account. Used by sync,
      *  prefetch, outbox-append, large backfills, and any other "this might
      *  take a while" operation. */

package/index.js

@@ -408,6 +408,152 @@ export class ImapManager extends EventEmitter {
     async createPublicClient(accountId) {
         return this.createClient(accountId);
     }
+    // ── Server-side folder operations ──────────────────────────────────────
+    // These run the IMAP folder mutation AND the local folder-table write here
+    // (on whatever thread ImapManager lives — the sync worker), so the service
+    // never needs a live IMAP client object across the worker boundary. The
+    // service keeps the surrounding UX (path computation, error messaging); it
+    // calls these for the actual server+folder-row work. Returns are primitive
+    // so they cross the bus cleanly.
+    /** Create `fullPath` on the server, upsert the local folder row, re-sync
+     *  the folder list, and report whether the folder actually exists after. */
+    async createFolderViaServer(accountId, fullPath, name, delimiter) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            await client.createmailbox(fullPath);
+            this.db.upsertFolder(accountId, fullPath, name, null, delimiter);
+            await this.syncFolders(accountId, client);
+            return this.db.getFolders(accountId).some(f => f.path === fullPath);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Rename `oldPath` → `newPath` on the server and re-sync folders. */
+    async renameFolderViaServer(accountId, oldPath, newPath) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            if (client.renameMailbox)
+                await client.renameMailbox(oldPath, newPath);
+            else
+                await client.withConnection(async () => { await client.client.mailboxRename(oldPath, newPath); });
+            await this.syncFolders(accountId, client);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Delete `path` on the server (tolerating already-gone). Local folder-row
+     *  removal stays with the caller (it knows the folderId). */
+    async deleteFolderViaServer(accountId, path) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            try {
+                if (client.deleteMailbox)
+                    await client.deleteMailbox(path);
+                else
+                    await client.withConnection(async () => { await client.client.mailboxDelete(path); });
+            }
+            catch (e) {
+                const msg = String(e?.message || e || "").toLowerCase();
+                if (!/nonexistent|does not exist|no such|not found|404/i.test(msg))
+                    throw e;
+                console.log(`  [folder] ${accountId} delete "${path}": server says already gone`);
+            }
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Expunge every message in `path` on the server. */
+    async emptyFolderViaServer(accountId, path) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            const uids = await client.getUids(path);
+            for (const uid of uids)
+                await client.deleteMessageByUid(path, uid);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Move a folder into Trash by IMAP RENAME, falling back to spilling its
+     *  messages into Trash root + deleting the empty folder when the server
+     *  forbids nesting under Trash. Self-contained on the worker. */
+    async moveFolderToTrashViaServer(accountId, folderId, folderPath, targetPath, trashId, trashPath, delim) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            try {
+                if (client.renameMailbox)
+                    await client.renameMailbox(folderPath, targetPath);
+                else
+                    await client.withConnection(async () => { await client.client.mailboxRename(folderPath, targetPath); });
+                console.log(`  [folder] ${accountId} moved "${folderPath}" → "${targetPath}"`);
+            }
+            catch (e) {
+                const msg = String(e?.message || e || "").toLowerCase();
+                if (!/noinferiors|hierarchy|invalid (mailbox )?name|cannot rename|inferiors/i.test(msg))
+                    throw e;
+                console.log(`  [folder] ${accountId} cannot RENAME under Trash; spilling messages`);
+                await this.spillFolderToTrashServer(accountId, folderId, folderPath, trashId, trashPath, delim, client);
+            }
+            await this.syncFolders(accountId, client);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    async spillFolderToTrashServer(accountId, folderId, folderPath, trashId, trashPath, delim, client) {
+        // Children first so the parent ends up empty.
+        const childPrefix = folderPath + delim;
+        const children = this.db.getFolders(accountId).filter(f => f.path.startsWith(childPrefix));
+        for (const child of children) {
+            await this.spillFolderToTrashServer(accountId, child.id, child.path, trashId, trashPath, delim, client);
+        }
+        // Move each message to Trash on the server, then mirror locally.
+        const uids = await client.getUids(folderPath).catch(() => []);
+        for (const uid of uids) {
+            try {
+                if (client.moveMessage)
+                    await client.moveMessage(folderPath, trashPath, uid);
+                else {
+                    await client.copyMessage(folderPath, trashPath, uid);
+                    await client.deleteMessageByUid(folderPath, uid);
+                }
+                this.store.trashMessage(accountId, uid, folderId, trashId);
+            }
+            catch (e) {
+                console.error(`  [folder] spill uid ${uid}: ${e?.message || e}`);
+            }
+        }
+        try {
+            if (client.deleteMailbox)
+                await client.deleteMailbox(folderPath);
+            else
+                await client.withConnection(async () => { await client.client.mailboxDelete(folderPath); });
+        }
+        catch (e) {
+            const m = String(e?.message || e || "").toLowerCase();
+            if (!/nonexistent|does not exist|no such/.test(m))
+                throw e;
+        }
+        this.db.deleteFolder(folderId);
+    }
     // Legacy fallback disabled — was doubling connections without helping.
     // To re-enable: uncomment legacyFallbacks logic in createClient and _syncAll.
     // private legacyFallbacks = new Set<string>();
@@ -636,14 +782,16 @@ export class ImapManager extends EventEmitter {
         const releaseHostSlot = skipSemaphore ? (() => { }) : await this.acquireHostSlot(host);
         let client;
         try {
-            // Verbose IMAP wire trace for ops connections only — that's the
-            // lane where commands have been hanging silently with no
-            // heartbeat / wall-clock fire / reject. Need to see the actual
-            // commands sent and bytes received to pinpoint where the
-            // pendingCommand is getting lost. Fast lane (C123) shares the
-            // verbose treatment so click-time wedges show too. Other lanes
-            // (idle, quickCheck) stay quiet so the log doesn't drown.
-            const cfgWithVerbose = (purpose === "ops" || purpose === "fast") ? { ...config, verbose: true } : config;
+            // Verbose IMAP wire trace — diagnostic for silently-hanging
+            // commands. It was left permanently ON for the ops/fast lanes, but
+            // that logs every literal chunk (8000+ lines during a body-fetch
+            // burst), and on Windows the daemon's console.log writes to the log
+            // file SYNCHRONOUSLY — so the trace itself blocked the main event
+            // loop during sync, starving the IPC reply relay and producing the
+            // 78s read stalls (Bob 2026-06-13). Now opt-in: set RMFMAIL_IMAP_TRACE=1
+            // to re-enable for a debugging session. Default is quiet.
+            const imapTrace = process.env.RMFMAIL_IMAP_TRACE === "1";
+            const cfgWithVerbose = (imapTrace && (purpose === "ops" || purpose === "fast")) ? { ...config, verbose: true } : config;
             client = new CompatImapClient(cfgWithVerbose, this.transportFactory);
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.91",
+  "version": "0.1.93",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -11,7 +11,7 @@
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.19",
     "@bobfrankston/mailx-settings": "^0.1.26",
-    "@bobfrankston/mailx-store": "^0.1.47",
+    "@bobfrankston/mailx-store": "^0.1.48",
     "@bobfrankston/iflow-direct": "^0.1.53",
     "@bobfrankston/tcp-transport": "^0.1.7",
     "@bobfrankston/smtp-direct": "^0.1.9",
@@ -39,7 +39,7 @@
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.19",
       "@bobfrankston/mailx-settings": "^0.1.26",
-      "@bobfrankston/mailx-store": "^0.1.47",
+      "@bobfrankston/mailx-store": "^0.1.48",
       "@bobfrankston/iflow-direct": "^0.1.53",
       "@bobfrankston/tcp-transport": "^0.1.7",
       "@bobfrankston/smtp-direct": "^0.1.9",