@bobfrankston/mailx 1.0.211 → 1.0.213

package/client/.msger-window.json

@@ -1 +1 @@
-{"height":1344,"width":2151,"x":380,"y":46}
+{"height":1344,"width":2151,"x":304,"y":36}

package/client/components/message-viewer.js

@@ -37,6 +37,96 @@ export function initViewer() {
         // "messages" change (sync reload) — don't touch the viewer
     });
 }
+// Zoom is persisted across messages via localStorage
+const ZOOM_KEY = "mailx-preview-zoom";
+const ZOOM_MIN = 0.5;
+const ZOOM_MAX = 3.0;
+const ZOOM_STEP = 0.1;
+let previewZoom = clampZoom(parseFloat(localStorage.getItem(ZOOM_KEY) || "1"));
+function clampZoom(z) {
+    if (!Number.isFinite(z) || z <= 0)
+        return 1;
+    return Math.max(ZOOM_MIN, Math.min(ZOOM_MAX, Math.round(z * 100) / 100));
+}
+function applyZoom(doc) {
+    if (doc.body)
+        doc.body.style.zoom = String(previewZoom);
+}
+function setZoom(z, doc) {
+    previewZoom = clampZoom(z);
+    localStorage.setItem(ZOOM_KEY, String(previewZoom));
+    applyZoom(doc);
+}
+/** Install preview iframe controls: key forwarding to parent, Ctrl+wheel zoom,
+ *  keyboard zoom shortcuts (Ctrl+= / Ctrl+- / Ctrl+0), and the right-click menu. */
+function installPreviewControls(iframe) {
+    const attach = () => {
+        const doc = iframe.contentDocument;
+        if (!doc)
+            return;
+        applyZoom(doc);
+        doc.addEventListener("keydown", (e) => {
+            const target = e.target;
+            if (target && (target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName)))
+                return;
+            if (e.ctrlKey && (e.key === "=" || e.key === "+")) {
+                e.preventDefault();
+                setZoom(previewZoom + ZOOM_STEP, doc);
+                return;
+            }
+            if (e.ctrlKey && e.key === "-") {
+                e.preventDefault();
+                setZoom(previewZoom - ZOOM_STEP, doc);
+                return;
+            }
+            if (e.ctrlKey && e.key === "0") {
+                e.preventDefault();
+                setZoom(1, doc);
+                return;
+            }
+            document.dispatchEvent(new KeyboardEvent("keydown", {
+                key: e.key, code: e.code,
+                ctrlKey: e.ctrlKey, shiftKey: e.shiftKey, altKey: e.altKey, metaKey: e.metaKey,
+                bubbles: true, cancelable: true,
+            }));
+        });
+        doc.addEventListener("wheel", (e) => {
+            if (!e.ctrlKey)
+                return;
+            e.preventDefault();
+            setZoom(previewZoom + (e.deltaY < 0 ? ZOOM_STEP : -ZOOM_STEP), doc);
+        }, { passive: false });
+        doc.addEventListener("contextmenu", (e) => {
+            e.preventDefault();
+            const me = e;
+            const rect = iframe.getBoundingClientRect();
+            const x = rect.left + me.clientX;
+            const y = rect.top + me.clientY;
+            const pct = Math.round(previewZoom * 100);
+            const items = [
+                { label: "Copy", action: () => doc.execCommand("copy") },
+                { label: "Select all", action: () => {
+                        const sel = doc.defaultView?.getSelection();
+                        if (!sel)
+                            return;
+                        const range = doc.createRange();
+                        range.selectNodeContents(doc.body);
+                        sel.removeAllRanges();
+                        sel.addRange(range);
+                    } },
+                { label: "", action: () => { }, separator: true },
+                { label: "Zoom in", action: () => setZoom(previewZoom + ZOOM_STEP, doc) },
+                { label: "Zoom out", action: () => setZoom(previewZoom - ZOOM_STEP, doc) },
+                { label: `Reset zoom (${pct}%)`, action: () => setZoom(1, doc) },
+            ];
+            showContextMenu(x, y, items);
+        });
+    };
+    if (iframe.contentDocument?.readyState === "complete")
+        attach();
+    else
+        iframe.addEventListener("load", attach, { once: true });
+}
 function clearViewer() {
     currentMessage = null;
     currentAccountId = "";
@@ -251,6 +341,7 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                     const iframe = document.createElement("iframe");
                     iframe.srcdoc = wrapHtmlBody(full.bodyHtml, true);
                     bodyEl.appendChild(iframe);
+                    installPreviewControls(iframe);
                 }
             };
             banner.querySelector("#btn-load-remote").addEventListener("click", loadRemote);
