@bobfrankston/rmfmail 1.2.248 → 1.2.251

package/client/components/message-list.ts

@@ -9,6 +9,7 @@ import type { ListMessage } from "../lib/message-state.js";
 import { showMessage as viewerShow, clearViewer as viewerClear } from "./message-viewer.js";
 import { showContextMenu, type MenuItem } from "./context-menu.js";
 import { pickFolder } from "./folder-picker.js";
+import { foldText } from "../lib/fold-text.js";
 import { seenOf, flaggedOf, draftOf, setSeen, setFlagged } from "@bobfrankston/mailx-types";
 
 type MessageSelectHandler = (accountId: string, uid: number, folderId: number) => void;
@@ -43,7 +44,7 @@ let liveFilterText = "";
  *  it (background reloads resume). Lower-cased once here so the per-row test
  *  is a plain substring check. */
 export function setLiveFilter(query: string): void {
-    liveFilterText = (query || "").trim().toLowerCase();
+    liveFilterText = foldText((query || "").trim());
     const body = document.getElementById("ml-body");
     if (body) applyLiveFilter(body);
 }
@@ -57,7 +58,7 @@ function applyLiveFilter(body: HTMLElement): void {
         return;
     }
     for (const row of body.querySelectorAll(".ml-row")) {
-        const text = row.textContent?.toLowerCase() || "";
+        const text = foldText(row.textContent);
         (row as HTMLElement).classList.toggle("filter-hidden", !text.includes(liveFilterText));
     }
 }

package/client/components/message-viewer.js

@@ -13,6 +13,46 @@ import { showContextMenu } from "./context-menu.js";
 import { updateMessageFlags as stateUpdateFlags } from "../lib/message-state.js";
 import { setRowSeen } from "./message-list.js";
 import { setSeen, seenOf } from "@bobfrankston/mailx-types";
+// ── "Copy image" bridge ──
+// The preview iframe encodes the image and posts the bytes back; these track
+// the outstanding request. Keyed by id because a user can hit Copy image on a
+// second picture before the first encode finishes.
+const pendingImageCopies = new Map();
+let imageCopySeq = 0;
+const IMAGE_COPY_TIMEOUT_MS = 8000;
+window.addEventListener("message", (e) => {
+    const d = e.data;
+    if (!d || d.type !== "previewImageBytes")
+        return;
+    const resolve = pendingImageCopies.get(d.reqId);
+    if (!resolve)
+        return; // timed out already
+    pendingImageCopies.delete(d.reqId);
+    resolve({ blob: d.blob, error: d.error });
+});
+/** Ask the preview iframe to encode the image the user right-clicked. Resolves
+ *  with a PNG blob, or an error string when the iframe can't read it (a remote
+ *  image taints the canvas — caller falls back to the daemon). */
+function requestImageFromPreview(sourceWindow, src) {
+    if (!sourceWindow)
+        return Promise.resolve({ error: "preview window is gone" });
+    const reqId = ++imageCopySeq;
+    return new Promise(resolve => {
+        const done = (r) => { clearTimeout(timer); resolve(r); };
+        const timer = setTimeout(() => {
+            pendingImageCopies.delete(reqId);
+            resolve({ error: "the preview did not answer in time" });
+        }, IMAGE_COPY_TIMEOUT_MS);
+        pendingImageCopies.set(reqId, done);
+        try {
+            sourceWindow.postMessage({ type: "previewCommand", cmd: "copyImage", reqId, src }, "*");
+        }
+        catch (err) {
+            pendingImageCopies.delete(reqId);
+            done({ error: err?.message || String(err) });
+        }
+    });
+}
 /** Currently displayed message (for reply/forward) */
 let currentMessage = null;
 let currentAccountId = "";
