@bobfrankston/mailx-imap 0.1.67 → 0.1.69

package/index.d.ts

@@ -452,6 +452,17 @@ export declare class ImapManager extends EventEmitter {
     private ensureOutbox;
     /** Save a copy of outgoing mail — label is a subdirectory (editing/queued/sent) */
     private saveSendingCopy;
+    /** Drop a requeue.cmd / requeue.sh into a sending/<acct>/<label>/ directory
+     *  so the user can re-queue a saved .eml/.ltr without remembering the
+     *  rmfmail -send syntax. Idempotent: only writes when missing.
+     *  The word is "requeue" — it puts the file back into the outbox queue;
+     *  it does NOT send a fresh copy bypassing the queue. */
+    private ensureRequeueScripts;
+    /** Walk the sending tree at startup and drop a requeue.cmd/.sh into every
+     *  existing sending/<acct>/<label>/ directory. Without this the scripts
+     *  only appear on the next outgoing message, which doesn't help a user
+     *  who needs to re-queue a stuck letter from before the upgrade. */
+    private seedRequeueScripts;
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     queueOutgoing(accountId: string, rawMessage: string | Buffer): Promise<void>;
     /** Process local file queue — scan both outbox/ (IMAP-unreachable fallback)

package/index.js

@@ -1250,7 +1250,7 @@ export class ImapManager extends EventEmitter {
                     for (const m of qr.changedMessages) {
                         try {
                             const flagsArr = Array.from(m.flags || []).map(f => String(f));
-                            this.db.updateMessageFlags(accountId, m.uid, flagsArr);
+                            this.db.updateMessageFlags(accountId, folderId, m.uid, flagsArr);
                         }
                         catch { /* row may have just been VANISHED */ }
                     }