@@ -279,6 +370,7 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
             iframe.sandbox.add("allow-top-navigation-by-user-activation");
             iframe.srcdoc = wrapHtmlBody(msg.bodyHtml, msg.remoteAllowed);
             bodyEl.appendChild(iframe);
+            installPreviewControls(iframe);
         }
         else if (msg.bodyText) {
             const pre = document.createElement("pre");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.211",
+  "version": "1.0.213",
   "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.273",
+    "@bobfrankston/msger": "^0.1.275",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -71,5 +71,24 @@
     "quill": "^2.0.3",
     "ws": "^8.18.0",
     "sql.js": "^1.14.1"
+  },
+  ".transformedSnapshot": {
+    "dependencies": {
+      "@bobfrankston/iflow-direct": "^0.1.6",
+      "@bobfrankston/iflow-node": "^0.1.2",
+      "@bobfrankston/miscinfo": "^1.0.8",
+      "@bobfrankston/oauthsupport": "^1.0.22",
+      "@bobfrankston/msger": "^0.1.275",
+      "@capacitor/android": "^8.3.0",
+      "@capacitor/cli": "^8.3.0",
+      "@capacitor/core": "^8.3.0",
+      "express": "^4.21.0",
+      "jsonc-parser": "^3.3.1",
+      "mailparser": "^3.7.2",
+      "nodemailer": "^7.0.0",
+      "quill": "^2.0.3",
+      "ws": "^8.18.0",
+      "sql.js": "^1.14.1"
+    }
   }
 }

package/packages/mailx-store-web/android-bootstrap.js

