@bobfrankston/mailx 1.0.35 → 1.0.36

package/README.md

@@ -141,9 +141,20 @@ Gmail requires OAuth2 instead of a password:
 - **Delete** -- Del key or trash button, moves to Trash. Ctrl+Z to undo (30s).
 - **Flag/unflag** -- click the star
 - **Drag and drop** -- drag messages to folders to move them. Shift/Ctrl+click for multi-select.
+- **Attachments** -- click the chip to open PDFs, images, etc. in the browser
 - **Remote content** -- blocked by default. "Load once" or "Always" buttons on the banner.
 - **Unsubscribe** -- button appears in header when List-Unsubscribe header is present
 - **View Source** -- Source button copies .eml file path to clipboard
+- **Link preview** -- hover over links in email body to see URL in status bar
+
+### Managing Folders
+- **Right-click any folder** for context menu:
+  - Mark all read
+  - New subfolder
+  - Rename folder
+  - Delete folder
+  - Empty folder (Trash/Junk only -- permanently deletes all messages)
+- Special folders (Inbox, Sent, Trash, etc.) cannot be renamed or deleted
 
 ### Keyboard Shortcuts
 | Key | Action |

package/client/app.js

@@ -5,7 +5,91 @@
 import { initFolderTree, refreshFolderTree } from "./components/folder-tree.js";
 import { initMessageList, loadMessages, loadUnifiedInbox, loadSearchResults, reloadCurrentFolder } from "./components/message-list.js";
 import { showMessage, getCurrentMessage } from "./components/message-viewer.js";
-import { connectWebSocket, onWsEvent, triggerSync, getAccounts } from "./lib/api-client.js";
+import { connectWebSocket, onWsEvent, triggerSync, getAccounts, getFolders } from "./lib/api-client.js";
+// ── New message badge (favicon + title) ──
+let baseTitle = "mailx";
+let lastSeenCount = 0;
+let badgeCount = 0;
+function updateBadge(count) {
+    badgeCount = count;
+    // Update title
+    document.title = count > 0 ? `(${count}) ${baseTitle}` : baseTitle;
+    // Update favicon with badge
+    const canvas = document.createElement("canvas");
+    canvas.width = 32;
+    canvas.height = 32;
+    const ctx = canvas.getContext("2d");
+    // Draw base icon (envelope)
+    ctx.fillStyle = "#4a7ccc";
+    ctx.fillRect(2, 8, 28, 20);
+    ctx.fillStyle = "#6a9cec";
+    ctx.beginPath();
+    ctx.moveTo(2, 8);
+    ctx.lineTo(16, 20);
+    ctx.lineTo(30, 8);
+    ctx.fill();
+    if (count > 0) {
+        // Red badge circle
+        ctx.fillStyle = "#e33";
+        ctx.beginPath();
+        ctx.arc(24, 8, 8, 0, Math.PI * 2);
+        ctx.fill();
+        // Badge number
+        ctx.fillStyle = "#fff";
+        ctx.font = "bold 11px sans-serif";
+        ctx.textAlign = "center";
+        ctx.textBaseline = "middle";
+        ctx.fillText(count > 99 ? "99+" : String(count), 24, 8);
+    }
+    // Set as favicon
+    let link = document.querySelector("link[rel='icon']");
+    if (!link) {
+        link = document.createElement("link");
+        link.rel = "icon";
+        document.head.appendChild(link);
+    }
+    link.href = canvas.toDataURL();
+}
+async function updateNewMessageCount() {
+    try {
+        const accounts = await getAccounts();
+        let totalUnread = 0;
+        for (const acct of accounts) {
+            const folders = await getFolders(acct.id);
+            const inbox = folders.find((f) => f.specialUse === "inbox");
+            if (inbox)
+                totalUnread += inbox.unreadCount || 0;
+        }
+        // First load: set baseline
+        if (lastSeenCount === 0) {
+            lastSeenCount = totalUnread;
+            updateBadge(0);
+            return;
+        }
+        // New messages = increase since last seen
+        const newCount = Math.max(0, totalUnread - lastSeenCount);
+        updateBadge(newCount);
+    }
+    catch { /* offline */ }
+}
+/** Call when user actively views messages — resets the badge */
+function markAsSeen() {
+    getAccounts().then(async (accounts) => {
+        let total = 0;
+        for (const acct of accounts) {
+            const folders = await getFolders(acct.id);
+            const inbox = folders.find((f) => f.specialUse === "inbox");
+            if (inbox)
+                total += inbox.unreadCount || 0;
+        }
+        lastSeenCount = total;
+        updateBadge(0);
+    }).catch(() => { });
+}
+function setTitle(title) {
+    baseTitle = title;
+    document.title = badgeCount > 0 ? `(${badgeCount}) ${baseTitle}` : baseTitle;
+}
 // ── Wire up components ──
 const folderTree = document.getElementById("folder-tree");
 let currentFolderSpecialUse = "";
