@bobfrankston/mailx 1.0.221 → 1.0.223

package/client/app.js

@@ -483,6 +483,7 @@ function forwardBody(msg) {
     return `<br><div class="reply"><p>---------- Forwarded message ----------<br>From: ${from}<br>Date: ${date}<br>Subject: ${msg.subject}<br>To: ${to}</p>${body}</div>`;
 }
 let lastDeleted = null;
+let lastMoved = null;
 let undoTimeout = null;
 async function deleteSelectedMessages() {
     const selected = getSelectedMessages();
@@ -548,6 +549,49 @@ async function undoDelete() {
         console.error(`Undo failed: ${e.message}`);
     }
 }
+async function undoMove() {
+    if (!lastMoved)
+        return;
+    const { messages } = lastMoved;
+    const statusSync = document.getElementById("status-sync");
+    try {
+        // Group by (sourceAccountId, sourceFolderId) and move each group back
+        const byDest = new Map();
+        for (const m of messages) {
+            const key = `${m.accountId}:${m.sourceFolderId}`;
+            if (!byDest.has(key))
+                byDest.set(key, { accountId: m.accountId, folderId: m.sourceFolderId, uids: [] });
+            byDest.get(key).uids.push(m.uid);
+        }
+        const { moveMessages, moveMessage } = await import("./lib/api-client.js");
+        for (const group of byDest.values()) {
+            if (group.uids.length === 1)
+                await moveMessage(group.accountId, group.uids[0], group.folderId);
+            else
+                await moveMessages(group.accountId, group.uids, group.folderId);
+        }
+        if (statusSync)
+            statusSync.textContent = `Undid move of ${messages.length} message${messages.length !== 1 ? "s" : ""}`;
+        lastMoved = null;
+        if (undoTimeout)
+            clearTimeout(undoTimeout);
+        reloadCurrentFolder();
+    }
+    catch (e) {
+        console.error(`Undo move failed: ${e.message}`);
+        if (statusSync)
+            statusSync.textContent = `Undo move failed: ${e.message}`;
+    }
+}
+// Listen for the "mailx-moved" custom event emitted by folder-tree's drop
+// handler so Ctrl+Z can reverse the most recent move.
+document.addEventListener("mailx-moved", (e) => {
+    lastMoved = e.detail;
+    lastDeleted = null; // Ctrl+Z undoes whichever came last
+    if (undoTimeout)
+        clearTimeout(undoTimeout);
+    undoTimeout = setTimeout(() => { lastMoved = null; }, 60000);
+});
 document.getElementById("btn-delete")?.addEventListener("click", deleteSelectedMessages);
 document.getElementById("btn-compose")?.addEventListener("click", () => openCompose("new"));
 document.getElementById("btn-reply")?.addEventListener("click", () => openCompose("reply"));
