@bobfrankston/mailx-imap 0.1.31 → 0.1.33

package/index.d.ts

@@ -398,7 +398,18 @@ export declare class ImapManager extends EventEmitter {
     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 */
+    /** 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>;

package/index.js

@@ -2696,12 +2696,24 @@ export class ImapManager extends EventEmitter {
         if (messages.length === 0)
             return;
         const trash = this.findFolder(accountId, "trash");
-        // Local first — remove all from DB immediately
+        // 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) {
-            this.unlinkBodyFile(accountId, msg.uid, msg.folderId).catch(() => { });
-            this.db.deleteMessage(accountId, msg.uid, "user-initiated delete (bulk)", "mailx-imap deleteMessages");
+            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(`  Deleted ${messages.length} messages locally`);
+        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) {
@@ -2750,9 +2762,17 @@ export class ImapManager extends EventEmitter {
     /** Move a message to Trash (delete) — local-first, queues IMAP sync */
     async trashMessage(accountId, folderId, uid) {
         const trash = this.findFolder(accountId, "trash");
-        // Local first — remove from DB immediately
-        this.unlinkBodyFile(accountId, uid, folderId).catch(() => { });
-        this.db.deleteMessage(accountId, uid, "user-initiated trash", "mailx-imap trashMessage");
+        // 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) {
@@ -2764,6 +2784,12 @@ export class ImapManager extends EventEmitter {
             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);
     }
@@ -2799,12 +2825,40 @@ export class ImapManager extends EventEmitter {
             });
         });
     }
-    /** Undelete — move from Trash back to original folder */
+    /** 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");
-        await this.moveMessage(accountId, uid, trash.id, originalFolderId);
+        // 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) {
@@ -3368,7 +3422,12 @@ export class ImapManager extends EventEmitter {
         //      this exact case: `.sending-rmf39-63196` sat in the queue
         //      for 7+ hours because PID 63196 was now an unrelated Node.
         //  (c) it's our PID — never sweep our own claim.
-        const STALE_CLAIM_MS = 3600_000;
+        // 5 minutes: SMTP transactions complete in seconds; 5m of
+        // claim with no progress means the worker is wedged or PID
+        // got recycled. Earlier 1h was a band-aid that left Bob's
+        // outbox stuck for hours when an SMTP wedge crashed the
+        // worker mid-flight.
+        const STALE_CLAIM_MS = 5 * 60_000;
         const myPid = process.pid;
         for (const dir of [outboxDir, queuedDir]) {
             if (!fs.existsSync(dir))
@@ -3470,11 +3529,23 @@ export class ImapManager extends EventEmitter {
                     // file is visible to the scan loop again.
                     const nextAt = new Date(nowMs + OUTBOX_RETRY_DELAY_MS).toISOString();
                     const withDelay = insertHeaderBeforeBody(raw, `X-Mailx-Retry-After: ${nextAt}`);
-                    fs.writeFileSync(claimedPath, withDelay, "utf-8");
+                    try {
+                        fs.writeFileSync(claimedPath, withDelay, "utf-8");
+                    }
+                    catch (we) {
+                        console.error(`  [outbox] FAIL writeBack ${claimedPath}: ${we?.message || we}`);
+                    }
                     try {
                         fs.renameSync(claimedPath, filePath);
                     }
-                    catch { /* file stays claimed; recovery sweeper will handle */ }
+                    catch (re) {
+                        // Loud — the file is now stuck in `.sending-` state
+                        // until the recovery sweeper's stale-claim timer
+                        // (5 min) reclaims it. User-visible as "stuck" in
+                        // the outbox view; cancelable via the new always-
+                        // allowed Cancel button.
+                        console.error(`  [outbox] FAIL renameBack ${claimedPath} → ${filePath}: ${re?.message || re} — claim will sit until stale-recovery (5 min)`);
+                    }
                     console.error(`  [outbox] Send failed for ${file} (attempt ${attempt}, retry after ${nextAt}): ${e.message}`);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,7 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.10",
-    "@bobfrankston/mailx-settings": "^0.1.13",
+    "@bobfrankston/mailx-settings": "^0.1.14",
     "@bobfrankston/mailx-store": "^0.1.15",
     "@bobfrankston/iflow-direct": "^0.1.39",
     "@bobfrankston/tcp-transport": "^0.1.6",
@@ -38,7 +38,7 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.10",
-      "@bobfrankston/mailx-settings": "^0.1.13",
+      "@bobfrankston/mailx-settings": "^0.1.14",
       "@bobfrankston/mailx-store": "^0.1.15",
       "@bobfrankston/iflow-direct": "^0.1.39",
       "@bobfrankston/tcp-transport": "^0.1.6",