@bobfrankston/mailx 1.0.212 → 1.0.214

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,23 +37,90 @@ export function initViewer() {
         // "messages" change (sync reload) — don't touch the viewer
     });
 }
-/** Re-dispatch keydown events from iframe contentDocument onto the parent document
- *  so global shortcuts (Delete, Ctrl+D, Ctrl+R, etc.) fire while the preview has focus. */
-function forwardKeysToParent(iframe) {
+// 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();
@@ -274,7 +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);
-                    forwardKeysToParent(iframe);
+                    installPreviewControls(iframe);
                 }
             };
             banner.querySelector("#btn-load-remote").addEventListener("click", loadRemote);
@@ -303,7 +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);
-            forwardKeysToParent(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.212",
+  "version": "1.0.214",
   "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.274",
+    "@bobfrankston/msger": "^0.1.276",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -78,7 +78,7 @@
       "@bobfrankston/iflow-node": "^0.1.2",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.22",
-      "@bobfrankston/msger": "^0.1.274",
+      "@bobfrankston/msger": "^0.1.276",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

package/packages/mailx-imap/index.js

@@ -346,7 +346,7 @@ export class ImapManager extends EventEmitter {
             const tokenDir = path.join(getConfigDir(), "tokens", account.imap.user.replace(/[@.]/g, "_"));
             tokenProvider = async () => {
                 const result = await authenticateOAuth(credPath, {
-                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly",
+                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/calendar",
                     tokenDirectory: tokenDir,
                     credentialsKey: "installed",
                     loginHint: account.imap.user,
@@ -360,6 +360,9 @@ export class ImapManager extends EventEmitter {
             username: account.imap.user,
             password: account.imap.password,
             tokenProvider,
+            // Slow Dovecot servers (e.g. iecc.com) can stall >60s during multi-body FETCH.
+            // Raise the inactivity timeout so the connection isn't dropped mid-stream.
+            inactivityTimeout: 180000,
         });
         this.configs.set(account.id, config);
         // Register account in DB
@@ -1731,19 +1734,36 @@ export class ImapManager extends EventEmitter {
             return;
         // Gmail/API accounts: send directly via SMTP from local queue (no IMAP outbox)
         const sentDir = path.join(getConfigDir(), "sending", accountId, "sent");
+        const failedDir = path.join(getConfigDir(), "sending", accountId, "failed");
         fs.mkdirSync(sentDir, { recursive: true });
+        fs.mkdirSync(failedDir, { recursive: true });
         if (this.isGmailAccount(accountId)) {
             for (const { dir, file } of filesToSend) {
                 const filePath = path.join(dir, file);
                 const raw = fs.readFileSync(filePath, "utf-8");
                 try {
                     await this.sendRawViaSMTP(accountId, raw);
-                    // Move to sent/
                     fs.renameSync(filePath, path.join(sentDir, file));
                     console.log(`  [outbox] Sent ${file} via SMTP → sent/`);
                 }
                 catch (e) {
-                    console.error(`  [outbox] Send failed for ${file}: ${e.message}`);
+                    // Critical: NEVER leave a .ltr in the queue after a send attempt unless the
+                    // failure was clearly pre-connect. An error after the SMTP session opened may
+                    // mean the server actually accepted DATA but we lost the ack — retrying would
+                    // double-send. Classify conservatively: only keep-in-queue for clearly
+                    // network-level / pre-auth errors.
+                    const code = String(e?.code || "");
+                    const cmd = String(e?.command || "").toUpperCase();
+                    const preConnect = /^(ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ECONNECTION|ETIMEDOUT)$/.test(code)
+                        && (!cmd || cmd === "CONN");
+                    if (preConnect) {
+                        console.error(`  [outbox] Pre-connect failure for ${file} (${code}), will retry: ${e.message}`);
+                    }
+                    else {
+                        // Ambiguous or terminal — move to failed/ so we don't resend if SMTP actually delivered
+                        fs.renameSync(filePath, path.join(failedDir, file));
+                        console.error(`  [outbox] Send failed for ${file} → failed/ (no auto-retry, code=${code || "?"}): ${e.message}`);
+                    }
                 }
             }
             return;
@@ -1939,12 +1959,21 @@ export class ImapManager extends EventEmitter {
                     this.outboxBackoffDelay.delete(accountId);
                 }
                 catch (e) {
-                    // Exponential backoff: 60s → 120s → 300s (max 5min)
-                    const prevDelay = this.outboxBackoffDelay.get(accountId) || 0;
-                    const delay = prevDelay ? Math.min(prevDelay * 2, 300000) : 60000;
-                    this.outboxBackoffDelay.set(accountId, delay);
-                    this.outboxBackoff.set(accountId, now + delay);
-                    console.error(`  [outbox] Error for ${accountId}: ${imapError(e)} (retry in ${Math.round(delay / 1000)}s)`);
+                    // Stale-socket errors (Dovecot silently drops idle connections):
+                    // don't back off — just reconnect on the next tick. The 300s
+                    // backoff is meant for real auth/network failures, not dead sockets.
+                    const msg = String(e?.message || e);
+                    if (/Not connected|ECONNRESET|socket hang up|EPIPE|write after end/i.test(msg)) {
+                        console.error(`  [outbox] Stale connection for ${accountId}: ${msg} — will retry next tick`);
+                    }
+                    else {
+                        // Exponential backoff: 60s → 120s → 300s (max 5min)
+                        const prevDelay = this.outboxBackoffDelay.get(accountId) || 0;
+                        const delay = prevDelay ? Math.min(prevDelay * 2, 300000) : 60000;
+                        this.outboxBackoffDelay.set(accountId, delay);
+                        this.outboxBackoff.set(accountId, now + delay);
+                        console.error(`  [outbox] Error for ${accountId}: ${imapError(e)} (retry in ${Math.round(delay / 1000)}s)`);
+                    }
                 }
             }
         };

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) {
@@ -269,7 +288,7 @@ const OAUTH_CLIENT = {
 // Use full drive scope so we can read/write the desktop's accounts.jsonc + clients.jsonc.
 // drive.file is per-consent-grant: files created by desktop's grant aren't visible to Android's grant
 // even with the same client_id. drive (full) lets us see all files the user has access to.
-const OAUTH_SCOPES = "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/drive";
+const OAUTH_SCOPES = "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/drive https://www.googleapis.com/auth/calendar";
 // ── Token cache (IndexedDB) ──
 async function getCachedToken(email) {
     const key = `oauth-token-${email.replace(/[@.]/g, "_")}`;
@@ -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) {