@bobfrankston/mailx-imap 0.1.34 → 0.1.36

package/index.js

@@ -2181,15 +2181,43 @@ export class ImapManager extends EventEmitter {
                 // it can't share the ops queue. Counts against the per-host
                 // semaphore (one slot for the IDLE socket).
                 const watchClient = await this.createClient(accountId, "idle");
+                // RFC 5465 NOTIFY: when the server supports it (Dovecot does;
+                // gmail-IMAP and Outlook IMAP typically don't), engage
+                // cross-mailbox push so changes in Sent/Drafts/subfolders
+                // surface in real time instead of waiting for the next
+                // periodic sync. SELECTED group keeps INBOX events flowing
+                // through the existing IDLE/EXISTS path; PERSONAL group
+                // pushes STATUS for every other mailbox the user owns.
+                const caps = typeof watchClient.getCapabilities === "function"
+                    ? watchClient.getCapabilities()
+                    : new Set();
+                const useNotify = caps.has("NOTIFY");
+                const notifySpec = useNotify
+                    ? "(SELECTED (MessageNew MessageExpunge FlagChange)) (PERSONAL (MessageNew MessageExpunge FlagChange MailboxName))"
+                    : undefined;
+                const onMailboxStatus = useNotify
+                    ? (mailboxPath, _data) => {
+                        // Find the local folder row by IMAP path and sync it.
+                        // STATUS pushes are lightweight count hints — the real
+                        // change set is fetched by syncFolder.
+                        const folder = this.db.getFolders(accountId).find(f => f.path === mailboxPath);
+                        if (!folder) {
+                            console.log(`  [notify] ${accountId}: STATUS for unknown mailbox "${mailboxPath}" — skipping`);
+                            return;
+                        }
+                        console.log(`  [notify] ${accountId}: ${mailboxPath} changed → syncFolder`);
+                        this.syncFolder(accountId, folder.id).catch(e => console.error(`  [notify] sync ${mailboxPath} failed: ${e.message}`));
+                    }
+                    : undefined;
                 const stop = await watchClient.watchMailbox("INBOX", (newCount) => {
                     console.log(`  [idle] ${accountId}: ${newCount} new message(s)`);
                     this.syncInboxNewOnly(accountId).catch(e => console.error(`  [idle] sync error: ${e.message}`));
-                });
+                }, { notifySpec, onMailboxStatus });
                 this.watchers.set(accountId, async () => {
                     await stop();
                     await watchClient.logout();
                 });
-                console.log(`  [idle] Watching INBOX for ${accountId}`);
+                console.log(`  [idle] Watching INBOX for ${accountId}${useNotify ? " (+NOTIFY personal mailboxes)" : ""}`);
             }
             catch (e) {
                 console.error(`  [idle] Failed to watch ${accountId}: ${e.message}`);
@@ -3124,33 +3152,54 @@ export class ImapManager extends EventEmitter {
             return;
         if (!draftUid && !draftId)
             return;
-        await this.withConnection(accountId, async (client) => {
-            if (draftUid) {
-                try {
-                    await client.deleteMessageByUid(drafts.path, draftUid);
-                    console.log(`  [drafts] Deleted draft UID ${draftUid}`);
-                }
-                catch (e) {
-                    console.error(`  [drafts] Delete by UID ${draftUid} failed: ${e.message}`);
+        let succeeded = false;
+        try {
+            await this.withConnection(accountId, async (client) => {
+                if (draftUid) {
+                    try {
+                        await client.deleteMessageByUid(drafts.path, draftUid);
+                        console.log(`  [drafts] Deleted draft UID ${draftUid}`);
+                        succeeded = true;
+                    }
+                    catch (e) {
+                        console.error(`  [drafts] Delete by UID ${draftUid} failed: ${e.message}`);
+                    }
                 }
-            }
-            if (draftId) {
-                try {
-                    const uids = await client.searchByHeader(drafts.path, "X-Mailx-Draft-ID", draftId);
-                    for (const uid of uids) {
-                        try {
-                            await client.deleteMessageByUid(drafts.path, uid);
+                if (draftId) {
+                    try {
+                        const uids = await client.searchByHeader(drafts.path, "X-Mailx-Draft-ID", draftId);
+                        for (const uid of uids) {
+                            try {
+                                await client.deleteMessageByUid(drafts.path, uid);
+                                succeeded = true;
+                            }
+                            catch { /* next */ }
                         }
-                        catch { /* next */ }
+                        if (uids.length > 0)
+                            console.log(`  [drafts] Deleted ${uids.length} draft(s) by ID ${draftId}`);
+                    }
+                    catch (e) {
+                        console.error(`  [drafts] searchByHeader for ${draftId} failed: ${e.message}`);
                     }
-                    if (uids.length > 0)
-                        console.log(`  [drafts] Deleted ${uids.length} draft(s) by ID ${draftId}`);
-                }
-                catch (e) {
-                    console.error(`  [drafts] searchByHeader for ${draftId} failed: ${e.message}`);
                 }
-            }
-        });
+            });
+        }
+        catch (e) {
+            // withConnection itself failed (no socket, auth refresh wedged) —
+            // fall through to queue a retry if we have a UID to anchor on.
+            console.error(`  [drafts] withConnection failed for ${accountId}: ${e?.message || e}`);
+        }
+        // Reliable cleanup: if the inline attempt didn't actually delete the
+        // draft, queue a sync_action so the regular processSyncActions loop
+        // retries it later. Without this, transient IMAP failures left stale
+        // drafts in the folder ("draft droppings" that pile up after sends).
+        // Only the UID path can be queued — searchByHeader retries on every
+        // future call anyway, and queuing a header-lookup isn't a real
+        // sync_action shape.
+        if (!succeeded && draftUid) {
+            console.log(`  [drafts] Queueing sync_action for retry: delete UID ${draftUid} in ${drafts.path}`);
+            this.db.queueSyncAction(accountId, "delete", draftUid, drafts.id);
+        }
     }
     /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP.
      *  Single path: write `~/.mailx/outbox/<acct>/*.ltr` synchronously, then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -11,8 +11,8 @@
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.10",
     "@bobfrankston/mailx-settings": "^0.1.14",
-    "@bobfrankston/mailx-store": "^0.1.16",
-    "@bobfrankston/iflow-direct": "^0.1.39",
+    "@bobfrankston/mailx-store": "^0.1.18",
+    "@bobfrankston/iflow-direct": "^0.1.40",
     "@bobfrankston/tcp-transport": "^0.1.6",
     "@bobfrankston/smtp-direct": "^0.1.8",
     "@bobfrankston/mailx-sync": "^0.1.16",
@@ -39,8 +39,8 @@
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.10",
       "@bobfrankston/mailx-settings": "^0.1.14",
-      "@bobfrankston/mailx-store": "^0.1.16",
-      "@bobfrankston/iflow-direct": "^0.1.39",
+      "@bobfrankston/mailx-store": "^0.1.18",
+      "@bobfrankston/iflow-direct": "^0.1.40",
       "@bobfrankston/tcp-transport": "^0.1.6",
       "@bobfrankston/smtp-direct": "^0.1.8",
       "@bobfrankston/mailx-sync": "^0.1.16",