@bobfrankston/rmfmail 1.2.215 → 1.2.217

package/client/app.ts

@@ -1758,10 +1758,24 @@ async function deleteSelectedMessages(): Promise<void> {
     }
 }
 
+/** Serialize Ctrl+Z presses. Each undo is several awaited IPCs plus a
+ *  revealMessage + folder reload; firing them concurrently (hold Ctrl and tap Z
+ *  three times to walk back three deletions) had them interleaving — two
+ *  reveals fighting over the list position, reloads landing out of order. The
+ *  stack is LIFO and each queued call pops its own entry when its turn comes,
+ *  so N presses undo the N most recent actions, in order. */
+let undoChain: Promise<void> = Promise.resolve();
+function queueUndo(): void {
+    undoChain = undoChain.then(() => performUndo()).catch(() => { /* performUndo reports its own failures */ });
+}
+
 async function performUndo(): Promise<void> {
     const op = popUndo();
     if (!op) return;
     const statusSync = document.getElementById("status-sync");
+    // "3 more to undo" — without it, a stack of undone deletions is invisible
+    // and the user can't tell whether pressing Ctrl+Z again will do anything.
+    const remaining = undoStack.length ? ` — ${undoStack.length} more to undo` : "";
     try {
         if (op.kind === "delete") {
             // payload is the full batch (was a single object pre-2026-06-12;
@@ -1771,9 +1785,9 @@ async function performUndo(): Promise<void> {
             for (const m of msgs) {
                 await undeleteMessage(m.accountId, m.uid, m.folderId);
             }
-            if (statusSync) statusSync.textContent = msgs.length === 1
+            if (statusSync) statusSync.textContent = (msgs.length === 1
                 ? "Message restored"
-                : `Restored ${msgs.length} messages`;
+                : `Restored ${msgs.length} messages`) + remaining;
             // Position at what was just restored — an undo whose effect lands
             // off-screen (or in a folder you've since left) reads as a no-op.
             // Reveal the first of the batch; the rest are in the same view.
@@ -1785,19 +1799,24 @@ async function performUndo(): Promise<void> {
                 return;
             }
         } else if (op.kind === "move") {
-            const { messages } = op.payload;
+            const { messages, targetFolderId } = op.payload;
             const byDest = new Map<string, { accountId: string; folderId: number; uids: number[] }>();
             for (const m of messages) {
                 const key = `${m.accountId}:${m.sourceFolderId}`;
                 if (!byDest.has(key)) byDest.set(key, { accountId: m.accountId, folderId: m.sourceFolderId, uids: [] });
                 byDest.get(key)!.uids.push(m.uid);
             }
-            const { moveMessages, moveMessage } = await import("./lib/api-client.js");
+            const { moveMessages } = await import("./lib/api-client.js");
             for (const group of byDest.values()) {
-                if (group.uids.length === 1) await moveMessage(group.accountId, group.uids[0], group.folderId);
-                else await moveMessages(group.accountId, group.uids, group.folderId);
+                // The messages are sitting in targetFolderId right now, so that
+                // is their SOURCE for the reverse move — pass it explicitly.
+                // Without it the service resolves each row by (account, uid)
+                // alone and a same-numbered uid in another folder can be moved
+                // instead (the flag-clear / spam-move wrong-folder class).
+                const currentFolderIds = targetFolderId ? group.uids.map(() => targetFolderId) : undefined;
+                await moveMessages(group.accountId, group.uids, group.folderId, currentFolderIds);
             }
-            if (statusSync) statusSync.textContent = `Undid move of ${messages.length} message${messages.length !== 1 ? "s" : ""}`;
+            if (statusSync) statusSync.textContent = `Undid move of ${messages.length} message${messages.length !== 1 ? "s" : ""}${remaining}`;
             // Same positioning rule as undo-delete: show the message back in
             // its original folder.
             const firstMoved = messages[0];
@@ -1820,7 +1839,7 @@ async function performUndo(): Promise<void> {
                 setRowFlagged(entry.accountId, entry.uid, entry.prevFlagged);
                 messageState.updateMessageFlags(entry.accountId, entry.uid, flagsAfter);
             }
-            if (statusSync) statusSync.textContent = `Undid flag change on ${op.payload.length} message${op.payload.length !== 1 ? "s" : ""}`;
+            if (statusSync) statusSync.textContent = `Undid flag change on ${op.payload.length} message${op.payload.length !== 1 ? "s" : ""}${remaining}`;
         }
         reloadCurrentFolder();
     } catch (e: any) {
@@ -2107,11 +2126,30 @@ async function spamSelectedMessages(): Promise<void> {
         g.folderIds.push(msg.folderId);
         byAccount.set(msg.accountId, g);
     }
-    if (statusSync) statusSync.textContent = `Spam: ${snapshot.length} queued — pending server sync`;
+    // Marking spam is just a move to the \Junk folder (service-side
+    // markAsSpamMessages), so its inverse is the move back — the same undo op
+    // a drag-to-folder move records. Pushed BEFORE the IPC, not in its `.then`:
+    // a misfired spam click is exactly the case where the user reaches for
+    // Ctrl+Z immediately, and the local move has already happened by then
+    // (Bob 2026-08-03: "^z should undo send-to-spam"). The move branch of
+    // performUndo restores each message to its own sourceFolderId, so a
+    // selection spanning folders comes back correctly; targetFolderId is only
+    // known once the service answers and the undo doesn't need it.
+    const spamUndo: MovedBatch = {
+        messages: snapshot.map(m => ({ accountId: m.accountId, uid: m.uid, sourceFolderId: m.folderId })),
+        targetAccountId: snapshot[0].accountId,
+        targetFolderId: 0,   // filled in below — only the service knows which folder is \Junk
+    };
+    pushUndo({ kind: "move", at: Date.now(), payload: spamUndo });
+    if (statusSync) statusSync.textContent = `Spam: ${snapshot.length} queued — Ctrl+Z to undo`;
     for (const [accountId, { uids, folderIds }] of byAccount) {
         markAsSpamMessages(accountId, uids, folderIds)
             .then(result => {
                 console.log(`[spam] ${accountId}: moved ${result?.moved ?? uids.length} to folderId=${result?.targetFolderId}`);
+                // Now we know where they landed. The undo op is still on the
+                // stack (same object) — record it so the reverse move names the
+                // messages' current folder instead of guessing by uid alone.
+                if (result?.targetFolderId) spamUndo.targetFolderId = result.targetFolderId;
             })
             .catch(e => {
                 console.error(`[spam] ${accountId} failed:`, e);
@@ -3899,7 +3937,7 @@ document.addEventListener("keydown", (e) => {
         const composeOpen = !!document.querySelector(".compose-overlay");
         if (!inEditable && !composeOpen && undoStack.length > 0) {
             e.preventDefault();
-            performUndo();
+            queueUndo();
         }
     }
     // F5 = Sync
@@ -4113,7 +4151,7 @@ function openShortcutsDialog(): void {
                 ["Forward", "Ctrl+F"],
                 ["Sync", "F5"],
                 ["Delete selected", "Del or Ctrl+D"],
-                ["Undo last delete/move", "Ctrl+Z"],
+                ["Undo delete / move / spam / flag (repeat to go back further)", "Ctrl+Z"],
                 ["Toggle read/unread", "R"],
                 ["Toggle flag (★)", "(⚑ button in viewer)"],
                 ["Select all visible", "Ctrl+A"],

package/client/compose/compose.bundle.js

@@ -1357,8 +1357,9 @@ function deleteMessages(accountId, uids, folderIds) {
   return ipc().deleteMessages?.(accountId, uids, folderIds);
 }
 function moveMessages(accountId, uids, targetFolderId, folderIds, targetAccountId) {
-  if (uids.length === 1)
+  if (uids.length === 1 && (targetAccountId || !folderIds?.length)) {
     return moveMessage(accountId, uids[0], targetFolderId, targetAccountId);
+  }
   return ipc().moveMessages?.(accountId, uids, targetFolderId, folderIds);
 }
 function markAsSpamMessages(accountId, uids, folderIds) {