@bobfrankston/mailx 1.0.217 → 1.0.218

package/client/compose/compose.css

@@ -75,6 +75,22 @@ body {
     background: var(--color-bg-hover);
 }
 
+.compose-status {
+    margin-left: auto;
+    align-self: center;
+    font-size: var(--font-size-xs);
+    color: var(--color-text-muted);
+    padding: 0 var(--gap-md);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    max-width: 20em;
+}
+.compose-status.compose-status-error {
+    color: oklch(0.65 0.2 25);
+    font-weight: 500;
+}
+
 #btn-send {
     background: var(--color-accent);
     color: white;

package/client/compose/compose.html

@@ -38,6 +38,7 @@
         <button class="tb-btn" id="btn-send">Send</button>
         <button class="tb-btn" id="btn-attach">Attach</button>
         <button class="tb-btn" id="btn-discard">Discard</button>
+        <span id="compose-status" class="compose-status"></span>
     </div>
     <div id="compose-editor"></div>
 </body>

package/client/compose/compose.js

@@ -293,11 +293,22 @@ function applyInit(init) {
         editor.focus();
 }
 // ── Compose state (declared before init so the async IIFE can reference them) ──
+const DRAFT_INPUT_DEBOUNCE_MS = 1500; // save ~1.5s after the last keystroke
+const DRAFT_INTERVAL_MS = 5000; // safety-net interval save
 let draftUid = null;
 let draftId = null; // stable ID for dedup when APPENDUID unavailable
 let draftTimer = null;
+let draftDebounceTimer = null;
 let lastDraftContent = "";
 let draftSaving = false; // prevent concurrent saves
+let draftSaveFailed = false; // surfaced in the compose status tag
+function showDraftStatus(text, isError) {
+    const status = document.getElementById("compose-status");
+    if (!status)
+        return;
+    status.textContent = text;
+    status.classList.toggle("compose-status-error", isError);
+}
 async function saveDraft() {
     if (draftSaving)
         return; // previous save still in flight
@@ -323,12 +334,32 @@ async function saveDraft() {
             draftUid = data.draftUid;
         if (data?.draftId)
             draftId = data.draftId;
+        if (draftSaveFailed) {
+            draftSaveFailed = false;
+            showDraftStatus("Draft saved", false);
+        }
+        else
+            showDraftStatus(`Draft saved ${new Date().toLocaleTimeString()}`, false);
+    }
+    catch (e) {
+        // Surface the error — silent failures are how drafts get lost on IMAP hiccups.
+        // The local editing/ checkpoint already exists server-side regardless.
+        console.error("[draft] save failed:", e);
+        draftSaveFailed = true;
+        showDraftStatus(`Draft save failed: ${e?.message || e}`, true);
+        // Clear lastDraftContent so the next tick retries the same content
+        lastDraftContent = "";
     }
-    catch { /* ignore draft save errors */ }
     finally {
         draftSaving = false;
     }
 }
+/** Schedule a debounced save on user input — fires ~1.5s after the last keystroke. */
+function scheduleDraftSave() {
+    if (draftDebounceTimer)
+        clearTimeout(draftDebounceTimer);
+    draftDebounceTimer = setTimeout(() => { draftDebounceTimer = null; saveDraft(); }, DRAFT_INPUT_DEBOUNCE_MS);
+}
 // ── Initialize: always fetch real accounts from the API before applying init, then
 //    start the auto-save timer. Callers like message-viewer's Edit Draft pass
 //    init.accounts=[], so we can't trust what's in the init blob. ──
@@ -352,9 +383,26 @@ async function saveDraft() {
         populateFromSelect(accounts);
         toInput.focus();
     }
