@bobfrankston/mailx 1.0.222 → 1.0.224

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.222",
+  "version": "1.0.224",
   "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.9",
+    "@bobfrankston/iflow-direct": "^0.1.10",
     "@bobfrankston/iflow-node": "^0.1.2",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.22",
-    "@bobfrankston/msger": "^0.1.284",
+    "@bobfrankston/msger": "^0.1.286",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -74,11 +74,11 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/iflow-direct": "^0.1.9",
+      "@bobfrankston/iflow-direct": "^0.1.10",
       "@bobfrankston/iflow-node": "^0.1.2",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.22",
-      "@bobfrankston/msger": "^0.1.284",
+      "@bobfrankston/msger": "^0.1.286",
       "@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

@@ -371,24 +371,35 @@ export class ImapManager extends EventEmitter {
             }
             const tokenDir = path.join(getConfigDir(), "tokens", account.imap.user.replace(/[@.]/g, "_"));
             tokenProvider = async () => {
-                const result = await authenticateOAuth(credPath, {
+                // Wrap authenticateOAuth with a 30s wall-clock timeout. Without this,
+                // a hung OAuth server could block the entire sync thread indefinitely.
+                const TOKEN_FETCH_TIMEOUT_MS = 30000;
+                const authPromise = authenticateOAuth(credPath, {
                     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,
                 });
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`OAuth token fetch timeout (${TOKEN_FETCH_TIMEOUT_MS / 1000}s)`)), TOKEN_FETCH_TIMEOUT_MS));
+                const result = await Promise.race([authPromise, timeoutPromise]);
                 return result?.access_token || "";
             };
         }
+        // Non-Gmail accounts (typically Dovecot / generic IMAP) get a smaller
+        // fetch chunk size (10 vs 25) and longer inactivity timeout (300s) so
+        // multi-body FETCH batches don't trip the connection-dead detector on
+        // slow servers. Gmail stays at the defaults since it's fast and has
+        // its own rate limits to respect.
+        const isGmail = account.imap.host?.includes("gmail") || account.email.endsWith("@gmail.com");
         const config = createAutoImapConfig({
             server: account.imap.host,
             port: account.imap.port,
             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,
+            inactivityTimeout: isGmail ? 60000 : 300000,
+            fetchChunkSize: isGmail ? 25 : 10,
+            fetchChunkSizeMax: isGmail ? 500 : 100,
         });
         this.configs.set(account.id, config);
         // Register account in DB
@@ -1825,15 +1836,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-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();