@bobfrankston/mailx 1.0.217 → 1.0.219

package/client/.msger-window.json

@@ -1 +1 @@
-{"height":1344,"width":2151,"x":243,"y":28}
+{"height":1344,"width":2151,"x":194,"y":22}

package/client/app.js

@@ -371,30 +371,49 @@ function showComposeOverlay() {
     closeBtn.addEventListener("mouseenter", () => closeBtn.style.color = "#c00");
     closeBtn.addEventListener("mouseleave", () => closeBtn.style.color = "#666");
     closeBtn.addEventListener("click", () => {
+        // compose.ts handles the prompt (Save/Discard/Cancel) and then calls
+        // window.close() which is redirected to wrapper.remove() at line below.
+        // If the user cancels the prompt, closeCompose() is never called and
+        // the wrapper stays. Don't force-remove on a timer — that defeats Cancel.
         try {
             const win = frame.contentWindow;
             if (win)
                 win.dispatchEvent(new Event("compose-save-and-close"));
         }
         catch { /* */ }
-        setTimeout(() => wrapper.remove(), 500);
     });
     titleBar.appendChild(closeBtn);
-    // Drag to move
+    // Drag to move. While dragging we set pointer-events:none on the iframe
+    // so mouse events don't get swallowed by the inner document the moment
+    // the cursor crosses into the iframe region. Without that, drag only
+    // worked if you stayed on the title bar pixels, which is why it felt
+    // broken except at the lower-right (resize grip) corner.
     let dragX = 0, dragY = 0;
     titleBar.addEventListener("mousedown", (e) => {
         if (e.target === closeBtn)
             return;
         e.preventDefault();
-        dragX = e.clientX - wrapper.offsetLeft;
-        dragY = e.clientY - wrapper.offsetTop;
-        const onMove = (e) => {
-            wrapper.style.left = `${e.clientX - dragX}px`;
-            wrapper.style.top = `${e.clientY - dragY}px`;
+        const rect = wrapper.getBoundingClientRect();
+        dragX = e.clientX - rect.left;
+        dragY = e.clientY - rect.top;
+        // Clamp movement to the viewport so the title bar stays grabbable.
+        const clamp = (val, min, max) => Math.max(min, Math.min(max, val));
+        frame.style.pointerEvents = "none";
+        document.body.style.userSelect = "none";
+        const onMove = (ev) => {
+            ev.preventDefault();
+            const w = wrapper.offsetWidth;
+            const h = wrapper.offsetHeight;
+            const left = clamp(ev.clientX - dragX, 0, window.innerWidth - 40);
+            const top = clamp(ev.clientY - dragY, 0, window.innerHeight - 40);
+            wrapper.style.left = `${left}px`;
+            wrapper.style.top = `${top}px`;
             wrapper.style.bottom = "auto";
             wrapper.style.right = "auto";
         };
         const onUp = () => {
+            frame.style.pointerEvents = "";
+            document.body.style.userSelect = "";
             document.removeEventListener("mousemove", onMove);
             document.removeEventListener("mouseup", onUp);
         };

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 () => {
@@ -391,18 +439,65 @@ document.getElementById("btn-send")?.addEventListener("click", async () => {
         alert(`Send failed: ${e.message}`);
     }
 });
-// ── Discard ──
-document.getElementById("btn-discard")?.addEventListener("click", () => {
-    if (editor.getText().trim() || toInput.value) {
-        if (!confirm("Discard this message?"))
-            return;
+// ── Close handling ──
+/** True if the compose has anything worth asking about. */
+function composeHasContent() {
+    return !!(editor.getText().trim() || toInput.value.trim() || ccInput.value.trim() || bccInput.value.trim() || subjectInput.value.trim());
+}
+/** Ask Save/Discard/Cancel. Returns "save" | "discard" | "cancel". */
+function promptSaveOrDiscard() {
+    // Three-way prompt built from two native dialogs: OK(save) / Cancel → then
+    // for Cancel, ask "Really discard?" which becomes Discard / Cancel.
+    const saveIt = confirm("Save this message as a draft?\n\nOK = Save as draft\nCancel = continue...");
+    if (saveIt)
+        return "save";
+    const discard = confirm("Discard the message without saving?\n\nOK = Discard\nCancel = Keep editing");
+    if (discard)
+        return "discard";
+    return "cancel";
+}
+/** Handle any "close the compose" action (Discard button, Escape, X, window close). */
+async function handleCloseRequest() {
+    if (!composeHasContent()) {
+        closeCompose();
+        return true;
     }
-    window.close();
+    const choice = promptSaveOrDiscard();
+    if (choice === "cancel")
+        return false;
+    // Stop auto-save so it can't race with our explicit save/discard.
+    if (draftDebounceTimer) {
+        clearTimeout(draftDebounceTimer);
+        draftDebounceTimer = null;
+    }
+    if (draftTimer) {
+        clearInterval(draftTimer);
+        draftTimer = null;
+    }
+    if (choice === "save") {
+        try {
+            await saveDraft();
+        }
+        catch { /* already logged */ }
+    }
+    else {
+        // Discard: if we have a tracked draft, delete it so the orphan doesn't stick around.
+        if (draftUid || draftId) {
+            try {
+                await deleteDraft(getFromAccountId(), draftUid || 0, draftId || "");
+            }
+            catch { /* ignore */ }
+        }
+    }
+    closeCompose();
+    return true;
+}
+document.getElementById("btn-discard")?.addEventListener("click", () => {
+    handleCloseRequest();
 });
 // ── Save and close (X button from parent) ──
-window.addEventListener("compose-save-and-close", async () => {
-    await saveDraft();
-    closeCompose();
+window.addEventListener("compose-save-and-close", () => {
+    handleCloseRequest();
 });
 // ── Keyboard shortcuts ──
 document.addEventListener("keydown", (e) => {
@@ -410,17 +505,20 @@ document.addEventListener("keydown", (e) => {
         document.getElementById("btn-send")?.click();
     }
     if (e.key === "Escape") {
-        document.getElementById("btn-discard")?.click();
-    }
-    // Ctrl+K = trigger address completion
-    if (e.ctrlKey && e.key === "k") {
         e.preventDefault();
+        handleCloseRequest();
+    }
+    // Ctrl+K in an address field = trigger address completion.
+    // NOTE: Ctrl+K is ALSO the editor's "insert link" shortcut. Scope this handler
+    // strictly to the to/cc/bcc inputs so it doesn't shadow the editor binding when
+    // focus is in the body.
+    if (e.ctrlKey && (e.key === "k" || e.key === "K")) {
         const active = document.activeElement;
         const addressFields = [toInput, ccInput, bccInput];
-        const target = addressFields.includes(active) ? active : toInput;
-        target.focus();
-        // Force trigger autocomplete by dispatching input event
-        target.dispatchEvent(new Event("input"));
+        if (addressFields.includes(active)) {
+            e.preventDefault();
+            active.dispatchEvent(new Event("input"));
+        }
     }
 });
 //# sourceMappingURL=compose.js.map

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.219",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,11 +20,11 @@
     "postinstall": "node bin/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow-direct": "^0.1.7",
+    "@bobfrankston/iflow-direct": "^0.1.8",
     "@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.282",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -74,11 +74,11 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/iflow-direct": "^0.1.7",
+      "@bobfrankston/iflow-direct": "^0.1.8",
       "@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.282",
       "@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

@@ -1250,8 +1250,15 @@ export class ImapManager extends EventEmitter {
     /** Fetch a single message body on demand, caching in the store.
      *  Uses its own fresh connection — never blocked by background prefetch. */
     async fetchMessageBody(accountId, folderId, uid) {
-        // Already cached?
+        // Already cached? If the file is on disk but body_path wasn't written to
+        // the DB (e.g. from an interrupted earlier run), the prefetch loop would
+        // otherwise keep returning the same missing rows forever — once saw
+        // "gmail: 17266796 bodies cached" in the logs, which is the counter
+        // spinning on the same 100 rows.
         if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
+            const existingPath = this.bodyStore.getMessagePath?.(accountId, folderId, uid);
+            if (existingPath)
+                this.db.updateBodyPath(accountId, uid, existingPath);
             return this.bodyStore.getMessage(accountId, folderId, uid);
         }
         if (!this.configs.has(accountId))
@@ -1359,6 +1366,14 @@ export class ImapManager extends EventEmitter {
                 this.db.queueSyncAction(accountId, "delete", msg.uid, msg.folderId);
             }
         }
+        // Recalc folder counts so the tree badge updates immediately instead
+        // of showing stale numbers until the next full sync.
+        const sourceFolderIds = new Set(messages.map(m => m.folderId));
+        for (const fid of sourceFolderIds)
+            this.db.recalcFolderCounts(fid);
+        if (trash)
+            this.db.recalcFolderCounts(trash.id);
+        this.emit("folderCountsChanged", accountId, {});
         // Process all queued actions in one IMAP session
         this.debounceSyncActions(accountId);
     }
@@ -1375,6 +1390,13 @@ export class ImapManager extends EventEmitter {
         for (const msg of messages) {
             this.db.queueSyncAction(accountId, "move", msg.uid, msg.folderId, { targetFolderId });
         }
+        // Recalc folder counts (source folders + destination) so the tree
+        // badge updates immediately.
+        const sourceFolderIds = new Set(messages.map(m => m.folderId));
+        for (const fid of sourceFolderIds)
+            this.db.recalcFolderCounts(fid);
+        this.db.recalcFolderCounts(targetFolderId);
+        this.emit("folderCountsChanged", accountId, {});
         // Process all queued actions in one IMAP session
         this.debounceSyncActions(accountId);
     }
@@ -1741,8 +1763,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 +1793,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 +1802,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)

package/packages/mailx-store/file-store.d.ts

@@ -8,6 +8,8 @@ export declare class FileMessageStore implements MessageStore {
     private basePath;
     constructor(basePath: string);
     private messagePath;
+    /** Public lookup of the on-disk path without touching the file. */
+    getMessagePath(accountId: string, folderId: number, uid: number): string;
     putMessage(accountId: string, folderId: number, uid: number, raw: Buffer): Promise<string>;
     getMessage(accountId: string, folderId: number, uid: number): Promise<Buffer>;
     deleteMessage(accountId: string, folderId: number, uid: number): Promise<void>;

package/packages/mailx-store/file-store.js

@@ -14,6 +14,10 @@ export class FileMessageStore {
     messagePath(accountId, folderId, uid) {
         return path.join(this.basePath, accountId, String(folderId), `${uid}.eml`);
     }
+    /** Public lookup of the on-disk path without touching the file. */
+    getMessagePath(accountId, folderId, uid) {
+        return this.messagePath(accountId, folderId, uid);
+    }
     async putMessage(accountId, folderId, uid, raw) {
         const filePath = this.messagePath(accountId, folderId, uid);
         fs.mkdirSync(path.dirname(filePath), { recursive: true });