@bobfrankston/mailx 1.0.253 → 1.0.260

package/bin/mailx.js

@@ -28,6 +28,92 @@ const args = process.argv.slice(2);
 function hasFlag(name) { return args.includes(`-${name}`) || args.includes(`--${name}`); }
 const verbose = hasFlag("verbose");
 const isDaemon = hasFlag("daemon"); // internal: re-spawned detached process
+// Read our own version once — used for the instance file + upgrade check below.
+const __selfRoot = path.join(import.meta.dirname, "..");
+const __selfVersion = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(__selfRoot, "package.json"), "utf-8")).version || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+})();
+const __instanceFile = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx", "instance.json");
+function readInstanceFile() {
+    try {
+        const raw = fs.readFileSync(__instanceFile, "utf-8");
+        const inst = JSON.parse(raw);
+        if (typeof inst.pid === "number" && typeof inst.version === "string")
+            return inst;
+    }
+    catch { /* missing or unreadable — treated as no instance */ }
+    return null;
+}
+function writeInstanceFile(pid) {
+    try {
+        fs.mkdirSync(path.dirname(__instanceFile), { recursive: true });
+        fs.writeFileSync(__instanceFile, JSON.stringify({ pid, version: __selfVersion, startedAt: Date.now() }, null, 2));
+    }
+    catch { /* non-fatal */ }
+}
+function clearInstanceFile() {
+    try {
+        fs.unlinkSync(__instanceFile);
+    }
+    catch { /* ignore */ }
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Version-mismatch upgrade: if a daemon from an older version is running when
+// the user types `mailx`, kill it so the new one can take over. Without this,
+// a second invocation would silently no-op (daemon exists), leaving the user
+// on an old UI with no indication that the install has been upgraded.
+// Skip this logic for command-only flags (kill, rebuild, setup, ...) and for
+// the internal --daemon respawn.
+const __commandFlags = ["kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "import", "log"];
+const __isCommandInvocation = process.argv.slice(2).some(a => __commandFlags.includes(a.replace(/^--?/, "")));
+if (!isDaemon && !__isCommandInvocation) {
+    const inst = readInstanceFile();
+    if (inst && pidAlive(inst.pid)) {
+        if (inst.version !== __selfVersion) {
+            console.log(`mailx: upgrading running daemon (PID ${inst.pid}) from v${inst.version} → v${__selfVersion}`);
+            try {
+                process.kill(inst.pid, "SIGTERM");
+            }
+            catch { /* already gone */ }
+            // Give it ~1.5s to exit gracefully, then verify
+            const deadline = Date.now() + 2000;
+            while (Date.now() < deadline && pidAlive(inst.pid)) {
+                const sab = new SharedArrayBuffer(4);
+                Atomics.wait(new Int32Array(sab), 0, 0, 100); // 100ms nap
+            }
+            if (pidAlive(inst.pid)) {
+                try {
+                    process.kill(inst.pid, "SIGKILL");
+                }
+                catch { /* */ }
+            }
+            clearInstanceFile();
+        }
+        else {
+            // Same version already running — nothing to do. Print so the user
+            // knows why `mailx` seems to have done nothing.
+            console.log(`mailx v${__selfVersion} is already running (PID ${inst.pid}). Use mailx -kill to stop it.`);
+            process.exit(0);
+        }
+    }
+    else if (inst) {
+        // Stale instance file — PID is dead. Clean up.
+        clearInstanceFile();
+    }
+}
 // Auto-detach: re-spawn as background process so terminal returns immediately
 // Skip for: --verbose (want console), --daemon (already detached),
 // and any command flags (setup, kill, test, etc.)
@@ -675,6 +761,24 @@ async function main() {
         const home = process.env.USERPROFILE || process.env.HOME || ".";
         const logDir = path.join(home, ".mailx", "logs");
         fs.mkdirSync(logDir, { recursive: true });
+        // Prune logs older than LOG_RETENTION_DAYS on startup. Keep it simple:
+        // scan the dir, stat, delete. Cheap even with years of history.
+        const LOG_RETENTION_DAYS = 7;
+        const cutoff = Date.now() - LOG_RETENTION_DAYS * 86400000;
+        try {
+            for (const name of fs.readdirSync(logDir)) {
+                if (!/^mailx-\d{4}-\d{2}-\d{2}\.log$/.test(name))
+                    continue;
+                const full = path.join(logDir, name);
+                try {
+                    const st = fs.statSync(full);
+                    if (st.mtimeMs < cutoff)
+                        fs.unlinkSync(full);
+                }
+                catch { /* ignore per-file error */ }
+            }
+        }
+        catch { /* ignore — log pruning is best-effort */ }
         const logDate = new Date().toISOString().slice(0, 10);
         const logPath = path.join(logDir, `mailx-${logDate}.log`);
         const logStream = fs.createWriteStream(logPath, { flags: "a" });
@@ -716,6 +820,14 @@ async function main() {
         size: { width: 1400, height: 900 },
         escapeCloses: false,
     });
+    // Register ourselves as the live instance so subsequent `mailx` invocations
+    // can detect version-mismatch and upgrade us (see top of file). Clear on
+    // any of: SIGINT, SIGTERM, normal exit.
+    writeInstanceFile(process.pid);
+    const __cleanupInstance = () => { clearInstanceFile(); };
+    process.once("exit", __cleanupInstance);
+    process.once("SIGINT", () => { __cleanupInstance(); process.exit(0); });
+    process.once("SIGTERM", () => { __cleanupInstance(); process.exit(0); });
     // Handle requests from WebView → dispatch to MailxService
     // Pass server version to dispatch so getVersion returns it
     const rootPkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8"));

package/client/.msger-window.json

@@ -1 +1 @@
-{"height":1344,"width":2151,"x":380,"y":73}
+{"height":1344,"width":2151,"x":707,"y":89}

package/client/components/message-viewer.js

@@ -74,6 +74,7 @@ function installPreviewControls(iframe) {
             const target = e.target;
             if (target && (target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName)))
                 return;
+            // Zoom is iframe-local — handle here, don't forward.
             if (e.ctrlKey && (e.key === "=" || e.key === "+")) {
                 e.preventDefault();
                 setZoom(previewZoom + ZOOM_STEP, doc);
@@ -89,11 +90,23 @@ function installPreviewControls(iframe) {
                 setZoom(1, doc);
                 return;
             }
-            document.dispatchEvent(new KeyboardEvent("keydown", {
+            // Forward EVERY keydown to the parent — no duplicated hotkey list.
+            // If the parent's handler calls preventDefault (because it owns the
+            // shortcut), dispatchEvent returns false, and we preventDefault on
+            // the iframe side too so the browser doesn't ALSO act on it
+            // (Ctrl+N otherwise pops a new browser window in some hosts).
+            // Single source of truth = app.ts hotkey handlers. Plain typing in
+            // the email body — letters, etc. — propagates with no parent
+            // handler matching, so dispatchEvent returns true and the iframe
+            // event is left alone.
+            const synth = 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,
-            }));
+            });
+            const allowDefault = document.dispatchEvent(synth);
+            if (!allowDefault)
+                e.preventDefault();
         });
         doc.addEventListener("wheel", (e) => {
             if (!e.ctrlKey)
@@ -412,6 +425,60 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                 loadRemote();
             });
         }