-    // Start auto-save after init so draftUid/draftId from the edit-draft flow are
-    // already in place when the first save fires.
-    draftTimer = setInterval(saveDraft, 5000);
+    // Wire debounced saves to input events — checkpoint ~1.5s after the last
+    // keystroke instead of waiting up to 5s for the interval tick.
+    toInput.addEventListener("input", scheduleDraftSave);
+    ccInput.addEventListener("input", scheduleDraftSave);
+    bccInput.addEventListener("input", scheduleDraftSave);
+    subjectInput.addEventListener("input", scheduleDraftSave);
+    editor.onContentChange(scheduleDraftSave);
+    // Safety-net interval: even with no user input, catch any edge cases.
+    draftTimer = setInterval(saveDraft, DRAFT_INTERVAL_MS);
+    // Flush the draft on window close so the last-typed content lands in
+    // editing/ even if the interval tick hasn't fired yet. navigator.sendBeacon
+    // is synchronous enough to survive unload; callNode IPC would be dropped.
+    window.addEventListener("beforeunload", () => {
+        if (draftDebounceTimer) {
+            clearTimeout(draftDebounceTimer);
+            draftDebounceTimer = null;
+        }
+        // fire-and-forget — can't await during unload
+        saveDraft();
+    });
 })();
 // ── Send ──
 document.getElementById("btn-send")?.addEventListener("click", async () => {

package/client/compose/editor.js

@@ -3,6 +3,79 @@
  * The compose window loads this module and calls createEditor() based on the user's setting.
  */
 function createQuillEditor(container) {
+    // Extra keybindings for formatting that Quill doesn't wire up by default.
+    // Ctrl+K (insert link) is the one most users expect; we also add shortcuts
+    // for strikethrough, lists, indent, color, and clear-formatting.
+    const extraBindings = {
+        insertLink: {
+            key: "K", shortKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                const current = this.quill.getFormat(range).link || "";
+                const url = prompt("URL (leave blank to remove link):", current);
+                if (url === null)
+                    return;
+                if (url === "")
+                    this.quill.format("link", false);
+                else
+                    this.quill.format("link", url);
+            },
+        },
+        removeLink: {
+            key: "K", shortKey: true, shiftKey: true,
+            handler: function () { this.quill.format("link", false); },
+        },
+        strike: {
+            key: "X", shortKey: true, shiftKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                const cur = this.quill.getFormat(range).strike;
+                this.quill.format("strike", !cur);
+            },
+        },
+        orderedList: {
+            key: "7", shortKey: true, shiftKey: true,
+            handler: function () { this.quill.format("list", "ordered"); },
+        },
+        bulletList: {
+            key: "8", shortKey: true, shiftKey: true,
+            handler: function () { this.quill.format("list", "bullet"); },
+        },
+        indent: {
+            key: "]", shortKey: true,
+            handler: function (range, context) {
+                this.quill.format("indent", (context.format.indent || 0) + 1);
+            },
+        },
+        outdent: {
+            key: "[", shortKey: true,
+            handler: function (range, context) {
+                this.quill.format("indent", Math.max(0, (context.format.indent || 0) - 1));
+            },
+        },
+        color: {
+            key: "C", shortKey: true, shiftKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                const current = this.quill.getFormat(range).color || "";
+                const color = prompt("Text color (name or #hex, blank to clear):", current);
+                if (color === null)
+                    return;
+                this.quill.format("color", color || false);
+            },
+        },
+        clearFormat: {
+            key: "\\", shortKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                this.quill.removeFormat(range.index, range.length || 0);
+            },
+        },
+    };
     const q = new Quill(container, {
         theme: "snow",
         placeholder: "Write your message...",
@@ -16,7 +89,8 @@ function createQuillEditor(container) {
                 [{ align: [] }],
                 ["blockquote", "link", "image"],
                 ["clean"]
-            ]
+            ],
+            keyboard: { bindings: extraBindings },
         }
     });
     // Make toolbar buttons non-tabbable so Tab goes straight to editor body

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.217",
+  "version": "1.0.218",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.2",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.22",
-    "@bobfrankston/msger": "^0.1.279",
+    "@bobfrankston/msger": "^0.1.280",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -78,7 +78,7 @@
       "@bobfrankston/iflow-node": "^0.1.2",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.22",
-      "@bobfrankston/msger": "^0.1.279",
+      "@bobfrankston/msger": "^0.1.280",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

package/packages/mailx-imap/index.d.ts

@@ -188,7 +188,9 @@ export declare class ImapManager extends EventEmitter {
     private saveSendingCopy;
     /** 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 — send from outbox/ and sending/queued/ */
+    /** Process local file queue — send from outbox/ only (IMAP-unreachable fallback).
+     *  Do NOT scan sending/<acct>/queued/ — that was causing every sent message to be
+     *  re-APPENDed to the IMAP Outbox on the next tick and delivered twice. */
     private processLocalQueue;
     /** Send a raw RFC 2822 message via SMTP for a given account */
     private sendRawViaSMTP;

package/packages/mailx-imap/index.js

@@ -1741,8 +1741,13 @@ export class ImapManager extends EventEmitter {
     }
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     async queueOutgoing(accountId, rawMessage) {
-        // Always save a debug copy
-        this.saveSendingCopy(accountId, rawMessage, "queued");
+        // IMPORTANT: do NOT save a "debug copy" to sending/<acct>/queued/ here.
+        // processLocalQueue also scans sending/<acct>/queued/, so writing there
+        // on every send caused the same message to be re-APPENDed to the IMAP
+        // Outbox on the next outbox tick — resulting in a duplicate send.
+        // The only two legitimate queue locations are:
+        //   - IMAP Outbox (primary, populated by APPEND below)
+        //   - ~/.mailx/outbox/<acct>/*.ltr (fallback when IMAP is unreachable)
         try {
             const outboxPath = await this.ensureOutbox(accountId);
             const client = this.createClient(accountId);
@@ -1766,7 +1771,7 @@ export class ImapManager extends EventEmitter {
         catch (e) {
             console.error(`  [outbox] IMAP queue failed: ${e.message} — saving locally`);
         }
-        // Fallback: save to local file queue
+        // Fallback: save to local file queue (processLocalQueue picks these up)
         const localQueue = path.join(getConfigDir(), "outbox", accountId);
         fs.mkdirSync(localQueue, { recursive: true });
         const now = new Date();
@@ -1775,17 +1780,15 @@ export class ImapManager extends EventEmitter {
         fs.writeFileSync(path.join(localQueue, filename), rawMessage);
         console.log(`  [outbox] Saved locally: ${filename}`);
     }
-    /** Process local file queue — send from outbox/ and sending/queued/ */
+    /** Process local file queue — send from outbox/ only (IMAP-unreachable fallback).
+     *  Do NOT scan sending/<acct>/queued/ — that was causing every sent message to be
+     *  re-APPENDed to the IMAP Outbox on the next tick and delivered twice. */
     async processLocalQueue(accountId) {
-        // Collect files from both outbox/ (legacy .ltr) and sending/queued/ (drop-in)
         const outboxDir = path.join(getConfigDir(), "outbox", accountId);
-        const queuedDir = path.join(getConfigDir(), "sending", accountId, "queued");
         const filesToSend = [];
-        for (const dir of [outboxDir, queuedDir]) {
-            if (!fs.existsSync(dir))
-                continue;
-            for (const file of fs.readdirSync(dir).filter(f => f.endsWith(".ltr") || f.endsWith(".eml"))) {
-                filesToSend.push({ dir, file });
+        if (fs.existsSync(outboxDir)) {
+            for (const file of fs.readdirSync(outboxDir).filter(f => f.endsWith(".ltr") || f.endsWith(".eml"))) {
+                filesToSend.push({ dir: outboxDir, file });
             }
         }
         if (filesToSend.length === 0)