@@ -909,9 +953,13 @@ document.addEventListener("keydown", (e) => {
         e.preventDefault();
         deleteSelectedMessages();
     }
-    // Ctrl+Z = Undo delete
+    // Ctrl+Z = Undo the most recent delete or move
     if (e.ctrlKey && e.key === "z") {
-        if (lastDeleted) {
+        if (lastMoved) {
+            e.preventDefault();
+            undoMove();
+        }
+        else if (lastDeleted) {
             e.preventDefault();
             undoDelete();
         }

package/client/components/folder-tree.js

@@ -325,13 +325,22 @@ function renderNode(node, container, depth) {
                 }
                 const moved = toMove.length;
                 if (statusEl)
-                    statusEl.textContent = `Moved ${moved} message${moved > 1 ? "s" : ""} to ${node.name}`;
+                    statusEl.textContent = `Moved ${moved} message${moved > 1 ? "s" : ""} to ${node.name} — Ctrl+Z to undo`;
                 // Remove from shared state — list and viewer update automatically
                 const { removeMessages } = await import("../lib/message-state.js");
                 removeMessages(toMove);
                 const treeContainer = document.getElementById("folder-tree");
                 if (treeContainer)
                     loadFolderTree(treeContainer);
+                // Notify app.ts so Ctrl+Z can undo this move. Each entry carries
+                // its ORIGINAL folderId/accountId so we know where to move back to.
+                document.dispatchEvent(new CustomEvent("mailx-moved", {
+                    detail: {
+                        messages: toMove.map(m => ({ accountId: m.accountId, uid: m.uid, sourceFolderId: m.folderId })),
+                        targetAccountId: node.accountId,
+                        targetFolderId: node.id,
+                    },
+                }));
             }
             catch (err) {
                 console.error(`Move failed: ${err.message}`);

package/client/components/message-viewer.js

@@ -2,7 +2,7 @@
  * Message viewer component -- displays full message in sandboxed iframe.
  * Subscribes to message-state: clears when selected becomes null.
  */
-import { getMessage, updateFlags, allowRemoteContent, getAttachment } from "../lib/api-client.js";
+import { getMessage, updateFlags, allowRemoteContent, getAttachment, addContact } from "../lib/api-client.js";
 import { showContextMenu } from "./context-menu.js";
 import * as state from "../lib/message-state.js";
 /** Currently displayed message (for reply/forward) */
@@ -173,20 +173,37 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
             toEl.textContent += `  Cc: ${msg.cc.map(formatAddr).join(", ")}`;
         }
         headerEl.querySelector(".mv-subject").textContent = msg.subject;
-        // Right-click on email addresses in header
-        const allAddresses = [msg.from, ...(msg.to || []), ...(msg.cc || [])].filter((a) => a?.address);
+        // Right-click on email addresses in header: copy name, copy address,
+        // copy both, add to contacts, plus reply actions for the whole message.
         for (const el of [fromEl, toEl]) {
             el.addEventListener("contextmenu", (e) => {
                 e.preventDefault();
                 const me = e;
                 const items = [];
-                for (const addr of (el === fromEl ? [msg.from] : [...(msg.to || []), ...(msg.cc || [])])) {
+                const addrs = el === fromEl ? [msg.from] : [...(msg.to || []), ...(msg.cc || [])];
+                for (const addr of addrs) {
                     if (!addr?.address)
                         continue;
-                    const display = addr.name ? `${addr.name} <${addr.address}>` : addr.address;
-                    items.push({ label: `Copy: ${display}`, action: () => navigator.clipboard.writeText(addr.address) });
+                    const name = addr.name || "";
+                    const both = name ? `${name} <${addr.address}>` : addr.address;
+                    if (name) {
+                        items.push({ label: `Copy name: ${name}`, action: () => navigator.clipboard.writeText(name) });
+                    }
+                    items.push({ label: `Copy address: ${addr.address}`, action: () => navigator.clipboard.writeText(addr.address) });
+                    if (name) {
+                        items.push({ label: `Copy both: ${both}`, action: () => navigator.clipboard.writeText(both) });
+                    }
+                    items.push({
+                        label: `Add to contacts: ${addr.address}`,
+                        action: async () => {
+                            try {
+                                await addContact(name, addr.address);
+                            }
+                            catch { /* ignore */ }
+                        },
+                    });
+                    items.push({ label: "", action: () => { }, separator: true });
                 }
-                items.push({ label: "", action: () => { }, separator: true });
                 items.push({ label: "Reply", action: () => document.dispatchEvent(new CustomEvent("mailx-compose", { detail: { mode: "reply" } })) });
                 items.push({ label: "Reply All", action: () => document.dispatchEvent(new CustomEvent("mailx-compose", { detail: { mode: "replyAll" } })) });
                 items.push({ label: "Forward", action: () => document.dispatchEvent(new CustomEvent("mailx-compose", { detail: { mode: "forward" } })) });

package/client/compose/compose.css

@@ -294,6 +294,36 @@ body {
 }
 .ql-editor, .tt-content .tiptap { position: relative; }
 
+/* Attachment chips above the editor */
+.compose-attachments {
+    padding: var(--gap-xs) var(--gap-md);
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--gap-xs);
+    background: var(--color-bg-surface);
+    border-bottom: 1px solid var(--color-border);
+}
+.compose-att-chip {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 3px 8px;
+    border-radius: 999px;
+    background: color-mix(in oklch, var(--color-accent) 15%, transparent);
+    color: var(--color-text);
+    font-size: var(--font-size-sm);
+}
+.compose-att-chip button {
+    background: none;
+    border: none;
+    color: var(--color-text-muted);
+    cursor: pointer;
+    padding: 0;
+    font-size: 1em;
+    line-height: 1;
+}
+.compose-att-chip button:hover { color: oklch(0.65 0.2 25); }
+
 /* Link editor modal (Ctrl+K / toolbar link button) */
 .mailx-modal-backdrop {
     position: fixed;

package/client/compose/compose.html

@@ -37,9 +37,11 @@
     <div class="compose-toolbar">
         <button class="tb-btn" id="btn-send">Send</button>
         <button class="tb-btn" id="btn-attach">Attach</button>
+        <input type="file" id="compose-file" multiple hidden>
         <button class="tb-btn" id="btn-discard">Discard</button>
         <span id="compose-status" class="compose-status"></span>
     </div>
+    <div id="compose-attachments" class="compose-attachments" hidden></div>
     <div id="compose-editor"></div>
 </body>
 </html>

package/client/compose/compose.js

@@ -302,6 +302,7 @@ let draftDebounceTimer = null;
 let lastDraftContent = "";
 let draftSaving = false; // prevent concurrent saves
 let draftSaveFailed = false; // surfaced in the compose status tag
+const attachments = [];
 function showDraftStatus(text, isError) {
     const status = document.getElementById("compose-status");
     if (!status)
@@ -418,6 +419,7 @@ document.getElementById("btn-send")?.addEventListener("click", async () => {
         subject: subjectInput.value,
         bodyHtml: editor.getHtml(),
         bodyText: editor.getText(),
+        attachments: attachments.map(a => ({ filename: a.filename, mimeType: a.mimeType, dataBase64: a.dataBase64 })),
     };
     try {
         await sendMessage(body);
@@ -495,6 +497,68 @@ async function handleCloseRequest() {
 document.getElementById("btn-discard")?.addEventListener("click", () => {
     handleCloseRequest();
 });
+// ── Attachments ──
+const fileInput = document.getElementById("compose-file");
+const attEl = document.getElementById("compose-attachments");
+function renderAttachmentChips() {
+    attEl.innerHTML = "";
+    if (attachments.length === 0) {
+        attEl.hidden = true;
+        return;
+    }
+    attEl.hidden = false;
+    for (let i = 0; i < attachments.length; i++) {
+        const a = attachments[i];
+        const chip = document.createElement("span");
+        chip.className = "compose-att-chip";
+        chip.innerHTML = `\uD83D\uDCCE ${escapeHtml(a.filename)} (${formatSize(a.size)}) `;
+        const rm = document.createElement("button");
+        rm.type = "button";
+        rm.title = "Remove attachment";
+        rm.textContent = "\u2715";
+        rm.addEventListener("click", () => {
+            attachments.splice(i, 1);
+            renderAttachmentChips();
+        });
+        chip.appendChild(rm);
+        attEl.appendChild(chip);
+    }
+}
+function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+}
+function formatSize(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+document.getElementById("btn-attach")?.addEventListener("click", () => {
+    fileInput?.click();
+});
+fileInput?.addEventListener("change", async () => {
+    if (!fileInput.files)
+        return;
+    for (const file of Array.from(fileInput.files)) {
+        const buf = await file.arrayBuffer();
+        // base64 the whole thing — mailx-service builds the multipart/mixed
+        let binary = "";
+        const bytes = new Uint8Array(buf);
+        for (let i = 0; i < bytes.length; i++)
+            binary += String.fromCharCode(bytes[i]);
+        const dataBase64 = btoa(binary);
+        attachments.push({
+            filename: file.name,
+            mimeType: file.type || "application/octet-stream",
+            size: file.size,
+            dataBase64,
+        });
+    }
+    fileInput.value = "";
+    renderAttachmentChips();
+    scheduleDraftSave();
+});
 // ── Save and close (X button from parent) ──
 window.addEventListener("compose-save-and-close", () => {
     handleCloseRequest();

package/client/lib/api-client.js

@@ -146,6 +146,9 @@ export function repairAccounts() {
 export function deleteDraft(accountId, draftUid, draftId) {
     return ipc().deleteDraft?.(accountId, draftUid, draftId);
 }
+export function addContact(name, email) {
+    return ipc().addContact?.(name, email);
+}
 export function setupAccount(name, email, password) {
     return ipc().setupAccount?.(name, email, password);
 }

package/client/lib/mailxapi.js

@@ -97,6 +97,9 @@
         searchMessages: function(query, page, pageSize) {
             return callNode("searchMessages", { query: query, page: page, pageSize: pageSize });
         },
+        addContact: function(name, email) {
+            return callNode("addContact", { name: name, email: email });
+        },
         searchContacts: function(query) {
             return callNode("searchContacts", { query: query });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.221",
+  "version": "1.0.223",
   "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.283",
+    "@bobfrankston/msger": "^0.1.285",
     "@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.283",
+      "@bobfrankston/msger": "^0.1.285",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

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

@@ -188,9 +188,12 @@ export declare class ImapManager extends EventEmitter {
     private saveSendingCopy;
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     queueOutgoing(accountId: string, rawMessage: string | Buffer): Promise<void>;
-    /** Process local file queue — send from outbox/ only (IMAP-unreachable fallback).
-     *  Do NOT scan sending/<acct>/queued/ — that was causing every sent message to be
-     *  re-APPENDed to the IMAP Outbox on the next tick and delivered twice. */
+    /** Process local file queue — scan both outbox/ (IMAP-unreachable fallback)
+     *  and sending/<acct>/queued/ (manual drop-in, crash recovery). The earlier
+     *  double-send bug was caused by queueOutgoing() WRITING a debug copy to
+     *  sending/queued/ on every send — that write is gone now, so scanning the
+     *  directory is safe again. Any legitimate files that land there (crash
+     *  recovery, manual drop) will get sent. */
     private processLocalQueue;
     /** Send a raw RFC 2822 message via SMTP for a given account */
     private sendRawViaSMTP;

package/packages/mailx-imap/index.js

@@ -946,20 +946,40 @@ export class ImapManager extends EventEmitter {
             console.log(`  [api] ${accountId}/${folder.path}: ${messages.length} new messages`);
             this.storeApiMessages(accountId, folder.id, messages, highestUid);
         }
-        // Reconcile deletions
+        // Reconcile deletions — messages present locally but not on the server.
+        // SAFETY: this used to silently wipe entire folders when getUids()
+        // returned a partial list (e.g. paginated fetch hit a rate limit and
+        // bailed). Multiple guards now:
+        //   1. getUids() flags partial results via _truncated — refuse to delete
+        //   2. If server list is empty but local isn't, assume a transient error
+        //   3. If reconcile would delete more than RECONCILE_DELETE_THRESHOLD of
+        //      local messages, log and skip — safer to keep phantoms than to lose
+        //      real messages. User can fix with `mailx -rebuild` if needed.
         try {
-            const serverUids = new Set(await api.getUids(folder.path));
+            const serverUidsArr = await api.getUids(folder.path);
+            const serverUids = new Set(serverUidsArr);
             const localUids = this.db.getUidsForFolder(accountId, folder.id);
-            let deleted = 0;
-            for (const uid of localUids) {
-                if (!serverUids.has(uid)) {
-                    this.db.deleteMessage(accountId, uid);
-                    this.bodyStore.deleteMessage(accountId, folder.id, uid).catch(() => { });
-                    deleted++;
+            if (serverUidsArr._truncated) {
+                console.log(`  [api] ${accountId}/${folder.path}: reconcile skipped — server list truncated (${serverUidsArr.length} ids)`);
+            }
+            else if (serverUidsArr.length === 0 && localUids.length > 0) {
+                console.log(`  [api] ${accountId}/${folder.path}: reconcile skipped — server list empty but local has ${localUids.length}`);
+            }
+            else {
+                const toDelete = localUids.filter(uid => !serverUids.has(uid));
+                const RECONCILE_DELETE_THRESHOLD = 0.5; // refuse to delete >50% in one pass
+                if (localUids.length > 0 && toDelete.length / localUids.length > RECONCILE_DELETE_THRESHOLD) {
+                    console.log(`  [api] ${accountId}/${folder.path}: reconcile refused — would delete ${toDelete.length}/${localUids.length} (${Math.round(toDelete.length / localUids.length * 100)}%) — probably a sync bug, skipping`);
+                }
+                else {
+                    for (const uid of toDelete) {
+                        this.db.deleteMessage(accountId, uid);
+                        this.bodyStore.deleteMessage(accountId, folder.id, uid).catch(() => { });
+                    }
+                    if (toDelete.length > 0)
+                        console.log(`  [api] ${accountId}/${folder.path}: ${toDelete.length} deleted`);
                 }
             }
-            if (deleted > 0)
-                console.log(`  [api] ${accountId}/${folder.path}: ${deleted} deleted`);
         }
         catch (e) {
             console.error(`  [api] ${accountId}/${folder.path}: reconciliation error: ${e.message}`);
@@ -970,12 +990,15 @@ export class ImapManager extends EventEmitter {
     }
     /** Store API-fetched messages to DB */
     storeApiMessages(accountId, folderId, msgs, highestUid) {
+        // highestUid kept for signature compatibility but no longer used to
+        // filter — Gmail message IDs aren't monotonic, so `msg.uid <= highestUid`
+        // would drop brand-new messages whose hash happens to be smaller than
+        // the previous high. upsertMessage's primary-key dedup handles it.
+        void highestUid;
         let stored = 0;
         this.db.beginTransaction();
         try {
             for (const msg of msgs) {
-                if (msg.uid <= highestUid)
-                    continue;
                 const flags = [];
                 if (msg.seen)
                     flags.push("\\Seen");
@@ -1802,15 +1825,21 @@ export class ImapManager extends EventEmitter {
         fs.writeFileSync(path.join(localQueue, filename), rawMessage);
         console.log(`  [outbox] Saved locally: ${filename}`);
     }
-    /** Process local file queue — send from outbox/ only (IMAP-unreachable fallback).
-     *  Do NOT scan sending/<acct>/queued/ — that was causing every sent message to be
-     *  re-APPENDed to the IMAP Outbox on the next tick and delivered twice. */
+    /** Process local file queue — scan both outbox/ (IMAP-unreachable fallback)
+     *  and sending/<acct>/queued/ (manual drop-in, crash recovery). The earlier
+     *  double-send bug was caused by queueOutgoing() WRITING a debug copy to
+     *  sending/queued/ on every send — that write is gone now, so scanning the
+     *  directory is safe again. Any legitimate files that land there (crash
+     *  recovery, manual drop) will get sent. */
     async processLocalQueue(accountId) {
         const outboxDir = path.join(getConfigDir(), "outbox", accountId);
+        const queuedDir = path.join(getConfigDir(), "sending", accountId, "queued");
         const filesToSend = [];
-        if (fs.existsSync(outboxDir)) {
-            for (const file of fs.readdirSync(outboxDir).filter(f => f.endsWith(".ltr") || f.endsWith(".eml"))) {
-                filesToSend.push({ dir: outboxDir, file });
+        for (const dir of [outboxDir, queuedDir]) {
+            if (!fs.existsSync(dir))
+                continue;
+            for (const file of fs.readdirSync(dir).filter(f => f.endsWith(".ltr") || f.endsWith(".eml"))) {
+                filesToSend.push({ dir, file });
             }
         }
         if (filesToSend.length === 0)

package/packages/mailx-imap/providers/gmail-api.d.ts

@@ -8,7 +8,11 @@ export declare class GmailApiProvider implements MailProvider {
     constructor(tokenProvider: () => Promise<string>);
     private fetch;
     listFolders(): Promise<ProviderFolder[]>;
-    /** List message IDs matching a query, handling pagination */
+    /** List message IDs matching a query, handling pagination.
+     *  IMPORTANT: on any error we throw — do NOT return a partial list, because
+     *  callers use this for sync reconciliation and a short list would delete
+     *  real messages from the local DB. Returning [] silently caused the
+     *  "INBOX empty in mailx" bug when a rate-limit hit mid-pagination. */
     private listMessageIds;
     /** Batch-fetch message metadata or full content */
     private batchFetch;

package/packages/mailx-imap/providers/gmail-api.js

@@ -93,10 +93,15 @@ export class GmailApiProvider {
         }
         return folders;
     }
-    /** List message IDs matching a query, handling pagination */
+    /** List message IDs matching a query, handling pagination.
+     *  IMPORTANT: on any error we throw — do NOT return a partial list, because
+     *  callers use this for sync reconciliation and a short list would delete
+     *  real messages from the local DB. Returning [] silently caused the
+     *  "INBOX empty in mailx" bug when a rate-limit hit mid-pagination. */
     async listMessageIds(query, maxResults = 500) {
         const ids = [];
         let pageToken = "";
+        let truncated = false;
         while (true) {
             const params = new URLSearchParams({ q: query, maxResults: String(Math.min(maxResults - ids.length, 500)) });
             if (pageToken)
@@ -105,10 +110,17 @@ export class GmailApiProvider {
             for (const msg of data.messages || []) {
                 ids.push(msg.id);
             }
-            if (!data.nextPageToken || ids.length >= maxResults)
+            if (!data.nextPageToken)
                 break;
+            if (ids.length >= maxResults) {
+                // Hit the caller's cap but the server has more. Flag it so
+                // reconcile-style callers can refuse to treat this as complete.
+                truncated = true;
+                break;
+            }
             pageToken = data.nextPageToken;
         }
+        ids._truncated = truncated;
         return ids;
     }
     /** Batch-fetch message metadata or full content */
@@ -170,12 +182,15 @@ export class GmailApiProvider {
         };
     }
     async fetchSince(folder, sinceUid, options = {}) {
-        // Gmail doesn't have UIDs — use date-based query for incremental
-        // For now, fetch recent messages and let the caller filter by UID
+        // Gmail message IDs are hash-derived, NOT monotonic — filtering by
+        // `uid > sinceUid` silently drops new messages whose hash happens to
+        // fall below the high-water mark. Fetch the most recent page and let
+        // upsertMessage dedupe by (account, folder, uid). The sinceUid arg is
+        // kept for interface compatibility but no longer used for filtering.
+        void sinceUid;
         const query = `in:${this.folderToLabel(folder)}`;
         const ids = await this.listMessageIds(query, 200);
-        const messages = await this.batchFetch(ids, options);
-        return messages.filter(m => m.uid > sinceUid);
+        return this.batchFetch(ids, options);
     }
     async fetchByDate(folder, since, before, options = {}, onChunk) {
         const afterDate = this.formatDate(since);
@@ -213,7 +228,11 @@ export class GmailApiProvider {
     async getUids(folder) {
         const query = `in:${this.folderToLabel(folder)}`;
         const ids = await this.listMessageIds(query, 10000);
-        return ids.map(idToUid);
+        const result = ids.map(idToUid);
+        // Propagate the truncation flag so reconcile can refuse to delete.
+        if (ids._truncated)
+            result._truncated = true;
+        return result;
     }
     async close() {
         // No persistent connection to close

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

@@ -55,6 +55,10 @@ export declare class MailxService {
     searchContacts(query: string): any[];
     syncGoogleContacts(): Promise<void>;
     seedContacts(): number;
+    /** Explicit add to address book — used by the right-click "Add to contacts"
+     *  action on From/To/Cc addresses in the message viewer. Just calls the same
+     *  validated upsert path as recordSentAddress. */
+    addContact(name: string, email: string): boolean;
     getSettings(): any;
     saveSettings(settings: any): void;
     getStorageInfo(): {

package/packages/mailx-service/index.js

@@ -378,16 +378,51 @@ export class MailxService {
         // Generate a unique Message-ID (required for threading, dedup, and RFC compliance)
         const domain = account.email.split("@")[1] || "mailx.local";
         const messageId = `<${Date.now()}.${Math.random().toString(36).slice(2)}@${domain}>`;
-        const headers = [
+        const hasAttachments = Array.isArray(msg.attachments) && msg.attachments.length > 0;
+        const commonHeaders = [
             `From: ${fromHeader}`, `To: ${to}`,
             cc ? `Cc: ${cc}` : null, bcc ? `Bcc: ${bcc}` : null,
             `Subject: ${msg.subject}`, `Date: ${new Date().toUTCString()}`,
             `Message-ID: ${messageId}`,
             msg.inReplyTo ? `In-Reply-To: ${msg.inReplyTo}` : null,
             msg.references?.length ? `References: ${msg.references.join(" ")}` : null,
-            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: quoted-printable`,
-        ].filter(h => h !== null).join("\r\n");
-        const rawMessage = `${headers}\r\n\r\n${bodyEncoded}`;
+            `MIME-Version: 1.0`,
+        ].filter(h => h !== null);
+        let rawMessage;
+        if (hasAttachments) {
+            // multipart/mixed with the body + one base64 attachment part per file.
+            // Each attachment chunk is wrapped at 76-char lines per RFC 2045.
+            const boundary = `mailx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+            const wrap76 = (s) => s.replace(/.{1,76}/g, m => m).match(/.{1,76}/g)?.join("\r\n") || s;
+            const parts = [];
+            parts.push(`--${boundary}\r\n` +
+                `Content-Type: text/html; charset=UTF-8\r\n` +
+                `Content-Transfer-Encoding: quoted-printable\r\n\r\n` +
+                `${bodyEncoded}\r\n`);
+            for (const att of msg.attachments) {
+                const filename = (att.filename || "attachment").replace(/[\r\n"]/g, "_");
+                const mime = att.mimeType || "application/octet-stream";
+                const wrapped = wrap76(att.dataBase64 || "");
+                parts.push(`--${boundary}\r\n` +
+                    `Content-Type: ${mime}; name="${filename}"\r\n` +
+                    `Content-Disposition: attachment; filename="${filename}"\r\n` +
+                    `Content-Transfer-Encoding: base64\r\n\r\n` +
+                    `${wrapped}\r\n`);
+            }
+            const headers = [
+                ...commonHeaders,
+                `Content-Type: multipart/mixed; boundary="${boundary}"`,
+            ].join("\r\n");
+            rawMessage = `${headers}\r\n\r\n${parts.join("")}--${boundary}--\r\n`;
+        }
+        else {
+            const headers = [
+                ...commonHeaders,
+                `Content-Type: text/html; charset=UTF-8`,
+                `Content-Transfer-Encoding: quoted-printable`,
+            ].join("\r\n");
+            rawMessage = `${headers}\r\n\r\n${bodyEncoded}`;
+        }
         this.imapManager.queueOutgoingLocal(account.id, rawMessage);
         console.log(`  Queued locally: ${msg.subject} via ${account.id} from ${fromHeader}`);
         for (const addr of msg.to)
@@ -615,6 +650,15 @@ export class MailxService {
         console.log(`  Seeded ${added} contacts from message history`);
         return added;
     }
+    /** Explicit add to address book — used by the right-click "Add to contacts"
+     *  action on From/To/Cc addresses in the message viewer. Just calls the same
+     *  validated upsert path as recordSentAddress. */
+    addContact(name, email) {
+        if (!email || !/^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/.test(email))
+            return false;
+        this.db.recordSentAddress(name || "", email);
+        return true;
+    }
     // ── Settings ──
     getSettings() {
         return loadSettings();

package/packages/mailx-service/jsonrpc.js

@@ -94,6 +94,8 @@ async function dispatchAction(svc, action, p) {
             return svc.search(p.query, p.page, p.pageSize, p.scope, p.accountId, p.folderId);
         case "searchContacts":
             return svc.searchContacts(p.query);
+        case "addContact":
+            return { ok: svc.addContact(p.name, p.email) };
         // Settings
         case "getSettings":
             return svc.getSettings();