+        // Body fetch error — show banner above (empty) body instead of polluting
+        // the main content area with the error text. Transient errors get a retry.
+        if (msg.bodyError) {
+            const err = String(msg.bodyError);
+            const isTransient = !!msg.bodyErrorTransient;
+            const errBanner = document.createElement("div");
+            errBanner.className = "mv-error-banner";
+            errBanner.style.cssText = "margin:1rem;padding:0.75rem 1rem;border:1px solid var(--color-border);border-left:3px solid #d33;background:var(--color-bg-surface);border-radius:4px;font-size:var(--font-size-sm)";
+            errBanner.innerHTML = `
+                <div style="font-weight:600;margin-bottom:0.25rem;color:#d33">Body unavailable</div>
+                <div style="color:var(--color-text-muted);white-space:pre-wrap;word-break:break-word">${err.replace(/[&<>"]/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c] || c))}</div>
+                ${isTransient ? `<button id="btn-retry-body" style="margin-top:0.5rem;padding:0.25rem 0.75rem">Retry</button>` : ""}
+            `;
+            bodyEl.appendChild(errBanner);
+            if (isTransient) {
+                errBanner.querySelector("#btn-retry-body")?.addEventListener("click", async () => {
+                    errBanner.remove();
+                    bodyEl.innerHTML = `<div class="mv-empty">Fetching message body...</div>`;
+                    try {
+                        const retry = await getMessage(accountId, uid, false);
+                        if (retry.bodyError) {
+                            // Still failing — rebuild the error banner via recursive render.
+                            showMessage(accountId, uid, folderId, specialUse).catch(() => { });
+                            return;
+                        }
+                        bodyEl.innerHTML = "";
+                        if (retry.bodyHtml) {
+                            const iframe = document.createElement("iframe");
+                            iframe.sandbox.add("allow-same-origin");
+                            iframe.sandbox.add("allow-popups");
+                            iframe.sandbox.add("allow-popups-to-escape-sandbox");
+                            iframe.sandbox.add("allow-top-navigation-by-user-activation");
+                            iframe.sandbox.add("allow-scripts");
+                            iframe.srcdoc = wrapHtmlBody(retry.bodyHtml, retry.remoteAllowed);
+                            bodyEl.appendChild(iframe);
+                            installPreviewControls(iframe);
+                        }
+                        else if (retry.bodyText) {
+                            const pre = document.createElement("pre");
+                            pre.style.cssText = "padding: 1rem; white-space: pre-wrap; word-break: break-word;";
+                            pre.innerHTML = linkifyText(retry.bodyText);
+                            bodyEl.appendChild(pre);
+                        }
+                        else {
+                            bodyEl.innerHTML = `<div class="mv-empty">No content</div>`;
+                        }
+                    }
+                    catch (e) {
+                        bodyEl.innerHTML = `<div class="mv-empty">Retry failed: ${e.message}</div>`;
+                    }
+                });
+            }
+            return;
+        }
         // Body in sandboxed iframe
         if (msg.bodyHtml) {
             const iframe = document.createElement("iframe");
@@ -455,11 +522,19 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                     e.preventDefault();
                     try {
                         const data = await getAttachment(accountId, uid, i, msg.folderId);
-                        // Create blob URL and open
-                        const bytes = Uint8Array.from(atob(data.content), c => c.charCodeAt(0));
-                        const blob = new Blob([bytes], { type: data.contentType });
-                        const url = URL.createObjectURL(blob);
-                        window.open(url, "_blank");
+                        const bridge = window._nativeBridge;
+                        if (bridge?.openAttachment) {
+                            // Android: blob URLs don't work in WebView. Pass base64
+                            // to native bridge which saves to Downloads and opens
+                            // with the system viewer.
+                            await bridge.openAttachment(att.filename, data.contentType, data.content);
+                        }
+                        else {
+                            const bytes = Uint8Array.from(atob(data.content), c => c.charCodeAt(0));
+                            const blob = new Blob([bytes], { type: data.contentType });
+                            const url = URL.createObjectURL(blob);
+                            window.open(url, "_blank");
+                        }
                     }
                     catch (err) {
                         console.error(`Attachment download failed: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.253",
+  "version": "1.0.260",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,11 +20,11 @@
     "postinstall": "node bin/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow-direct": "^0.1.15",
+    "@bobfrankston/iflow-direct": "^0.1.19",
     "@bobfrankston/iflow-node": "^0.1.5",
     "@bobfrankston/miscinfo": "^1.0.8",
-    "@bobfrankston/oauthsupport": "^1.0.23",
-    "@bobfrankston/msger": "^0.1.314",
+    "@bobfrankston/oauthsupport": "^1.0.24",
+    "@bobfrankston/msger": "^0.1.316",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -37,7 +37,8 @@
     "sql.js": "^1.14.1",
     "@bobfrankston/tcp-transport": "^0.1.3",
     "@bobfrankston/node-tcp-transport": "^0.1.1",
-    "@bobfrankston/smtp-direct": "^0.1.2"
+    "@bobfrankston/smtp-direct": "^0.1.2",
+    "@bobfrankston/mailx-sync": "file:../../../MailApps/mailx-sync"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6"
@@ -80,11 +81,11 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/iflow-direct": "^0.1.15",
+      "@bobfrankston/iflow-direct": "^0.1.19",
       "@bobfrankston/iflow-node": "^0.1.5",
       "@bobfrankston/miscinfo": "^1.0.8",
-      "@bobfrankston/oauthsupport": "^1.0.23",
-      "@bobfrankston/msger": "^0.1.314",
+      "@bobfrankston/oauthsupport": "^1.0.24",
+      "@bobfrankston/msger": "^0.1.316",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

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

@@ -147,7 +147,13 @@ export declare class ImapManager extends EventEmitter {
      *  stale row locally and keep going. Only unrelated errors (network,
      *  auth, rate limits) count against the error budget, and the budget is
      *  generous so a few transient failures don't kill the whole run. */
+    /** Guard against concurrent prefetchBodies for the same account — mirror of
+     *  `sendingAccounts`. Without this, every periodic-sync tick spawns a new
+     *  prefetch session alongside any still in flight, blowing through Gmail's
+     *  per-minute quota and racing on disk writes. One prefetch per account. */
+    private prefetchingAccounts;
     private prefetchBodies;
+    private _prefetchBodies;
     /** Get the body store for direct access */
     getBodyStore(): FileMessageStore;
     /** Bulk trash messages — local-first, single IMAP connection for all */