@@ -3467,6 +3467,12 @@ export class ImapManager extends EventEmitter {
             // Delete previous draft — try UID first (fast path), and ALWAYS also try
             // searchByHeader(X-Mailx-Draft-ID) as a safety net. Running both catches
             // orphans from a crash-mid-save or a UID delete that failed silently.
+            //
+            // CRITICAL: also delete the LOCAL DB row for the superseded UID. Without
+            // that, every checkpoint save left a stale row behind — IMAP had only
+            // the latest copy but the local Drafts view rendered every past UID as
+            // its own row, producing the "Drafts is flooded with droppings" symptom
+            // (Bob 2026-05-27 — 8+ rows for a single in-progress reply).
             if (previousDraftUid) {
                 try {
                     await client.deleteMessageByUid(drafts.path, previousDraftUid);
@@ -3474,6 +3480,10 @@ export class ImapManager extends EventEmitter {
                 catch (e) {
                     console.error(`  [drafts] Delete prev UID ${previousDraftUid} failed: ${e.message}`);
                 }
+                try {
+                    this.db.deleteMessage(accountId, drafts.id, previousDraftUid, "previous draft superseded", "saveDraft");
+                }
+                catch { /* */ }
             }
             if (draftId) {
                 try {
@@ -3483,6 +3493,10 @@ export class ImapManager extends EventEmitter {
                             await client.deleteMessageByUid(drafts.path, uid);
                         }
                         catch { /* next */ }
+                        try {
+                            this.db.deleteMessage(accountId, drafts.id, uid, `draft superseded by newer save (id=${draftId})`, "saveDraft");
+                        }
+                        catch { /* */ }
                     }
                     if (uids.length > 0)
                         console.log(`  [drafts] Deleted ${uids.length} stale draft(s) by ID ${draftId}`);
@@ -3827,6 +3841,7 @@ export class ImapManager extends EventEmitter {
         try {
             const dir = path.join(getConfigDir(), "sending", accountId, label);
             fs.mkdirSync(dir, { recursive: true });
+            this.ensureRequeueScripts(dir);
             const now = new Date();
             const pad2 = (n) => String(n).padStart(2, "0");
             const ts = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
@@ -3837,6 +3852,68 @@ export class ImapManager extends EventEmitter {
             console.error(`  [sending] Failed to save copy: ${e.message}`);
         }
     }
+    /** Drop a requeue.cmd / requeue.sh into a sending/<acct>/<label>/ directory
+     *  so the user can re-queue a saved .eml/.ltr without remembering the
+     *  rmfmail -send syntax. Idempotent: only writes when missing.
+     *  The word is "requeue" — it puts the file back into the outbox queue;
+     *  it does NOT send a fresh copy bypassing the queue. */
+    ensureRequeueScripts(dir) {
+        const cmdPath = path.join(dir, "requeue.cmd");
+        if (!fs.existsSync(cmdPath)) {
+            const cmd = "@echo off\r\n" +
+                "rem Re-queue a saved .eml / .ltr for sending. Pass the filename:\r\n" +
+                "rem   requeue 20260527_140527-6599.ltr\r\n" +
+                "rem With no arg, lists files in this directory.\r\n" +
+                "if \"%~1\"==\"\" (\r\n" +
+                "  dir /b *.eml *.ltr 2>nul\r\n" +
+                "  exit /b 0\r\n" +
+                ")\r\n" +
+                "rmfmail -send \"%~dp0%~1\"\r\n";
+            fs.writeFileSync(cmdPath, cmd);
+        }
+        const shPath = path.join(dir, "requeue.sh");
+        if (!fs.existsSync(shPath)) {
+            const sh = "#!/bin/sh\n" +
+                "# Re-queue a saved .eml / .ltr for sending. Pass the filename:\n" +
+                "#   ./requeue.sh 20260527_140527-6599.ltr\n" +
+                "# With no arg, lists files in this directory.\n" +
+                "DIR=\"$(cd \"$(dirname \"$0\")\" && pwd)\"\n" +
+                "if [ -z \"$1\" ]; then\n" +
+                "  ls \"$DIR\"/*.eml \"$DIR\"/*.ltr 2>/dev/null | xargs -n1 basename 2>/dev/null\n" +
+                "  exit 0\n" +
+                "fi\n" +
+                "rmfmail -send \"$DIR/$1\"\n";
+            fs.writeFileSync(shPath, sh);
+            try {
+                fs.chmodSync(shPath, 0o755);
+            }
+            catch { /* */ }
+        }
+    }
+    /** Walk the sending tree at startup and drop a requeue.cmd/.sh into every
+     *  existing sending/<acct>/<label>/ directory. Without this the scripts
+     *  only appear on the next outgoing message, which doesn't help a user
+     *  who needs to re-queue a stuck letter from before the upgrade. */
+    seedRequeueScripts() {
+        try {
+            const root = path.join(getConfigDir(), "sending");
+            if (!fs.existsSync(root))
+                return;
+            for (const acct of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!acct.isDirectory())
+                    continue;
+                const acctDir = path.join(root, acct.name);
+                for (const label of fs.readdirSync(acctDir, { withFileTypes: true })) {
+                    if (!label.isDirectory())
+                        continue;
+                    this.ensureRequeueScripts(path.join(acctDir, label.name));
+                }
+            }
+        }
+        catch (e) {
+            console.error(`  [sending] seedRequeueScripts failed: ${e?.message || e}`);
+        }
+    }
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     async queueOutgoing(accountId, rawMessage) {
         // IMPORTANT: do NOT save a "debug copy" to sending/<acct>/queued/ here.
@@ -3848,13 +3925,38 @@ export class ImapManager extends EventEmitter {
         //   - ~/.mailx/outbox/<acct>/*.ltr (fallback when IMAP is unreachable)
         try {
             const outboxPath = await this.ensureOutbox(accountId);
+            const outboxFolder = this.findFolder(accountId, "outbox");
+            // Capture APPENDUID. The Sent folder path (processOutbox at line
+            // ~4150) does this and then calls insertLocalRowFromSource so the
+            // local Sent view is instantly populated without a sync round-trip.
+            // The Outbox path used to ONLY trigger fire-and-forget syncFolder,
+            // which on a wedged slow-lane (Bob 2026-05-27 14:11: syncAll held
+            // the lane for the whole afternoon) left the queued message
+            // invisible in the local Outbox view until next daemon restart.
+            let appendedUid = null;
+            const sourceStr = typeof rawMessage === "string"
+                ? rawMessage
+                : rawMessage.toString("utf-8");
             await this.withConnection(accountId, async (client) => {
-                await client.appendMessage(outboxPath, rawMessage, ["\\Seen"]);
-                console.log(`  [outbox] Queued message in ${outboxPath}`);
+                appendedUid = await client.appendMessage(outboxPath, rawMessage, ["\\Seen"]);
+                console.log(`  [outbox] Queued message in ${outboxPath}${appendedUid != null ? ` (UID ${appendedUid})` : ""}`);
             });
-            const outboxFolder = this.findFolder(accountId, "outbox");
             if (outboxFolder) {
-                this.syncFolder(accountId, outboxFolder.id).catch(() => { });
+                if (appendedUid != null) {
+                    // Inserts the row from the source bytes we already have +
+                    // the UID the server assigned. No sync, no slow-lane
+                    // dependency. The row shows up in the Outbox view instantly.
+                    await this.insertLocalRowFromSource(accountId, outboxFolder, appendedUid, sourceStr, ["\\Seen"])
+                        .catch((e) => {
+                        console.error(`  [outbox] Local Outbox row insert failed: ${e?.message || e} — falling back to broad sync`);
+                        this.syncFolder(accountId, outboxFolder.id).catch(() => { });
+                    });
+                }
+                else {
+                    // No APPENDUID (server doesn't support UIDPLUS, or APPEND
+                    // returned without one). Fall back to a broad sync.
+                    this.syncFolder(accountId, outboxFolder.id).catch(() => { });
+                }
             }
             return;
         }
@@ -4410,6 +4512,10 @@ export class ImapManager extends EventEmitter {
     startOutboxWorker() {
         if (this.outboxInterval)
             return;
+        // Seed requeue.cmd/.sh into every existing sending/<acct>/<label>/ dir
+        // so a user staring at a stuck .ltr can re-queue it without knowing
+        // the rmfmail -send syntax. Cheap, idempotent.
+        this.seedRequeueScripts();
         const processAll = async () => {
             const now = Date.now();
             // Auto-route any files dropped into the general (acct-agnostic)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -11,7 +11,7 @@
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.18",
     "@bobfrankston/mailx-settings": "^0.1.25",
-    "@bobfrankston/mailx-store": "^0.1.39",
+    "@bobfrankston/mailx-store": "^0.1.40",
     "@bobfrankston/iflow-direct": "^0.1.51",
     "@bobfrankston/tcp-transport": "^0.1.6",
     "@bobfrankston/smtp-direct": "^0.1.8",
@@ -39,7 +39,7 @@
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.18",
       "@bobfrankston/mailx-settings": "^0.1.25",
-      "@bobfrankston/mailx-store": "^0.1.39",
+      "@bobfrankston/mailx-store": "^0.1.40",
       "@bobfrankston/iflow-direct": "^0.1.51",
       "@bobfrankston/tcp-transport": "^0.1.6",
       "@bobfrankston/smtp-direct": "^0.1.8",