@bobfrankston/mailx 1.0.92 → 1.0.93

package/client/app.js

@@ -5,7 +5,7 @@
 import { initFolderTree, refreshFolderTree } from "./components/folder-tree.js";
 import { initMessageList, loadMessages, loadUnifiedInbox, loadSearchResults, reloadCurrentFolder, getSelectedMessages } from "./components/message-list.js";
 import { showMessage, getCurrentMessage } from "./components/message-viewer.js";
-import { connectWebSocket, onWsEvent, triggerSync, getAccounts, getFolders, deleteMessage, undeleteMessage, restartServer, rebuildServer, getSyncPending, getServerUrl, setServerUrl } from "./lib/api-client.js";
+import { connectWebSocket, onWsEvent, triggerSync, getAccounts, getFolders, deleteMessage, undeleteMessage, restartServer, rebuildServer } from "./lib/api-client.js";
 // ── New message badge (favicon + title) ──
 let baseTitle = "mailx";
 let lastSeenCount = 0;
@@ -781,211 +781,37 @@ optEditorTiptap?.addEventListener("change", () => {
         saveEditorSetting("tiptap");
 });
 const isApp = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-// Dismiss startup overlay immediately in browser/local mode — the UI components
-// have their own loading states ("Loading accounts...", etc.). Only keep the
-// overlay for native app mode where ensureServer needs to start the server.
-if (!isApp) {
-    const overlay = document.getElementById("startup-overlay");
-    if (overlay) {
-        overlay.classList.add("hidden");
-        setTimeout(() => overlay.remove(), 400);
+fetch("/api/version").then(r => r.json()).then(d => {
+    const el = document.getElementById("app-version");
+    const storage = d.storage || {};
+    const storageLabel = storage.provider && storage.provider !== "local" ? ` [${storage.provider}]` : "";
+    if (el)
+        el.textContent = `mailx v${d.version}${storageLabel}${isApp ? "" : " [browser]"}`;
+}).catch(async () => {
+    // Server not running — try to start it if we're in the app
+    const startupStatus = document.getElementById("startup-status");
+    if (isApp) {
+        if (startupStatus)
+            startupStatus.textContent = "Starting server...";
+        await mailxapi.ensureServer();
+        location.reload();
     }
-}
-async function checkServer() {
-    const base = getServerUrl();
-    try {
-        const res = await fetch(`${base}/api/version`, { signal: AbortSignal.timeout(5000) });
-        const ct = res.headers.get("content-type") || "";
-        if (ct.includes("text/html") || !res.ok)
-            throw new Error("not JSON");
-        const d = await res.json();
+    else {
         const el = document.getElementById("app-version");
-        const storage = d.storage || { provider: "local", mode: "local" };
-        const storageLabel = storage.provider === "local" ? "" : ` · ${storage.provider}${storage.mode === "api" ? " (API)" : ""}`;
         if (el)
-            el.textContent = `mailx v${d.version}${storageLabel}${isApp ? "" : " · browser"}`;
-        // Hide startup overlay on success
-        const overlay = document.getElementById("startup-overlay");
-        if (overlay) {
-            overlay.classList.add("hidden");
-            setTimeout(() => overlay.remove(), 400);
-        }
+            el.textContent = "mailx [server offline]";
+        if (startupStatus)
+            startupStatus.textContent = "Server offline — start with: node packages/mailx-server/index.js";
     }
-    catch {
-        const startupStatus = document.getElementById("startup-status");
-        if (isApp && mailxapi?.ensureServer) {
-            // Desktop native app — start the embedded server
-            if (startupStatus)
-                startupStatus.textContent = "Starting server...";
-            await mailxapi.ensureServer();
-            location.reload();
-        }
-        else if (isApp) {
-            // MAUI Android app — runs via bridge, no HTTP server
-            const overlay = document.getElementById("startup-overlay");
-            const content = overlay?.querySelector(".startup-content");
-            if (content) {
-                content.innerHTML = `
-                    <div style="text-align:center;max-width:400px">
-                        <h2 style="margin-bottom:1rem;color:var(--color-text)">mailx</h2>
-                        <p style="color:var(--color-text-muted);font-size:0.9rem" id="bridge-status">
-                            Initializing...
-                        </p>
-                    </div>`;
-            }
-            if (overlay)
-                overlay.hidden = false;
-            // Initialize local service
-            try {
-                const localService = await import("./lib/local-service.js");
-                const statusEl = document.getElementById("bridge-status");
-                // Check for saved settings
-                let savedSettings = localService.getSettings();
-                if (!savedSettings || !savedSettings.accounts?.length) {
-                    // No settings — prompt for account
-                    if (statusEl)
-                        statusEl.textContent = "No accounts configured";
-                    if (content) {
-                        content.innerHTML = `
-                            <div style="text-align:center;max-width:400px">
-                                <h2 style="margin-bottom:1rem;color:var(--color-text)">mailx — Setup</h2>
-                                <p style="color:var(--color-text-muted);font-size:0.9rem;margin-bottom:1rem">
-                                    Enter your email account to get started.
-                                </p>
-                                <input type="email" id="setup-email" placeholder="you@example.com" style="width:100%;padding:0.5rem;border:1px solid var(--color-border);border-radius:4px;background:var(--color-bg);color:var(--color-text);font-size:1rem;margin-bottom:0.5rem">
-                                <input type="text" id="setup-imap" placeholder="IMAP server (e.g. imap.example.com)" style="width:100%;padding:0.5rem;border:1px solid var(--color-border);border-radius:4px;background:var(--color-bg);color:var(--color-text);font-size:1rem;margin-bottom:0.5rem">
-                                <input type="password" id="setup-pass" placeholder="Password" style="width:100%;padding:0.5rem;border:1px solid var(--color-border);border-radius:4px;background:var(--color-bg);color:var(--color-text);font-size:1rem;margin-bottom:0.75rem">
-                                <button id="setup-go" style="padding:0.5rem 1.5rem;background:var(--color-accent);color:#fff;border:none;border-radius:4px;font-size:1rem;cursor:pointer">Connect</button>
-                                <p id="setup-error" style="margin-top:0.75rem;color:oklch(0.65 0.2 25);font-size:0.85rem" hidden></p>
-                            </div>`;
-                    }
-                    document.getElementById("setup-go")?.addEventListener("click", async () => {
-                        const email = document.getElementById("setup-email").value.trim();
-                        const imap = document.getElementById("setup-imap").value.trim();
-                        const pass = document.getElementById("setup-pass").value;
-                        const errEl = document.getElementById("setup-error");
-                        if (!email || !pass) {
-                            errEl.textContent = "Email and password required";
-                            errEl.hidden = false;
-                            return;
-                        }
-                        const domain = email.split("@")[1] || "";
-                        const host = imap || `imap.${domain}`;
-                        const id = domain.replace(/\./g, "");
-                        const newSettings = {
-                            accounts: [{
-                                    id, name: email.split("@")[0], email,
-                                    imap: { host, port: 993, user: email, password: pass, auth: "password" },
-                                    smtp: { host: `smtp.${domain}`, port: 587, user: email, password: pass, auth: "password" },
-                                    enabled: true,
-                                }],
-                            ui: { theme: "system" },
-                            sync: { intervalMinutes: 5, historyDays: 100 },
-                        };
-                        errEl.hidden = true;
-                        document.getElementById("setup-go").textContent = "Connecting...";
-                        await localService.initialize(newSettings);
-                        if (overlay)
-                            overlay.hidden = true;
-                    });
-                }
-                else {
-                    // Settings exist — initialize and sync
-                    if (statusEl)
-                        statusEl.textContent = "Loading accounts...";
-                    await localService.initialize();
-                    if (overlay)
-                        overlay.hidden = true;
-                }
-            }
-            catch (e) {
-                const statusEl = document.getElementById("bridge-status");
-                if (statusEl)
-                    statusEl.textContent = `Error: ${e.message}`;
-            }
-        }
-        else if (getServerUrl()) {
-            // Remote server configured but unreachable — prompt to change URL
-            promptForServer();
-        }
-        else {
-            // Local server not responding — dismiss overlay, show UI with offline status
-            const overlay = document.getElementById("startup-overlay");
-            if (overlay) {
-                overlay.classList.add("hidden");
-                setTimeout(() => overlay.remove(), 400);
-            }
-            const statusSync = document.getElementById("status-sync");
-            if (statusSync) {
-                statusSync.textContent = "SERVER OFFLINE";
-                statusSync.style.color = "oklch(0.65 0.2 25)";
-            }
-        }
-    }
-}
-function promptForServer() {
-    const overlay = document.getElementById("startup-overlay");
-    const content = overlay?.querySelector(".startup-content");
-    if (!content)
-        return;
-    const current = getServerUrl();
-    content.innerHTML = `
-        <div style="text-align:center;max-width:400px">
-            <h2 style="margin-bottom:1rem;color:var(--color-text)">Connect to mailx server</h2>
-            <p style="margin-bottom:1rem;color:var(--color-text-muted);font-size:0.9rem">
-                Enter the address of your mailx server (running on your desktop or network).
-            </p>
-            <input type="text" id="server-url-input" placeholder="http://192.168.1.x:9333"
-                value="${current}" autocomplete="off"
-                style="width:100%;padding:0.5rem;border:1px solid var(--color-border);border-radius:var(--radius-sm);
-                       background:var(--color-bg);color:var(--color-text);font-size:1rem;margin-bottom:0.75rem">
-            <button id="server-url-btn" style="padding:0.5rem 1.5rem;background:var(--color-accent);color:#fff;
-                    border:none;border-radius:var(--radius-sm);font-size:1rem;cursor:pointer">Connect</button>
-            <p id="server-url-error" style="margin-top:0.75rem;color:oklch(0.65 0.2 25);font-size:0.85rem" hidden></p>
-        </div>
-    `;
-    if (overlay)
-        overlay.hidden = false;
-    const input = document.getElementById("server-url-input");
-    const btn = document.getElementById("server-url-btn");
-    const err = document.getElementById("server-url-error");
-    async function tryConnect() {
-        const url = input.value.trim().replace(/\/$/, "");
-        if (!url) {
-            err.textContent = "Enter a server URL";
-            err.hidden = false;
-            return;
-        }
-        btn.disabled = true;
-        btn.textContent = "Connecting...";
-        err.hidden = true;
-        try {
-            const res = await fetch(`${url}/api/version`, { signal: AbortSignal.timeout(5000) });
-            const ct = res.headers.get("content-type") || "";
-            if (ct.includes("text/html") || !res.ok)
-                throw new Error("Server returned an error page");
-            await res.json();
-            setServerUrl(url);
-            location.reload();
-        }
-        catch (e) {
-            btn.disabled = false;
-            btn.textContent = "Connect";
-            err.textContent = e.message || "Cannot reach server";
-            err.hidden = false;
-        }
-    }
-    btn.addEventListener("click", tryConnect);
-    input.addEventListener("keydown", (e) => { if (e.key === "Enter")
-        tryConnect(); });
-    input.focus();
-}
-checkServer();
+});
 // ── Sync pending indicator + server health check ──
 let serverDown = false;
 setInterval(async () => {
     try {
-        const data = await getSyncPending();
+        const res = await fetch("/api/sync/pending");
+        if (!res.ok)
+            return;
+        const data = await res.json();
         const el = document.getElementById("status-pending");
         if (el) {
             el.textContent = data.pending > 0 ? `↻ ${data.pending} pending` : "";
@@ -1025,8 +851,7 @@ function scheduleMiddnightRefresh() {
 }
 scheduleMiddnightRefresh();
 // ── Apply theme from settings ──
-const svrBase = getServerUrl();
-fetch(`${svrBase}/api/version`).then(r => r.json()).then(d => {
+fetch("/api/version").then(r => r.json()).then(d => {
     if (d.theme === "dark")
         document.documentElement.classList.add("theme-dark");
     else if (d.theme === "light")

package/client/lib/api-client.js

@@ -1,14 +1,14 @@
 /**
- * API client — transport-agnostic.
- * Automatically selects the right transport:
- *   - HttpTransport: browser mode (REST + WebSocket)
- *   - IPC: injected by native launcher (mailxapi global)
- *   - BridgeTransport: Android (capacitor-nodejs bridge) — future
+ * API client — auto-detects IPC (WebView) vs HTTP (browser).
+ * When mailxapi is available (injected by launcher), calls go directly via IPC.
+ * Otherwise falls back to REST/WebSocket.
  *
  * All server operations MUST go through these centralized methods.
  * Never use fetch("/api/...") directly in components.
  */
-// ── HTTP Transport (browser mode) ──
+const hasIPC = typeof mailxapi !== "undefined" && mailxapi?.isApp;
+// ── HTTP fallback ──
+// Abort controller for message-list requests — cancel stale fetches when folder changes
 let messageListAbort = null;
 export function abortMessageListRequests() {
     if (messageListAbort) {
@@ -21,290 +21,206 @@ function newMessageListSignal() {
     messageListAbort = new AbortController();
     return messageListAbort.signal;
 }
-/** Server base URL — empty for same-origin, set by remote config for mobile */
-let serverUrl = localStorage.getItem("mailx-server-url") || "";
-/** Set the server URL (for mobile/remote mode) */
-export function setServerUrl(url) {
-    serverUrl = url.replace(/\/$/, "");
-    localStorage.setItem("mailx-server-url", serverUrl);
-}
-/** Get the configured server URL */
-export function getServerUrl() { return serverUrl; }
-class HttpTransport {
-    handlers = [];
-    async call(method, params) {
-        const route = httpRoutes[method];
-        if (!route)
-            throw new Error(`Unknown method: ${method}`);
-        const { path, options } = route(params);
-        const base = serverUrl ? serverUrl : "";
-        let res;
-        try {
-            // Default 10s timeout prevents hangs when server is zombie (accepts TCP, never responds)
-            const fetchOptions = {
-                headers: { "Content-Type": "application/json" },
-                ...options,
-            };
-            if (!fetchOptions.signal) {
-                fetchOptions.signal = AbortSignal.timeout(10000);
-            }
-            res = await fetch(`${base}/api${path}`, fetchOptions);
-        }
-        catch (e) {
-            if (e.name === "AbortError")
-                throw e;
-            if (e.name === "TimeoutError")
-                throw new Error("Server not responding — request timed out");
-            throw new Error("Server offline — check connection or run: mailx -server");
-        }
-        // Detect HTML error responses (server not reachable, returns error page)
-        const ct = res.headers.get("content-type") || "";
-        if (ct.includes("text/html")) {
-            throw new Error("Server returned HTML instead of JSON — check server URL");
-        }
-        if (!res.ok) {
-            const err = await res.json().catch(() => ({ error: res.statusText }));
-            throw new Error(err.error || res.statusText);
-        }
-        return res.json();
-    }
-    onEvent(handler) {
-        this.handlers.push(handler);
-    }
-    connect() {
-        let wsUrl;
-        if (serverUrl) {
-            // Remote server — derive WS URL from HTTP URL
-            const u = new URL(serverUrl);
-            wsUrl = `${u.protocol === "https:" ? "wss:" : "ws:"}//${u.host}`;
-        }
-        else {
-            wsUrl = `${location.protocol === "https:" ? "wss:" : "ws:"}//${location.host}`;
-        }
-        const ws = new WebSocket(wsUrl);
-        ws.onmessage = (ev) => {
-            try {
-                const event = JSON.parse(ev.data);
-                for (const h of this.handlers)
-                    h(event);
-            }
-            catch { /* ignore */ }
-        };
-        ws.onclose = () => { setTimeout(() => this.connect(), 3000); };
-    }
-}
-class IpcTransport {
-    async call(method, params) {
-        // IPC methods are direct function calls on the injected mailxapi object
-        const p = params || {};
-        switch (method) {
-            case "getAccounts": return mailxapi.getAccounts();
-            case "getFolders": return mailxapi.getFolders(p.accountId);
-            case "getMessages": return mailxapi.getMessages(p.accountId, p.folderId, p.page, p.pageSize);
-            case "getUnifiedInbox": return mailxapi.getUnifiedInbox(p.page, p.pageSize);
-            case "searchMessages": return mailxapi.searchMessages(p.query, p.page, p.pageSize);
-            case "getMessage": return mailxapi.getMessage(p.accountId, p.uid, p.allowRemote, p.folderId);
-            case "updateFlags": return mailxapi.updateFlags(p.accountId, p.uid, p.flags);
-            case "triggerSync": return mailxapi.syncAll();
-            case "getSyncPending": return mailxapi.getSyncPending();
-            case "searchContacts": return mailxapi.searchContacts(p.query);
-            case "allowRemoteContent": return mailxapi.allowRemoteContent(p.type, p.value);
-            case "deleteMessage": return mailxapi.deleteMessage(p.accountId, p.uid);
-            case "undeleteMessage": return mailxapi.undeleteMessage(p.accountId, p.uid, p.folderId);
-            case "moveMessage": return mailxapi.moveMessage(p.accountId, p.uid, p.targetFolderId, p.targetAccountId);
-            case "restartServer": return mailxapi.restart?.();
-            case "markFolderRead": return mailxapi.markFolderRead?.(p.accountId, p.folderId);
-            case "createFolder": return mailxapi.createFolder?.(p.accountId, p.parentPath, p.name);
-            case "renameFolder": return mailxapi.renameFolder?.(p.accountId, p.folderId, p.newName);
-            case "deleteFolder": return mailxapi.deleteFolder?.(p.accountId, p.folderId);
-            case "emptyFolder": return mailxapi.emptyFolder?.(p.accountId, p.folderId);
-            case "sendMessage": return mailxapi.sendMessage?.(p.body);
-            case "saveDraft": return mailxapi.saveDraft?.(p.body);
-            default: throw new Error(`Unknown IPC method: ${method}`);
-        }
-    }
-    onEvent(handler) {
-        mailxapi.onEvent(handler);
-    }
-    connect() {
-        // IPC events are push-based — no connection needed
-    }
-}
-const httpRoutes = {
-    getAccounts: () => ({ path: "/accounts" }),
-    getFolders: (p) => ({ path: `/folders/${p.accountId}` }),
-    getMessages: (p) => ({
-        path: `/messages/${p.accountId}/${p.folderId}?page=${p.page || 1}&pageSize=${p.pageSize || 50}`,
-        options: { signal: newMessageListSignal() }
-    }),
-    getUnifiedInbox: (p) => ({
-        path: `/messages/unified/inbox?page=${p.page || 1}&pageSize=${p.pageSize || 50}`,
-        options: { signal: newMessageListSignal() }
-    }),
-    searchMessages: (p) => {
-        const params = new URLSearchParams({ q: p.query, page: String(p.page || 1), pageSize: String(p.pageSize || 50), scope: p.scope || "all" });
-        if ((p.scope === "current" || p.scope === "server") && p.accountId) {
-            params.set("accountId", p.accountId);
-            params.set("folderId", String(p.folderId));
-        }
-        return { path: `/search?${params}` };
-    },
-    getMessage: (p) => {
-        const params = new URLSearchParams();
-        if (p.allowRemote)
-            params.set("allowRemote", "true");
-        if (p.folderId != null)
-            params.set("folderId", String(p.folderId));
-        const q = params.toString() ? `?${params}` : "";
-        return { path: `/message/${p.accountId}/${p.uid}${q}` };
-    },
-    updateFlags: (p) => ({
-        path: `/message/${p.accountId}/${p.uid}/flags`,
-        options: { method: "PATCH", body: JSON.stringify({ flags: p.flags }) }
-    }),
-    triggerSync: () => ({ path: "/sync", options: { method: "POST" } }),
-    getSyncPending: () => ({ path: "/sync/pending" }),
-    searchContacts: (p) => ({ path: `/contacts?q=${encodeURIComponent(p.query)}` }),
-    allowRemoteContent: (p) => ({
-        path: "/settings/allow-remote",
-        options: { method: "POST", body: JSON.stringify({ type: p.type, value: p.value }) }
-    }),
-    deleteMessage: (p) => ({ path: `/message/${p.accountId}/${p.uid}`, options: { method: "DELETE" } }),
-    undeleteMessage: (p) => ({
-        path: `/message/${p.accountId}/${p.uid}/undelete`,
-        options: { method: "POST", body: JSON.stringify({ folderId: p.folderId }) }
-    }),
-    moveMessage: (p) => {
-        const body = { targetFolderId: p.targetFolderId };
-        if (p.targetAccountId)
-            body.targetAccountId = p.targetAccountId;
-        return { path: `/message/${p.accountId}/${p.uid}/move`, options: { method: "POST", body: JSON.stringify(body) } };
-    },
-    restartServer: () => ({ path: "/restart", options: { method: "POST" } }),
-    rebuildServer: () => ({ path: "/rebuild", options: { method: "POST" } }),
-    markFolderRead: (p) => ({ path: `/folder/${p.accountId}/${p.folderId}/mark-read`, options: { method: "POST" } }),
-    createFolder: (p) => ({
-        path: `/folder/${p.accountId}`,
-        options: { method: "POST", body: JSON.stringify({ parentPath: p.parentPath, name: p.name }) }
-    }),
-    renameFolder: (p) => ({
-        path: `/folder/${p.accountId}/${p.folderId}/rename`,
-        options: { method: "POST", body: JSON.stringify({ newName: p.newName }) }
-    }),
-    deleteFolder: (p) => ({ path: `/folder/${p.accountId}/${p.folderId}`, options: { method: "DELETE" } }),
-    emptyFolder: (p) => ({ path: `/folder/${p.accountId}/${p.folderId}/empty`, options: { method: "POST" } }),
-    sendMessage: (p) => ({ path: "/send", options: { method: "POST", body: JSON.stringify(p.body) } }),
-    saveDraft: (p) => ({ path: "/draft", options: { method: "POST", body: JSON.stringify(p.body) } }),
-};
-// ── Local Transport (MAUI Android — runs IMAP in WebView via bridge) ──
-class LocalTransport {
-    handlers = [];
-    localService = null;
-    async call(method, params) {
-        if (!this.localService) {
-            this.localService = await import("./local-service.js");
-        }
-        return this.localService.handleCall(method, params || {});
+async function api(path, options) {
+    let res;
+    try {
+        res = await fetch(`/api${path}`, {
+            headers: { "Content-Type": "application/json" },
+            ...options
+        });
     }
-    onEvent(handler) {
-        this.handlers.push(handler);
+    catch (e) {
+        // Network error — server is down
+        if (e.name === "AbortError")
+            throw e;
+        throw new Error("Server offline — run: mailx -server");
     }
-    async connect() {
-        if (!this.localService) {
-            this.localService = await import("./local-service.js");
-        }
-        // Forward events from local service to transport handlers
-        this.localService.onEvent((event) => {
-            for (const h of this.handlers)
-                h(event);
-        });
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({ error: res.statusText }));
+        throw new Error(err.error || res.statusText);
     }
+    return res.json();
 }
-// ── Select transport ──
-const hasIPC = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-const hasBridge = typeof mailxapi !== "undefined" && mailxapi?.tcp !== undefined;
-const hasEnsureServer = typeof mailxapi !== "undefined" && mailxapi?.ensureServer !== undefined;
-// MAUI bridge (has tcp but no ensureServer) → LocalTransport
-// Desktop native (has ensureServer) → IpcTransport
-// Browser → HttpTransport
-const transport = hasBridge && !hasEnsureServer
-    ? new LocalTransport()
-    : hasIPC ? new IpcTransport() : new HttpTransport();
-// ── Public API (unchanged signatures for all callers) ──
+// ── API Methods (IPC or HTTP) ──
 export function getAccounts() {
-    return transport.call("getAccounts");
+    if (hasIPC)
+        return mailxapi.getAccounts();
+    return api("/accounts");
 }
 export function getFolders(accountId) {
-    return transport.call("getFolders", { accountId });
+    if (hasIPC)
+        return mailxapi.getFolders(accountId);
+    return api(`/folders/${accountId}`);
 }
 export function getMessages(accountId, folderId, page = 1, pageSize = 50) {
-    return transport.call("getMessages", { accountId, folderId, page, pageSize });
+    if (hasIPC)
+        return mailxapi.getMessages(accountId, folderId, page, pageSize);
+    const signal = newMessageListSignal();
+    return api(`/messages/${accountId}/${folderId}?page=${page}&pageSize=${pageSize}`, { signal });
 }
 export function getUnifiedInbox(page = 1, pageSize = 50) {
-    return transport.call("getUnifiedInbox", { page, pageSize });
+    if (hasIPC)
+        return mailxapi.getUnifiedInbox(page, pageSize);
+    const signal = newMessageListSignal();
+    return api(`/messages/unified/inbox?page=${page}&pageSize=${pageSize}`, { signal });
 }
 export function searchMessages(query, page = 1, pageSize = 50, scope = "all", accountId = "", folderId = 0) {
-    return transport.call("searchMessages", { query, page, pageSize, scope, accountId, folderId });
+    if (hasIPC)
+        return mailxapi.searchMessages(query, page, pageSize);
+    const params = new URLSearchParams({ q: query, page: String(page), pageSize: String(pageSize), scope });
+    if (scope === "current" && accountId) {
+        params.set("accountId", accountId);
+        params.set("folderId", String(folderId));
+    }
+    if (scope === "server" && accountId) {
+        params.set("accountId", accountId);
+        params.set("folderId", String(folderId));
+    }
+    return api(`/search?${params}`);
 }
 export function getMessage(accountId, uid, allowRemote = false, folderId) {
-    return transport.call("getMessage", { accountId, uid, allowRemote, folderId });
+    if (hasIPC)
+        return mailxapi.getMessage(accountId, uid, allowRemote, folderId);
+    const params = new URLSearchParams();
+    if (allowRemote)
+        params.set("allowRemote", "true");
+    if (folderId != null)
+        params.set("folderId", String(folderId));
+    const q = params.toString() ? `?${params}` : "";
+    return api(`/message/${accountId}/${uid}${q}`);
 }
 export function updateFlags(accountId, uid, flags) {
-    return transport.call("updateFlags", { accountId, uid, flags });
+    if (hasIPC)
+        return mailxapi.updateFlags(accountId, uid, flags);
+    return api(`/message/${accountId}/${uid}/flags`, {
+        method: "PATCH",
+        body: JSON.stringify({ flags })
+    });
 }
 export function triggerSync() {
-    return transport.call("triggerSync");
+    if (hasIPC)
+        return mailxapi.syncAll();
+    return api("/sync", { method: "POST" });
 }
 export function getSyncPending() {
-    return transport.call("getSyncPending");
+    if (hasIPC)
+        return mailxapi.getSyncPending();
+    return api("/sync/pending");
 }
 export function searchContacts(query) {
-    return transport.call("searchContacts", { query });
+    if (hasIPC)
+        return mailxapi.searchContacts(query);
+    return api(`/contacts?q=${encodeURIComponent(query)}`);
 }
 export function allowRemoteContent(type, value) {
-    return transport.call("allowRemoteContent", { type, value });
+    if (hasIPC)
+        return mailxapi.allowRemoteContent(type, value);
+    return api("/settings/allow-remote", {
+        method: "POST",
+        body: JSON.stringify({ type, value })
+    });
 }
 export function deleteMessage(accountId, uid) {
-    return transport.call("deleteMessage", { accountId, uid });
+    if (hasIPC)
+        return mailxapi.deleteMessage?.(accountId, uid);
+    return api(`/message/${accountId}/${uid}`, { method: "DELETE" });
 }
 export function undeleteMessage(accountId, uid, folderId) {
-    return transport.call("undeleteMessage", { accountId, uid, folderId });
+    if (hasIPC)
+        return mailxapi.undeleteMessage?.(accountId, uid, folderId);
+    return api(`/message/${accountId}/${uid}/undelete`, {
+        method: "POST",
+        body: JSON.stringify({ folderId })
+    });
 }
 export function moveMessage(accountId, uid, targetFolderId, targetAccountId) {
-    return transport.call("moveMessage", { accountId, uid, targetFolderId, targetAccountId });
+    if (hasIPC)
+        return mailxapi.moveMessage?.(accountId, uid, targetFolderId, targetAccountId);
+    const body = { targetFolderId };
+    if (targetAccountId)
+        body.targetAccountId = targetAccountId;
+    return api(`/message/${accountId}/${uid}/move`, {
+        method: "POST",
+        body: JSON.stringify(body)
+    });
 }
 export function restartServer() {
-    return transport.call("restartServer").catch(() => { });
+    if (hasIPC)
+        return mailxapi.restart?.();
+    return api("/restart", { method: "POST" }).catch(() => { });
 }
 export function rebuildServer() {
-    return transport.call("rebuildServer").catch(() => { });
+    return api("/rebuild", { method: "POST" }).catch(() => { });
 }
 export function markFolderRead(accountId, folderId) {
-    return transport.call("markFolderRead", { accountId, folderId });
+    if (hasIPC)
+        return mailxapi.markFolderRead?.(accountId, folderId);
+    return api(`/folder/${accountId}/${folderId}/mark-read`, { method: "POST" });
 }
 export function createFolder(accountId, parentPath, name) {
-    return transport.call("createFolder", { accountId, parentPath, name });
+    if (hasIPC)
+        return mailxapi.createFolder?.(accountId, parentPath, name);
+    return api(`/folder/${accountId}`, {
+        method: "POST",
+        body: JSON.stringify({ parentPath, name })
+    });
 }
 export function renameFolder(accountId, folderId, newName) {
-    return transport.call("renameFolder", { accountId, folderId, newName });
+    if (hasIPC)
+        return mailxapi.renameFolder?.(accountId, folderId, newName);
+    return api(`/folder/${accountId}/${folderId}/rename`, {
+        method: "POST",
+        body: JSON.stringify({ newName })
+    });
 }
 export function deleteFolder(accountId, folderId) {
-    return transport.call("deleteFolder", { accountId, folderId });
+    if (hasIPC)
+        return mailxapi.deleteFolder?.(accountId, folderId);
+    return api(`/folder/${accountId}/${folderId}`, { method: "DELETE" });
 }
 export function emptyFolder(accountId, folderId) {
-    return transport.call("emptyFolder", { accountId, folderId });
+    if (hasIPC)
+        return mailxapi.emptyFolder?.(accountId, folderId);
+    return api(`/folder/${accountId}/${folderId}/empty`, { method: "POST" });
 }
 export function sendMessage(body) {
-    return transport.call("sendMessage", { body });
+    if (hasIPC)
+        return mailxapi.sendMessage?.(body);
+    return api("/send", { method: "POST", body: JSON.stringify(body) });
 }
 export function saveDraft(body) {
-    return transport.call("saveDraft", { body });
+    if (hasIPC)
+        return mailxapi.saveDraft?.(body);
+    return api("/draft", { method: "POST", body: JSON.stringify(body) });
 }
+const eventHandlers = [];
 export function onEvent(handler) {
-    transport.onEvent(handler);
+    eventHandlers.push(handler);
 }
 export function connectEvents() {
-    transport.connect();
+    if (hasIPC) {
+        // IPC events come via mailxapi.onEvent
+        mailxapi.onEvent((event) => {
+            for (const h of eventHandlers)
+                h(event);
+        });
+    }
+    else {
+        // WebSocket for HTTP mode
+        const protocol = location.protocol === "https:" ? "wss:" : "ws:";
+        const ws = new WebSocket(`${protocol}//${location.host}`);
+        ws.onmessage = (ev) => {
+            try {
+                const event = JSON.parse(ev.data);
+                for (const h of eventHandlers)
+                    h(event);
+            }
+            catch { /* ignore */ }
+        };
+        ws.onclose = () => {
+            setTimeout(connectEvents, 3000);
+        };
+    }
 }
 // Legacy exports for backward compatibility
 export const connectWebSocket = connectEvents;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.92",
+  "version": "1.0.93",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",