@bobfrankston/mailx-imap 0.1.67 → 0.1.68

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

@@ -3827,6 +3827,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 +3838,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 +3911,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 +4498,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.68",
   "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",