@@ -38,6 +38,13 @@ function emitEvent(event) {
 function toEmailAddress(addr) {
     return { name: addr?.name || "", address: addr?.address || "" };
 }
+/** Verbose log — goes to logit but doesn't clutter the screen (silent=true) */
+function vlog(msg) {
+    try {
+        fetch(`https://rmf39.aaz.lt/logit/${encodeURIComponent("V/" + msg.substring(0, 800))}?log=mailx-android&silent=true`).catch(() => { });
+    }
+    catch { /* ignore */ }
+}
 // ── Sync Manager ──
 class AndroidSyncManager {
     db;
@@ -51,6 +58,7 @@ class AndroidSyncManager {
     on(_event, _handler) { }
     emit(event, ...args) { emitEvent({ type: event, ...args[0] }); }
     async addAccount(account) {
+        vlog(`addAccount id=${account.id} email=${account.email} host=${account.imap?.host} auth=${account.imap?.auth}`);
         this.db.upsertAccount(account.id, account.name, account.email, JSON.stringify(account));
         if (this.isGmailAccount(account)) {
             const tokenProvider = this.tokenProviders.get(account.id);
@@ -62,6 +70,9 @@ class AndroidSyncManager {
                 console.warn(`[sync] ${account.id}: no token provider`);
             }
         }
+        else {
+            vlog(`addAccount ${account.id}: NOT a Gmail account — needs IMAP via TCP bridge (not yet implemented)`);
+        }
     }
     setTokenProvider(accountId, provider) {
         this.tokenProviders.set(accountId, provider);
@@ -74,9 +85,13 @@ class AndroidSyncManager {
     }
     async syncAll() {
         const accounts = this.db.getAccounts();
+        vlog(`syncAll: ${accounts.length} accounts in DB: ${accounts.map(a => a.id).join(",")}`);
         for (const account of accounts) {
+            const hasProvider = this.providers.has(account.id);
+            vlog(`syncAll: ${account.id} hasProvider=${hasProvider}`);
             try {
                 const folders = await this.syncFolders(account.id);
+                vlog(`syncAll: ${account.id} got ${folders.length} folders`);
                 const sorted = [...folders].sort((a, b) => {
                     if (a.specialUse === "inbox")
                         return -1;
@@ -97,14 +112,18 @@ class AndroidSyncManager {
             }
             catch (e) {
                 console.error(`[sync] ${account.id}: ${e.message}`);
+                vlog(`syncAll: ${account.id} ERROR: ${e.message}`);
                 emitEvent({ type: "syncError", accountId: account.id, error: e.message });
             }
         }
     }
     async syncFolders(accountId) {
         const provider = this.getProvider(accountId);
-        if (!provider)
-            return this.db.getFolders(accountId);
+        if (!provider) {
+            const existing = this.db.getFolders(accountId);
+            vlog(`syncFolders: ${accountId} no provider, returning ${existing.length} cached folders`);
+            return existing;
+        }
         emitEvent({ type: "syncProgress", accountId, phase: "folders", progress: 0 });
         const providerFolders = await provider.listFolders();
         for (const folder of providerFolders) {
@@ -546,8 +565,11 @@ export async function initAndroid() {
                     // Use canonical GDrive accounts (upsert handles overwrites)
                     accounts = gdriveAccounts;
                     for (const account of accounts) {
-                        if (!account.enabled)
+                        vlog(`init: registering ${account.id} email=${account.email} enabled=${account.enabled} imap=${JSON.stringify(account.imap)}`);
+                        if (!account.enabled) {
+                            vlog(`init: ${account.id} disabled, skipping`);
                             continue;
+                        }
                         const domain = account.email?.split("@")[1]?.toLowerCase() || "";
                         if (domain === "gmail.com" || domain === "googlemail.com") {
                             syncManager.setTokenProvider(account.id, createNativeTokenProvider(account.email));

package/packages/mailx-store-web/web-service.js

@@ -134,29 +134,62 @@ function parseMimeParts(body, boundary, topHeaders) {
             });
         }
         else if (partType.includes("text/html")) {
-            html = decodeBody(partBody, partEncoding);
+            const charsetMatch = partType.match(/charset="?([^";\s]+)"?/i);
+            html = decodeBody(partBody, partEncoding, charsetMatch?.[1] || "utf-8");
         }
         else if (partType.includes("text/plain")) {
-            text = decodeBody(partBody, partEncoding);
+            const charsetMatch = partType.match(/charset="?([^";\s]+)"?/i);
+            text = decodeBody(partBody, partEncoding, charsetMatch?.[1] || "utf-8");
         }
     }
     return { html, text, headers: topHeaders, attachments };
 }
-function decodeBody(body, encoding) {
+function decodeBody(body, encoding, charset = "utf-8") {
+    // Step 1: decode the transfer encoding to a byte array
+    let bytes;
     if (encoding === "base64") {
         try {
-            return atob(body.replace(/\s/g, ""));
+            const binary = atob(body.replace(/\s/g, ""));
+            bytes = Uint8Array.from(binary, c => c.charCodeAt(0));
         }
         catch {
             return body;
         }
     }
-    if (encoding === "quoted-printable") {
-        return body
-            .replace(/=\r?\n/g, "")
-            .replace(/=([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    else if (encoding === "quoted-printable") {
+        // Decode QP into bytes (NOT into a string — multi-byte UTF-8 must stay as bytes)
+        const cleaned = body.replace(/=\r?\n/g, "");
+        const out = [];
+        for (let i = 0; i < cleaned.length; i++) {
+            const c = cleaned[i];
+            if (c === "=" && i + 2 < cleaned.length && /[0-9A-Fa-f]{2}/.test(cleaned.substr(i + 1, 2))) {
+                out.push(parseInt(cleaned.substr(i + 1, 2), 16));
+                i += 2;
+            }
+            else {
+                // Existing character — encode as its byte (assumes ASCII for QP source)
+                out.push(c.charCodeAt(0) & 0xff);
+            }
+        }
+        bytes = new Uint8Array(out);
+    }
+    else if (encoding === "7bit" || encoding === "8bit" || encoding === "" || encoding === "binary") {
+        // No transfer encoding — body is already a string of single-byte chars
+        bytes = Uint8Array.from(body, c => c.charCodeAt(0) & 0xff);
+    }
+    else {
+        // Unknown encoding — return as-is
+        return body;
+    }
+    // Step 2: decode bytes using the declared charset (default UTF-8)
+    try {
+        const normalized = charset.toLowerCase().replace("windows-", "windows-").replace("iso-", "iso-");
+        return new TextDecoder(normalized).decode(bytes);
+    }
+    catch {
+        // Unknown charset — fall back to UTF-8 with replacement chars
+        return new TextDecoder("utf-8").decode(bytes);
     }
-    return body;
 }
 // ── Quoted-printable encoding (for compose/send) ──
 function encodeQuotedPrintable(text) {