@@ -15,13 +99,14 @@ initFolderTree(folderTree, (accountId, folderId, folderName, specialUse) => {
     currentFolderId = folderId;
     if (searchInput)
         searchInput.value = "";
+    markAsSeen();
     loadMessages(accountId, folderId, 1, specialUse);
-    document.title = `mailx - ${folderName}`;
+    setTitle(`mailx - ${folderName}`);
 }, () => {
     // Unified inbox handler
     currentFolderSpecialUse = "inbox";
     loadUnifiedInbox();
-    document.title = "mailx - All Inboxes";
+    setTitle("mailx - All Inboxes");
 });
 initMessageList((accountId, uid, folderId) => {
     showMessage(accountId, uid, folderId, currentFolderSpecialUse);
@@ -235,7 +320,7 @@ function doSearch(immediate = false) {
         return;
     }
     loadSearchResults(query, scope, currentAccountId, currentFolderId);
-    document.title = `mailx - Search: ${query}`;
+    setTitle(`mailx - Search: ${query}`);
 }
 // Track current folder for scoped search
 let currentAccountId = "";
@@ -374,6 +459,7 @@ onWsEvent((event) => {
             break;
         case "folderCountsChanged": {
             refreshFolderTree();
+            updateNewMessageCount();
             // Only reload message list if user isn't reading a message
             if (!getCurrentMessage())
                 reloadCurrentFolder();
@@ -552,6 +638,7 @@ setInterval(async () => {
     }
 }, 5000);
 console.log("mailx client initialized, location:", location.href);
+updateNewMessageCount();
 // Diagnostic: test API connectivity (helps debug WebView2 blank screen)
 fetch("/api/version").then(r => r.json()).then(d => {
     console.log("API reachable:", d);

package/client/components/context-menu.js

@@ -0,0 +1,51 @@
+/**
+ * Simple context menu component.
+ * Shows a menu at a given position with clickable items.
+ */
+let activeMenu = null;
+/** Close any open context menu */
+export function closeContextMenu() {
+    if (activeMenu) {
+        activeMenu.remove();
+        activeMenu = null;
+    }
+}
+/** Show a context menu at the given position */
+export function showContextMenu(x, y, items) {
+    closeContextMenu();
+    const menu = document.createElement("div");
+    menu.className = "ctx-menu";
+    for (const item of items) {
+        if (item.separator) {
+            const sep = document.createElement("div");
+            sep.className = "ctx-sep";
+            menu.appendChild(sep);
+            continue;
+        }
+        const el = document.createElement("div");
+        el.className = "ctx-item" + (item.disabled ? " ctx-disabled" : "");
+        el.textContent = item.label;
+        if (!item.disabled) {
+            el.addEventListener("click", () => {
+                closeContextMenu();
+                item.action();
+            });
+        }
+        menu.appendChild(el);
+    }
+    menu.style.left = `${x}px`;
+    menu.style.top = `${y}px`;
+    document.body.appendChild(menu);
+    // Adjust if menu goes off-screen
+    const rect = menu.getBoundingClientRect();
+    if (rect.right > window.innerWidth)
+        menu.style.left = `${x - rect.width}px`;
+    if (rect.bottom > window.innerHeight)
+        menu.style.top = `${y - rect.height}px`;
+    activeMenu = menu;
+}
+// Close on click outside or Escape
+document.addEventListener("click", closeContextMenu);
+document.addEventListener("keydown", (e) => { if (e.key === "Escape")
+    closeContextMenu(); });
+//# sourceMappingURL=context-menu.js.map

package/client/components/folder-tree.js

@@ -3,6 +3,7 @@
  * expand/collapse, and optional unified inbox.
  */
 import { getAccounts, getFolders } from "../lib/api-client.js";
+import { showContextMenu } from "./context-menu.js";
 let onFolderSelect;
 let onUnifiedInbox = null;
 let selectedElement;
@@ -156,6 +157,92 @@ function renderNode(node, container, depth) {
         selectedFolderId = node.id;
         onFolderSelect(node.accountId, node.id, node.name, node.specialUse || node.path.toLowerCase());
     });
+    // ── Right-click context menu ──
+    folderEl.addEventListener("contextmenu", (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        const isTrash = node.specialUse === "trash" || node.path.toLowerCase().includes("trash");
+        const isJunk = node.specialUse === "junk" || node.path.toLowerCase().includes("spam") || node.path.toLowerCase().includes("junk");
+        const items = [
+            { label: "Mark all read", action: async () => {
+                    try {
+                        await fetch(`/api/folder/${node.accountId}/${node.id}/mark-read`, { method: "POST" });
+                        const treeContainer = document.getElementById("folder-tree");
+                        if (treeContainer)
+                            loadFolderTree(treeContainer);
+                    }
+                    catch { /* ignore */ }
+                } },
+            { label: "", action: () => { }, separator: true },
+            { label: "New subfolder...", action: async () => {
+                    const name = prompt("New folder name:");
+                    if (!name)
+                        return;
+                    try {
+                        await fetch(`/api/folder/${node.accountId}`, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify({ parentPath: node.path, name }),
+                        });
+                        const treeContainer = document.getElementById("folder-tree");
+                        if (treeContainer)
+                            loadFolderTree(treeContainer);
+                    }
+                    catch (err) {
+                        alert(`Failed: ${err.message}`);
+                    }
+                } },
+            { label: "Rename...", action: async () => {
+                    const newName = prompt("Rename folder:", node.name);
+                    if (!newName || newName === node.name)
+                        return;
+                    try {
+                        await fetch(`/api/folder/${node.accountId}/${node.id}/rename`, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify({ newName }),
+                        });
+                        const treeContainer = document.getElementById("folder-tree");
+                        if (treeContainer)
+                            loadFolderTree(treeContainer);
+                    }
+                    catch (err) {
+                        alert(`Failed: ${err.message}`);
+                    }
+                }, disabled: !!node.specialUse },
+            { label: "Delete folder", action: async () => {
+                    if (!confirm(`Delete folder "${node.name}"? Messages will be moved to Trash.`))
+                        return;
+                    try {
+                        await fetch(`/api/folder/${node.accountId}/${node.id}`, { method: "DELETE" });
+                        const treeContainer = document.getElementById("folder-tree");
+                        if (treeContainer)
+                            loadFolderTree(treeContainer);
+                    }
+                    catch (err) {
+                        alert(`Failed: ${err.message}`);
+                    }
+                }, disabled: !!node.specialUse },
+        ];
+        if (isTrash || isJunk) {
+            items.push({ label: "", action: () => { }, separator: true });
+            items.push({ label: `Empty ${node.name}`, action: async () => {
+                    if (!confirm(`Permanently delete all messages in "${node.name}"?`))
+                        return;
+                    try {
+                        await fetch(`/api/folder/${node.accountId}/${node.id}/empty`, { method: "POST" });
+                        const treeContainer = document.getElementById("folder-tree");
+                        if (treeContainer)
+                            loadFolderTree(treeContainer);
+                        document.dispatchEvent(new CustomEvent("mailx-message-moved"));
+                    }
+                    catch (err) {
+                        alert(`Failed: ${err.message}`);
+                    }
+                } });
+        }
+        showContextMenu(e.clientX, e.clientY, items);
+    });
     // ── Drop target for message drag-and-drop ──
     if (node.id !== -1) {
         folderEl.addEventListener("dragover", (e) => {

package/client/components/message-list.js

@@ -92,6 +92,8 @@ export async function loadUnifiedInbox(autoSelect = true) {
     const body = document.getElementById("ml-body");
     if (!body)
         return;
+    const savedScroll = !autoSelect ? body.scrollTop : 0;
+    const savedUid = !autoSelect ? body.querySelector(".ml-row.selected")?.getAttribute("data-uid") : null;
     body.innerHTML = `<div class="ml-empty">Loading...</div>`;
     try {
         const result = await getUnifiedInbox(1);
@@ -108,6 +110,14 @@ export async function loadUnifiedInbox(autoSelect = true) {
             if (firstRow)
                 firstRow.click();
         }
+        else {
+            body.scrollTop = savedScroll;
+            if (savedUid) {
+                const row = body.querySelector(`.ml-row[data-uid="${savedUid}"]`);
+                if (row)
+                    row.classList.add("selected");
+            }
+        }
     }
     catch (e) {
         if (e.name === "AbortError")
@@ -184,6 +194,9 @@ export async function loadMessages(accountId, folderId, page = 1, specialUse = "
     const fromHeader = document.querySelector(".ml-col-from");
     if (fromHeader)
         fromHeader.textContent = showToInsteadOfFrom ? "To" : "From";
+    // Save scroll position and selected UID for non-autoSelect reloads
+    const savedScroll = !autoSelect ? body.scrollTop : 0;
+    const savedUid = !autoSelect ? body.querySelector(".ml-row.selected")?.getAttribute("data-uid") : null;
     body.innerHTML = `<div class="ml-empty">Loading...</div>`;
     try {
         const result = await getMessages(accountId, folderId, 1);
@@ -195,12 +208,21 @@ export async function loadMessages(accountId, folderId, page = 1, specialUse = "
         }
         body.innerHTML = "";
         appendMessages(body, accountId, result.items);
-        // Auto-select first message only on explicit folder navigation, not sync reload
         if (autoSelect) {
+            // Explicit folder navigation — select first message
             const firstRow = body.querySelector(".ml-row");
             if (firstRow)
                 firstRow.click();
         }
+        else {
+            // Sync reload — restore scroll position and selection
+            body.scrollTop = savedScroll;
+            if (savedUid) {
+                const row = body.querySelector(`.ml-row[data-uid="${savedUid}"]`);
+                if (row)
+                    row.classList.add("selected");
+            }
+        }
     }
     catch (e) {
         if (e.name === "AbortError")

package/client/components/message-viewer.js

@@ -109,6 +109,31 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                 editBtn.hidden = true;
             }
         }
+        // Details toggle — show extra headers (Delivered-To, Return-Path, Message-ID, etc.)
+        const detailsEl = document.getElementById("mv-details");
+        const detailsBtn = document.getElementById("mv-toggle-details");
+        if (detailsEl && detailsBtn) {
+            const lines = [];
+            if (msg.deliveredTo)
+                lines.push(`<span class="mv-details-label">Delivered-To:</span> ${escapeText(msg.deliveredTo)}`);
+            if (msg.returnPath)
+                lines.push(`<span class="mv-details-label">Return-Path:</span> ${escapeText(msg.returnPath)}`);
+            if (msg.messageId)
+                lines.push(`<span class="mv-details-label">Message-ID:</span> ${escapeText(msg.messageId)}`);
+            if (msg.listUnsubscribe)
+                lines.push(`<span class="mv-details-label">Unsubscribe:</span> ${escapeText(msg.listUnsubscribe)}`);
+            if (msg.emlPath)
+                lines.push(`<span class="mv-details-label">EML file:</span> ${escapeText(msg.emlPath)}`);
+            lines.push(`<span class="mv-details-label">Account:</span> ${escapeText(accountId)}`);
+            lines.push(`<span class="mv-details-label">UID:</span> ${msg.uid} (folder ${msg.folderId})`);
+            detailsEl.innerHTML = lines.join("<br>");
+            detailsEl.hidden = true;
+            detailsBtn.textContent = "Details";
+            detailsBtn.onclick = () => {
+                detailsEl.hidden = !detailsEl.hidden;
+                detailsBtn.textContent = detailsEl.hidden ? "Details" : "\u2713 Details";
+            };
+        }
         // Remote content banner (collapsible dropdown with sender/recipient details)
         bodyEl.innerHTML = "";
         if (msg.hasRemoteContent) {
@@ -215,10 +240,14 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
         if (msg.attachments?.length) {
             attEl.hidden = false;
             attEl.innerHTML = "";
-            for (const att of msg.attachments) {
-                const chip = document.createElement("span");
+            for (let i = 0; i < msg.attachments.length; i++) {
+                const att = msg.attachments[i];
+                const chip = document.createElement("a");
                 chip.className = "mv-att-chip";
                 chip.textContent = `\uD83D\uDCCE ${att.filename} (${formatSize(att.size)})`;
+                chip.href = `/api/message/${accountId}/${uid}/attachment/${i}?folderId=${msg.folderId}`;
+                chip.target = "_blank";
+                chip.title = `${att.filename} (${att.mimeType})`;
                 attEl.appendChild(chip);
             }
         }
@@ -226,14 +255,16 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
     catch (e) {
         const err = e.message || "Unknown error";
         console.error("showMessage error:", e);
-        if (retryCount < 3) {
+        // Don't retry on "not found" or known errors — only on connection issues
+        const isNotFound = err.includes("not found") || err.includes("Not Found") || err.includes("404");
+        if (!isNotFound && retryCount < 3) {
             retryCount++;
             bodyEl.innerHTML = `<div class="mv-empty">Loading failed: ${err} — retrying (${retryCount}/3)...</div>`;
             setTimeout(() => { if (gen === showMessageGeneration)
                 showMessage(accountId, uid, folderId, specialUse, true); }, 3000);
         }
         else {
-            bodyEl.innerHTML = `<div class="mv-empty">Failed to load message: ${err}</div>`;
+            bodyEl.innerHTML = `<div class="mv-empty">${isNotFound ? "Message was moved or deleted" : `Failed to load: ${err}`}</div>`;
         }
     }
 }

package/client/index.html

@@ -45,14 +45,6 @@
             <span id="app-version" class="app-version"></span>
         </div>
         <div class="toolbar-right">
-            <search class="search-bar">
-                <select id="search-scope" title="Search scope">
-                    <option value="all">All folders</option>
-                    <option value="current">This folder</option>
-                    <option value="server">IMAP server</option>
-                </select>
-                <input type="search" id="search-input" placeholder="Search... (/regex/)" autocomplete="off" title="Search messages. /pattern/ for regex. Qualifiers: from: to: subject:">
-            </search>
             <button class="tb-btn" id="btn-sync" title="Sync all folders (F5)">
                 <span class="tb-icon">↻</span> Sync
             </button>
@@ -73,6 +65,14 @@
 
     <main class="main-area">
         <section class="message-list" id="message-list">
+            <search class="search-bar ml-search">
+                <select id="search-scope" title="Search scope">
+                    <option value="all">All folders</option>
+                    <option value="current">This folder</option>
+                    <option value="server">IMAP server</option>
+                </select>
+                <input type="search" id="search-input" placeholder="Search... (/regex/)" autocomplete="off" title="Search messages. /pattern/ for regex. Qualifiers: from: to: subject:">
+            </search>
             <div class="ml-header">
                 <span class="ml-col ml-col-flag"></span>
                 <span class="ml-col ml-col-from" data-sort="from">From</span>
@@ -97,10 +97,12 @@
                         <button class="mv-action mv-action-primary" id="mv-edit-draft" hidden>Edit & Send</button>
                         <a class="mv-unsubscribe" id="mv-unsubscribe" hidden>Unsubscribe</a>
                         <button class="mv-action" id="mv-view-source" title="View source (.eml)" hidden>Source</button>
+                        <button class="mv-action" id="mv-toggle-details" title="Show/hide extra headers">Details</button>
                     </div>
                 </div>
                 <div class="mv-subject"></div>
                 <div class="mv-date"></div>
+                <div class="mv-details" id="mv-details" hidden></div>
             </div>
             <div class="mv-body" id="mv-body">
                 <div class="mv-empty">Select a message to read</div>

package/client/styles/components.css

@@ -1,5 +1,30 @@
 /* mailx component styles */
 
+/* ── Context Menu ── */
+
+.ctx-menu {
+    position: fixed;
+    z-index: 1000;
+    background: var(--color-bg-surface);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-md);
+    padding: var(--gap-xs) 0;
+    min-width: 180px;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+}
+
+.ctx-item {
+    padding: var(--gap-xs) var(--gap-md);
+    cursor: pointer;
+    font-size: var(--font-size-sm);
+    white-space: nowrap;
+}
+
+.ctx-item:hover { background: var(--color-bg-hover); }
+.ctx-disabled { opacity: 0.4; cursor: default; }
+.ctx-disabled:hover { background: transparent; }
+.ctx-sep { height: 1px; background: var(--color-border); margin: var(--gap-xs) 0; }
+
 /* ── Toolbar ── */
 
 .toolbar {
@@ -85,14 +110,21 @@
     cursor: pointer;
 }
 
+.ml-search {
+    grid-column: 1 / -1;
+    border-bottom: 1px solid var(--color-border);
+    padding: 2px var(--gap-xs);
+    background: var(--color-bg-surface);
+}
+
 #search-input {
     padding: var(--gap-xs) var(--gap-sm);
     border: 1px solid var(--color-border);
     border-radius: 0 var(--radius-md) var(--radius-md) 0;
-    background: var(--color-bg-surface);
+    background: var(--color-bg);
     color: var(--color-text);
     font-size: var(--font-size-sm);
-    width: 500px;
+    flex: 1;
 
     &::placeholder { color: var(--color-text-muted); }
     &:focus { outline: 1px solid var(--color-accent); border-color: var(--color-accent); }
@@ -218,7 +250,7 @@
 .message-list {
     display: grid;
     grid-template-columns: 1.2em minmax(120px, 200px) auto 1fr;
-    grid-template-rows: auto 1fr;
+    grid-template-rows: auto auto 1fr;
     column-gap: var(--gap-sm);
     overflow: hidden;
     border-right: 1px solid var(--color-border);
@@ -344,7 +376,7 @@
 
     .mv-header-top { display: flex; justify-content: space-between; align-items: flex-start; gap: var(--gap-sm); }
     .mv-header-info { flex: 1; min-width: 0; }
-    .mv-header-actions { display: flex; align-items: center; gap: var(--gap-xs); flex-shrink: 0; }
+    .mv-header-actions { display: flex; flex-direction: column; align-items: flex-end; gap: 2px; flex-shrink: 0; }
     .mv-from { font-weight: 600; }
     .mv-to { color: var(--color-text-muted); }
     .mv-subject { font-size: var(--font-size-lg); font-weight: 600; margin-top: var(--gap-xs); }
@@ -367,6 +399,20 @@
         white-space: nowrap;
     }
     .mv-action:hover { background: var(--color-bg-hover); color: var(--color-text); }
+    .mv-details {
+        font-size: var(--font-size-sm);
+        color: var(--color-text-muted);
+        border-top: 1px solid var(--color-border);
+        padding-top: var(--gap-xs);
+        margin-top: var(--gap-xs);
+        line-height: 1.6;
+    }
+    .mv-details-label {
+        display: inline-block;
+        min-width: 7em;
+        color: var(--color-text);
+        font-weight: 600;
+    }
     .mv-action-primary {
         background: var(--color-brand-dark) !important;
         color: white !important;
@@ -474,6 +520,8 @@
     border-radius: var(--radius-sm);
     font-size: var(--font-size-sm);
     cursor: pointer;
+    color: var(--color-text);
+    text-decoration: none;
 
     &:hover { background: var(--color-bg-hover); }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.35",
+  "version": "1.0.36",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,7 +20,7 @@
     "postinstall": "node launcher/builder/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.6",
+    "@bobfrankston/iflow": "^1.0.7",
     "@bobfrankston/miscinfo": "^1.0.6",
     "@bobfrankston/oauthsupport": "^1.0.11",
     "@bobfrankston/rust-builder": "^0.1.2",

package/packages/mailx-api/index.js

@@ -160,7 +160,37 @@ export function createApiRouter(db, imapManager) {
                     }
                     return String(v);
                 };
-                deliveredTo = hdr("delivered-to");
+                // Get the real Delivered-To, skipping relay domains from account config
+                const msgSettings = loadSettings();
+                const acctConfig = msgSettings.accounts.find((a) => a.id === accountId);
+                const relayDomains = acctConfig?.relayDomains || [];
+                const prefixes = acctConfig?.deliveredToPrefix || [];
+                const rawDelivered = parsed2.headers.get("delivered-to");
+                if (rawDelivered) {
+                    const deliveredList = Array.isArray(rawDelivered) ? rawDelivered : [rawDelivered];
+                    for (let i = deliveredList.length - 1; i >= 0; i--) {
+                        const d = deliveredList[i];
+                        const addr = typeof d === "string" ? d : d?.text || d?.address || String(d);
+                        if (!relayDomains.some(rd => addr.includes(`@${rd}`))) {
+                            deliveredTo = addr;
+                            break;
+                        }
+                    }
+                    if (!deliveredTo && deliveredList.length > 0) {
+                        const d = deliveredList[deliveredList.length - 1];
+                        deliveredTo = typeof d === "string" ? d : d?.text || d?.address || String(d);
+                    }
+                    // Strip prefix from local part to get clean alias
+                    if (deliveredTo && prefixes.length > 0) {
+                        const [local, domain] = deliveredTo.split("@");
+                        for (const prefix of prefixes) {
+                            if (local.startsWith(prefix)) {
+                                deliveredTo = `${local.slice(prefix.length)}@${domain}`;
+                                break;
+                            }
+                        }
+                    }
+                }
                 returnPath = hdr("return-path").replace(/[<>]/g, "");
                 // mailparser merges List-* headers into a "list" object
                 const listHeaders = parsed2.headers.get("list");
@@ -428,6 +458,153 @@ export function createApiRouter(db, imapManager) {
             res.status(500).json({ error: e.message });
         }
     });
+    // ── Folder management ──
+    // Create subfolder
+    router.post("/folder/:accountId", async (req, res) => {
+        try {
+            const { accountId } = req.params;
+            const { parentPath, name } = req.body;
+            const fullPath = parentPath ? `${parentPath}.${name}` : name;
+            const client = imapManager.createPublicClient(accountId);
+            try {
+                await client.createmailbox(fullPath);
+                await imapManager.syncFolders(accountId, client);
+                await client.logout();
+            }
+            finally {
+                try {
+                    await client.logout();
+                }
+                catch { /* */ }
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // Rename folder
+    router.post("/folder/:accountId/:folderId/rename", async (req, res) => {
+        try {
+            const { accountId, folderId } = req.params;
+            const { newName } = req.body;
+            const folder = db.getFolders(accountId).find(f => f.id === Number(folderId));
+            if (!folder)
+                return res.status(404).json({ error: "Folder not found" });
+            const parts = folder.path.split(folder.delimiter || ".");
+            parts[parts.length - 1] = newName;
+            const newPath = parts.join(folder.delimiter || ".");
+            const client = imapManager.createPublicClient(accountId);
+            try {
+                // iflow doesn't have renamemailbox yet — use raw imapflow
+                await client.withConnection(async () => {
+                    await client.client.mailboxRename(folder.path, newPath);
+                });
+                await imapManager.syncFolders(accountId, client);
+                await client.logout();
+            }
+            finally {
+                try {
+                    await client.logout();
+                }
+                catch { /* */ }
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // Delete folder
+    router.delete("/folder/:accountId/:folderId", async (req, res) => {
+        try {
+            const { accountId, folderId } = req.params;
+            const folder = db.getFolders(accountId).find(f => f.id === Number(folderId));
+            if (!folder)
+                return res.status(404).json({ error: "Folder not found" });
+            const client = imapManager.createPublicClient(accountId);
+            try {
+                await client.withConnection(async () => {
+                    await client.client.mailboxDelete(folder.path);
+                });
+                db.deleteFolder(Number(folderId));
+                await client.logout();
+            }
+            finally {
+                try {
+                    await client.logout();
+                }
+                catch { /* */ }
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // Mark all messages in folder as read
+    router.post("/folder/:accountId/:folderId/mark-read", async (req, res) => {
+        try {
+            const { accountId, folderId } = req.params;
+            db.markFolderRead(Number(folderId));
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // Empty folder (permanently delete all messages)
+    router.post("/folder/:accountId/:folderId/empty", async (req, res) => {
+        try {
+            const { accountId, folderId } = req.params;
+            const folder = db.getFolders(accountId).find(f => f.id === Number(folderId));
+            if (!folder)
+                return res.status(404).json({ error: "Folder not found" });
+            db.deleteAllMessages(accountId, Number(folderId));
+            // Also delete on IMAP
+            const client = imapManager.createPublicClient(accountId);
+            try {
+                const uids = await client.getUids(folder.path);
+                for (const uid of uids) {
+                    await client.deleteMessageByUid(folder.path, uid);
+                }
+                await client.logout();
+            }
+            finally {
+                try {
+                    await client.logout();
+                }
+                catch { /* */ }
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // ── Attachments ──
+    router.get("/message/:accountId/:uid/attachment/:attachmentId", async (req, res) => {
+        try {
+            const { accountId, uid, attachmentId } = req.params;
+            const folderId = req.query.folderId ? Number(req.query.folderId) : undefined;
+            const envelope = db.getMessageByUid(accountId, Number(uid), folderId);
+            if (!envelope)
+                return res.status(404).json({ error: "Message not found" });
+            const raw = await imapManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
+            if (!raw)
+                return res.status(404).json({ error: "Message body not available" });
+            const parsed = await simpleParser(raw);
+            const att = parsed.attachments?.[Number(attachmentId)];
+            if (!att)
+                return res.status(404).json({ error: "Attachment not found" });
+            res.set("Content-Type", att.contentType || "application/octet-stream");
+            res.set("Content-Disposition", `inline; filename="${(att.filename || "attachment").replace(/"/g, "")}""`);
+            res.send(att.content);
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
     // ── Drafts ──
     router.post("/draft", async (req, res) => {
         try {

package/packages/mailx-core/index.js

@@ -171,7 +171,37 @@ export async function getMessage(params) {
             }
             return String(v);
         };
-        deliveredTo = hdr("delivered-to");
+        // Get the real Delivered-To, skipping relay domains from account config
+        const settings = loadSettings();
+        const acctConfig = settings.accounts.find(a => a.id === accountId);
+        const relayDomains = acctConfig?.relayDomains || [];
+        const prefixes = acctConfig?.deliveredToPrefix || [];
+        const rawDelivered = parsed.headers.get("delivered-to");
+        if (rawDelivered) {
+            const deliveredList = Array.isArray(rawDelivered) ? rawDelivered : [rawDelivered];
+            for (let i = deliveredList.length - 1; i >= 0; i--) {
+                const d = deliveredList[i];
+                const addr = typeof d === "string" ? d : d?.text || d?.address || String(d);
+                if (!relayDomains.some((rd) => addr.includes(`@${rd}`))) {
+                    deliveredTo = addr;
+                    break;
+                }
+            }
+            if (!deliveredTo && deliveredList.length > 0) {
+                const d = deliveredList[deliveredList.length - 1];
+                deliveredTo = typeof d === "string" ? d : d?.text || d?.address || String(d);
+            }
+            // Strip prefix from local part to get clean alias
+            if (deliveredTo && prefixes.length > 0) {
+                const [local, domain] = deliveredTo.split("@");
+                for (const prefix of prefixes) {
+                    if (local.startsWith(prefix)) {
+                        deliveredTo = `${local.slice(prefix.length)}@${domain}`;
+                        break;
+                    }
+                }
+            }
+        }
         returnPath = hdr("return-path").replace(/[<>]/g, "");
         // mailparser merges List-* headers into a "list" object
         const listHeaders = parsed.headers.get("list");

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

@@ -34,6 +34,8 @@ export declare class ImapManager extends EventEmitter {
     deleteOnServer(accountId: string, folderPath: string, uid: number): Promise<void>;
     /** Search messages on the IMAP server — returns matching UIDs */
     searchOnServer(accountId: string, mailboxPath: string, criteria: any): Promise<number[]>;
+    /** Create a fresh ImapClient for an account (public access for API endpoints) */
+    createPublicClient(accountId: string): ImapClient;
     /** Create a fresh ImapClient for an account (disposable, single-use) */
     private createClient;
     /** Register an account */

package/packages/mailx-imap/index.js

@@ -89,6 +89,10 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
+    /** Create a fresh ImapClient for an account (public access for API endpoints) */
+    createPublicClient(accountId) {
+        return this.createClient(accountId);
+    }
     /** Create a fresh ImapClient for an account (disposable, single-use) */
     createClient(accountId) {
         const config = this.configs.get(accountId);

package/packages/mailx-settings/index.js

@@ -127,12 +127,24 @@ const DEFAULT_ALLOWLIST = {
 // ── Public API ──
 /** Load account configs */
 export function loadAccounts() {
-    // Try new split file first
-    const accounts = readJsonc(path.join(getSharedDir(), "accounts.jsonc"));
-    if (accounts?.accounts)
-        return accounts.accounts;
-    if (Array.isArray(accounts))
-        return accounts;
+    const sharedDir = getSharedDir();
+    const sharedPath = path.join(sharedDir, "accounts.jsonc");
+    const localPath = path.join(LOCAL_DIR, "accounts.jsonc");
+    // Try shared first, then local cache
+    let accounts = readJsonc(sharedPath);
+    if (!accounts)
+        accounts = readJsonc(localPath);
+    if (accounts?.accounts || Array.isArray(accounts)) {
+        // Cache shared to local for offline fallback
+        if (sharedDir !== LOCAL_DIR && fs.existsSync(sharedPath)) {
+            try {
+                fs.mkdirSync(LOCAL_DIR, { recursive: true });
+                fs.writeFileSync(localPath, fs.readFileSync(sharedPath, "utf-8"));
+            }
+            catch { /* ignore */ }
+        }
+        return accounts.accounts || accounts;
+    }
     // Legacy: read from settings.jsonc
     const legacy = loadLegacySettings();
     if (legacy?.accounts)

package/packages/mailx-store/db.d.ts

@@ -19,6 +19,8 @@ export declare class MailxDB {
     upsertFolder(accountId: string, folderPath: string, name: string, specialUse: string, delimiter: string): number;
     getFolders(accountId: string): Folder[];
     deleteFolder(folderId: number): void;
+    markFolderRead(folderId: number): void;
+    deleteAllMessages(accountId: string, folderId: number): void;
     updateFolderCounts(folderId: number, total: number, unread: number): void;
     updateFolderSync(folderId: number, uidvalidity: number, highestModseq: string): void;
     getFolderSync(folderId: number): {

package/packages/mailx-store/db.js

@@ -168,6 +168,14 @@ export class MailxDB {
         this.db.prepare("DELETE FROM messages WHERE folder_id = ?").run(folderId);
         this.db.prepare("DELETE FROM folders WHERE id = ?").run(folderId);
     }
+    markFolderRead(folderId) {
+        this.db.prepare(`UPDATE messages SET flags_json = REPLACE(flags_json, '[]', '["\\\\Seen"]') WHERE folder_id = ? AND flags_json NOT LIKE '%\\\\Seen%'`).run(folderId);
+        this.recalcFolderCounts(folderId);
+    }
+    deleteAllMessages(accountId, folderId) {
+        this.db.prepare("DELETE FROM messages WHERE account_id = ? AND folder_id = ?").run(accountId, folderId);
+        this.recalcFolderCounts(folderId);
+    }
     updateFolderCounts(folderId, total, unread) {
         this.db.prepare("UPDATE folders SET total_count = ?, unread_count = ? WHERE id = ?").run(total, unread, folderId);
     }

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

@@ -30,6 +30,8 @@ export interface AccountConfig {
     };
     enabled: boolean;
     defaultSend?: boolean; /** Use this account's SMTP when From doesn't match any account */
+    relayDomains?: string[]; /** Domains to skip in Delivered-To chain (e.g., ["m.connectivity.xyz"]) */
+    deliveredToPrefix?: string[]; /** Prefixes to strip from Delivered-To to get clean alias (e.g., ["bobf-ma-", "bobf-"]) — order matters, longest first */
 }
 /** Standard IMAP special-use folder types */
 export type SpecialUse = "inbox" | "sent" | "drafts" | "trash" | "junk" | "archive" | "all";