@bobfrankston/mailx 1.0.333 → 1.0.336

package/client/compose/compose.js

@@ -80,6 +80,45 @@ await loadEditorAssets(editorType);
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
 const editor = await createEditor(container, editorType);
+// Ctrl+scroll / Ctrl+= / Ctrl+- / Ctrl+0 zoom for the compose editor body.
+// Persists per-session in localStorage so zoom survives window pop/close cycles.
+(() => {
+    const STORAGE_KEY = "mailx.compose.zoom";
+    const MIN = 0.5, MAX = 3, STEP = 0.1;
+    let zoom = parseFloat(localStorage.getItem(STORAGE_KEY) || "1") || 1;
+    const applyZoom = () => {
+        container.style.fontSize = `${zoom}em`;
+        localStorage.setItem(STORAGE_KEY, String(zoom));
+    };
+    applyZoom();
+    container.addEventListener("wheel", (e) => {
+        if (!e.ctrlKey)
+            return;
+        e.preventDefault();
+        const delta = e.deltaY < 0 ? STEP : -STEP;
+        zoom = Math.min(MAX, Math.max(MIN, Math.round((zoom + delta) * 10) / 10));
+        applyZoom();
+    }, { passive: false });
+    document.addEventListener("keydown", (e) => {
+        if (!(e.ctrlKey || e.metaKey))
+            return;
+        if (e.key === "=" || e.key === "+") {
+            zoom = Math.min(MAX, zoom + STEP);
+            applyZoom();
+            e.preventDefault();
+        }
+        else if (e.key === "-") {
+            zoom = Math.max(MIN, zoom - STEP);
+            applyZoom();
+            e.preventDefault();
+        }
+        else if (e.key === "0") {
+            zoom = 1;
+            applyZoom();
+            e.preventDefault();
+        }
+    });
+})();
 // ── Populate from init data ──
 // From field is a free-text input with a <datalist> of known accounts. The
 // user can pick a preset or type an arbitrary "Name <addr@domain>" — no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.333",
+  "version": "1.0.336",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -39,7 +39,7 @@
     "@bobfrankston/tcp-transport": "^0.1.4",
     "@bobfrankston/node-tcp-transport": "^0.1.4",
     "@bobfrankston/smtp-direct": "^0.1.4",
-    "@bobfrankston/mailx-sync": "^0.1.7"
+    "@bobfrankston/mailx-sync": "^0.1.8"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6"
@@ -103,7 +103,7 @@
       "@bobfrankston/tcp-transport": "^0.1.4",
       "@bobfrankston/node-tcp-transport": "^0.1.4",
       "@bobfrankston/smtp-direct": "^0.1.4",
-      "@bobfrankston/mailx-sync": "^0.1.7"
+      "@bobfrankston/mailx-sync": "^0.1.8"
     }
   }
 }

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

@@ -187,7 +187,11 @@ export declare class ImapManager extends EventEmitter {
         uid: number;
         folderId: number;
     }[]): Promise<void>;