@@ -189,25 +229,77 @@ export function showPreviewBodyMenu(absX, absY, selectedText, sourceWindow, link
             }
         })();
         items.push({ label: "Copy image", action: async () => {
-                try {
-                    const resp = await fetch(imgSrc);
-                    const blob = await resp.blob();
-                    // Transcode to PNG via canvas — WebView2's clipboard image
-                    // write is reliable for PNG; arbitrary source types (webp,
-                    // gif, jpeg) may not round-trip directly.
+                // Three ways in, because no single one covers every image a
+                // letter can carry (Bob 2026-08-11: right-click → copy just
+                // failed). In order of what works most often:
+                //   1. the preview iframe encodes its own already-decoded
+                //      <img> — the only path that works for inline cid:/data:
+                //      images, and it costs no network at all;
+                //   2. the parent fetches the src — fine for data: and for
+                //      hosts that send CORS headers;
+                //   3. the daemon fetches it — remote images are cross-origin
+                //      with no CORS headers, so the WebView can never read
+                //      their bytes, but Node has no such restriction.
+                const attempts = [];
+                const writePng = async (png) => {
+                    await navigator.clipboard.write([new ClipboardItem({ "image/png": png })]);
+                };
+                // Transcode to PNG via canvas — WebView2's clipboard image
+                // write is reliable for PNG; arbitrary source types (webp,
+                // gif, jpeg) may not round-trip directly.
+                const toPng = async (blob) => {
+                    if (blob.type === "image/png")
+                        return blob;
                     const bmp = await createImageBitmap(blob);
                     const canvas = document.createElement("canvas");
                     canvas.width = bmp.width;
                     canvas.height = bmp.height;
                     canvas.getContext("2d").drawImage(bmp, 0, 0);
-                    const png = await new Promise((res, rej) => canvas.toBlob(b => b ? res(b) : rej(new Error("toBlob failed")), "image/png"));
-                    await navigator.clipboard.write([new ClipboardItem({ "image/png": png })]);
+                    return await new Promise((res, rej) => canvas.toBlob(b => b ? res(b) : rej(new Error("toBlob failed")), "image/png"));
+                };
+                // 1. Ask the preview to encode it.
+                const fromPreview = await requestImageFromPreview(sourceWindow, imgSrc);
+                if (fromPreview.blob) {
+                    try {
+                        await writePng(fromPreview.blob);
+                        return;
+                    }
+                    catch (e) {
+                        attempts.push(`clipboard write: ${e?.message || e}`);
+                    }
+                }
+                else {
+                    attempts.push(`preview: ${fromPreview.error}`);
+                }
+                // 2. Fetch it from here.
+                try {
+                    const resp = await fetch(imgSrc);
+                    if (!resp.ok)
+                        throw new Error(`HTTP ${resp.status}`);
+                    await writePng(await toPng(await resp.blob()));
+                    return;
                 }
                 catch (e) {
-                    // cid: inline images can't be fetched from the parent
-                    // context — surface rather than fail silently.
-                    alert(`Couldn't copy image: ${e?.message || e}${imgSrc.startsWith("cid:") ? " (inline cid: image — try Save instead, or right-click → save in the message)" : ""}`);
+                    attempts.push(`direct fetch: ${e?.message || e}`);
+                }
+                // 3. Let the daemon fetch it (remote images, no CORS).
+                if (/^https?:/i.test(imgSrc)) {
+                    try {
+                        const { fetchRemoteImage } = await import("../lib/api-client.js");
+                        const r = await fetchRemoteImage(imgSrc);
+                        if (!r?.base64)
+                            throw new Error(r?.error || "no data returned");
+                        const bytes = Uint8Array.from(atob(r.base64), c => c.charCodeAt(0));
+                        await writePng(await toPng(new Blob([bytes], { type: r.contentType || "image/png" })));
+                        return;
+                    }
+                    catch (e) {
+                        attempts.push(`via rmfmail: ${e?.message || e}`);
+                    }
                 }
+                // Name what was tried — a bare "couldn't copy" leaves nothing
+                // to act on, and these three failure modes need different fixes.
+                alert(`Couldn't copy that image.\n\n${attempts.map(a => `• ${a}`).join("\n")}`);
             } }, { label: `Save image as "${guessImgName}"…`, action: () => {
                 const a = document.createElement("a");
                 a.href = imgSrc;
@@ -2372,6 +2464,9 @@ ${csp}
     // dismissers it sees. The parent's debounced 500 ms show-timer still
     // suppresses flicker.
     var lastHoveredHref = "";
+    // The <img> under the most recent right-click, kept so a later
+    // "copyImage" command can encode that exact element (see below).
+    var lastContextImg = null;
     function postLinkHover(href, rect, mouse) {
         // Only post on transitions to avoid spamming the parent on every
         // mousemove inside a link.
@@ -2447,6 +2542,45 @@ ${csp}
                     s.addRange(r);
                 }
             } catch (_) {}
+        } else if (d.cmd === "copyImage") {
+            // Encode the right-clicked image HERE and hand the parent the
+            // bytes. The parent can't fetch it itself: an inline image is a
+            // multi-megabyte data: URI it would have to re-download through
+            // the message channel, and a remote one is cross-origin with no
+            // CORS headers, so a parent-side fetch rejects. This img is
+            // already decoded here, so a canvas draw needs no network at all.
+            // (A remote image DOES taint the canvas — toBlob then throws and
+            // the parent falls back to fetching it through the daemon.)
+            var target = lastContextImg;
+            if (!target && d.src) {
+                var all = document.getElementsByTagName("img");
+                for (var i = 0; i < all.length; i++) {
+                    if (all[i].currentSrc === d.src || all[i].src === d.src) { target = all[i]; break; }
+                }
+            }
+            if (!target) {
+                window.parent.postMessage({ type: "previewImageBytes", reqId: d.reqId, error: "image element not found" }, "*");
+                return;
+            }
+            try {
+                var cv = document.createElement("canvas");
+                cv.width = target.naturalWidth || target.width;
+                cv.height = target.naturalHeight || target.height;
+                if (!cv.width || !cv.height) throw new Error("image has no decoded size yet");
+                cv.getContext("2d").drawImage(target, 0, 0);
+                cv.toBlob(function (b) {
+                    if (!b) {
+                        window.parent.postMessage({ type: "previewImageBytes", reqId: d.reqId, error: "encode failed" }, "*");
+                        return;
+                    }
+                    window.parent.postMessage({ type: "previewImageBytes", reqId: d.reqId, blob: b }, "*");
+                }, "image/png");
+            } catch (err) {
+                window.parent.postMessage({
+                    type: "previewImageBytes", reqId: d.reqId,
+                    error: (err && err.message) ? err.message : String(err)
+                }, "*");
+            }
         }
     });
 
@@ -2465,6 +2599,10 @@ ${csp}
         try { rect = e.target.getBoundingClientRect ? e.target.getBoundingClientRect() : rect; } catch (_) {}
         var a = e.target && e.target.closest ? e.target.closest("a[href]") : null;
         var img = e.target && e.target.closest ? e.target.closest("img") : null;
+        // Remember the element itself, not just its src — "Copy image" encodes
+        // this exact <img>, and matching by src would pick the wrong one when
+        // a letter repeats the same image (spacers, logos, tracking pixels).
+        lastContextImg = img;
         var sel = (window.getSelection && window.getSelection()) ? window.getSelection().toString() : "";
         window.parent.postMessage({
             type: "previewContextMenu",