-    /** Bulk move messages — local-first, single IMAP connection for all */
+    /** Bulk move messages — queues the IMAP action only. The service layer
+     *  (MailxService.moveMessages) owns the local DB mutation via
+     *  updateMessageFolder; this method used to ALSO deleteMessage here,
+     *  which wiped the row the service just updated — the message vanished
+     *  on the next reconcile and "spam folder empty" was the symptom. */
     moveMessages(accountId: string, messages: {
         uid: number;
         folderId: number;
@@ -197,7 +201,8 @@ export declare class ImapManager extends EventEmitter {
     private debounceSyncActions;
     /** Move a message to Trash (delete) — local-first, queues IMAP sync */
     trashMessage(accountId: string, folderId: number, uid: number): Promise<void>;
-    /** Move a message between folders — local-first, queues IMAP sync */
+    /** Move a message between folders — queues IMAP sync only. Service
+     *  layer owns the local DB update (see MailxService.moveMessage). */
     moveMessage(accountId: string, uid: number, fromFolderId: number, toFolderId: number): Promise<void>;
     /** Move message across accounts using iflow's moveMessageToServer */
     moveMessageCrossAccount(fromAccountId: string, uid: number, fromFolderId: number, toAccountId: string, toFolderId: number): Promise<void>;
@@ -218,7 +223,13 @@ export declare class ImapManager extends EventEmitter {
      *  Tries the specific UID first, then falls back to searchByHeader so orphaned copies
      *  from earlier failed autosaves are cleaned up at the same time. */
     deleteDraft(accountId: string, draftUid: number, draftId?: string): Promise<void>;
-    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP */
+    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP.
+     *  Single path: write `~/.mailx/outbox/<acct>/*.ltr` synchronously, then
+     *  kick processLocalQueue. The file IS the queue — durable across crashes,
+     *  visible in the filesystem, consumed by the existing outbox worker that
+     *  handles both IMAP-APPEND (non-Gmail) and direct SMTP (Gmail). The old
+     *  sync_actions "send" branch was removed because it duplicated the same
+     *  work and risked double-send when both paths fired on the same message. */
     queueOutgoingLocal(accountId: string, rawMessage: string): void;
     /** Guard against concurrent processSendActions for the same account */
     private sendingAccounts;

package/packages/mailx-imap/index.js

@@ -2052,27 +2052,18 @@ export class ImapManager extends EventEmitter {
         // Process all queued actions in one IMAP session
         this.debounceSyncActions(accountId);
     }
-    /** Bulk move messages — local-first, single IMAP connection for all */
+    /** Bulk move messages — queues the IMAP action only. The service layer
+     *  (MailxService.moveMessages) owns the local DB mutation via
+     *  updateMessageFolder; this method used to ALSO deleteMessage here,
+     *  which wiped the row the service just updated — the message vanished
+     *  on the next reconcile and "spam folder empty" was the symptom. */
     async moveMessages(accountId, messages, targetFolderId) {
         if (messages.length === 0)
             return;
-        // Local first
-        for (const msg of messages) {
-            this.db.deleteMessage(accountId, msg.uid);
-        }
-        console.log(`  Moved ${messages.length} messages locally (→ folder ${targetFolderId})`);
-        // Queue IMAP actions
         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
+        console.log(`  [move] ${accountId}: queued IMAP MOVE for ${messages.length} message(s) → folder ${targetFolderId}`);
         this.debounceSyncActions(accountId);
     }
     /** Debounced sync actions — batches rapid local changes into one IMAP operation */
@@ -2092,25 +2083,25 @@ export class ImapManager extends EventEmitter {
         // Local first — remove from DB immediately
         this.db.deleteMessage(accountId, uid);
         this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
-        console.log(`  Deleted message UID ${uid} locally`);
-        // Queue IMAP action
+        // Queue IMAP action + log the resolution so "I deleted a message and
+        // now it's in neither trash nor deleted" is diagnosable from the log.
         if (trash && trash.id !== folderId) {
+            const trashFolder = this.db.getFolders(accountId).find(f => f.id === trash.id);
             this.db.queueSyncAction(accountId, "move", uid, folderId, { targetFolderId: trash.id });
+            console.log(`  [trash] ${accountId} UID ${uid}: queued MOVE to "${trashFolder?.path || trash.path}" (id=${trash.id}, specialUse=trash)`);
         }
         else {
             this.db.queueSyncAction(accountId, "delete", uid, folderId);
+            console.log(`  [trash] ${accountId} UID ${uid}: queued EXPUNGE in folder ${folderId} (already in trash or no trash configured)`);
         }
         // Debounced sync — batches multiple deletes into one IMAP session
         this.debounceSyncActions(accountId);
     }
-    /** Move a message between folders — local-first, queues IMAP sync */
+    /** Move a message between folders — queues IMAP sync only. Service
+     *  layer owns the local DB update (see MailxService.moveMessage). */
     async moveMessage(accountId, uid, fromFolderId, toFolderId) {
-        // Local first
-        this.db.deleteMessage(accountId, uid);
-        console.log(`  Moved UID ${uid} locally (folder ${fromFolderId} → ${toFolderId})`);
-        // Queue IMAP action
         this.db.queueSyncAction(accountId, "move", uid, fromFolderId, { targetFolderId: toFolderId });
-        // Debounced sync — batches multiple moves into one IMAP session
+        console.log(`  [move] ${accountId}: queued IMAP MOVE UID ${uid} folder ${fromFolderId} → ${toFolderId}`);
         this.debounceSyncActions(accountId);
     }
     /** Move message across accounts using iflow's moveMessageToServer */
@@ -2221,13 +2212,26 @@ export class ImapManager extends EventEmitter {
                             break;
                         case "move": {
                             const target = folders.find(f => f.id === action.targetFolderId);
-                            if (target) {
-                                const msg = await client.fetchMessageByUid(folder.path, action.uid, { source: false });
-                                if (msg) {
-                                    await client.moveMessage(msg, folder.path, target.path);
-                                    console.log(`  [sync] Moved UID ${action.uid}: ${folder.path} → ${target.path}`);
-                                }
+                            if (!target) {
+                                // Target folder gone — treat as permanent failure so the
+                                // action doesn't loop forever. User must re-delete manually.
+                                console.error(`  [sync] Move target folder ${action.targetFolderId} missing — dropping action UID ${action.uid}`);
+                                throw new Error(`move target folder ${action.targetFolderId} not found`);
+                            }
+                            const msg = await client.fetchMessageByUid(folder.path, action.uid, { source: false });
+                            if (!msg) {
+                                // Message no longer in source folder. Two real cases:
+                                //   (a) another client already moved/deleted it — nothing to do,
+                                //       just mark the action done.
+                                //   (b) the server is lying (transient SELECT miss) — the retry
+                                //       will pick it up. We can't tell these apart from one fetch,
+                                //       so log loud and treat as (a) after the first failure; the
+                                //       attempts counter handles (b) via the failSyncAction path.
+                                console.log(`  [sync] Move UID ${action.uid} in ${folder.path}: message gone (attempt ${action.attempts + 1}); dropping action`);
+                                break;
                             }
+                            await client.moveMessage(msg, folder.path, target.path);
+                            console.log(`  [sync] Moved UID ${action.uid}: ${folder.path} → ${target.path}`);
                             break;
                         }
                         case "flags":
@@ -2409,13 +2413,23 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
-    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP */
+    /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP.
+     *  Single path: write `~/.mailx/outbox/<acct>/*.ltr` synchronously, then
+     *  kick processLocalQueue. The file IS the queue — durable across crashes,
+     *  visible in the filesystem, consumed by the existing outbox worker that
+     *  handles both IMAP-APPEND (non-Gmail) and direct SMTP (Gmail). The old
+     *  sync_actions "send" branch was removed because it duplicated the same
+     *  work and risked double-send when both paths fired on the same message. */
     queueOutgoingLocal(accountId, rawMessage) {
-        // Use folderId=0 and uid=Date.now() as placeholder — the worker will handle the real IMAP append
-        this.db.queueSyncAction(accountId, "send", Date.now(), 0, { rawMessage });
-        console.log(`  [outbox] Queued locally for ${accountId}`);
-        // Try immediate processing
-        this.processSendActions(accountId).catch(() => { });
+        const outboxDir = path.join(getConfigDir(), "outbox", accountId);
+        fs.mkdirSync(outboxDir, { recursive: true });
+        const now = new Date();
+        const pad2 = (n) => String(n).padStart(2, "0");
+        const filename = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}-${String(Math.floor(Math.random() * 10000)).padStart(4, "0")}.ltr`;
+        const filePath = path.join(outboxDir, filename);
+        fs.writeFileSync(filePath, rawMessage);
+        console.log(`  [outbox] Queued ${filePath}`);
+        this.processLocalQueue(accountId).catch((e) => console.error(`  [outbox] processLocalQueue error: ${e?.message || e}`));
     }
     /** Guard against concurrent processSendActions for the same account */
     sendingAccounts = new Set();