@bobfrankston/mailx 1.0.64 → 1.0.69

package/client/lib/api-client.js

@@ -1,11 +1,14 @@
 /**
- * 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.
+ * 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
+ *
+ * All server operations MUST go through these centralized methods.
+ * Never use fetch("/api/...") directly in components.
  */
-const hasIPC = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-// ── HTTP fallback ──
-// Abort controller for message-list requests — cancel stale fetches when folder changes
+// ── HTTP Transport (browser mode) ──
 let messageListAbort = null;
 export function abortMessageListRequests() {
     if (messageListAbort) {
@@ -18,216 +21,252 @@ function newMessageListSignal() {
     messageListAbort = new AbortController();
     return messageListAbort.signal;
 }
-async function api(path, options) {
-    let res;
-    try {
-        res = await fetch(`/api${path}`, {
-            headers: { "Content-Type": "application/json" },
-            ...options
-        });
+/** 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 {
+            res = await fetch(`${base}/api${path}`, {
+                headers: { "Content-Type": "application/json" },
+                ...options,
+            });
+        }
+        catch (e) {
+            if (e.name === "AbortError")
+                throw e;
+            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}`);
+        }
     }
-    catch (e) {
-        // Network error — server is down
-        if (e.name === "AbortError")
-            throw e;
-        throw new Error("Server offline — run: mailx -server");
+    onEvent(handler) {
+        mailxapi.onEvent(handler);
     }
-    if (!res.ok) {
-        const err = await res.json().catch(() => ({ error: res.statusText }));
-        throw new Error(err.error || res.statusText);
+    connect() {
+        // IPC events are push-based — no connection needed
     }
-    return res.json();
 }
-// ── API Methods (IPC or HTTP) ──
+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) } }),
+};
+// ── Select transport ──
+const hasIPC = typeof mailxapi !== "undefined" && mailxapi?.isApp;
+const transport = hasIPC ? new IpcTransport() : new HttpTransport();
+// ── Public API (unchanged signatures for all callers) ──
 export function getAccounts() {
-    if (hasIPC)
-        return mailxapi.getAccounts();
-    return api("/accounts");
+    return transport.call("getAccounts");
 }
 export function getFolders(accountId) {
-    if (hasIPC)
-        return mailxapi.getFolders(accountId);
-    return api(`/folders/${accountId}`);
+    return transport.call("getFolders", { accountId });
 }
 export function getMessages(accountId, folderId, page = 1, pageSize = 50) {
-    if (hasIPC)
-        return mailxapi.getMessages(accountId, folderId, page, pageSize);
-    const signal = newMessageListSignal();
-    return api(`/messages/${accountId}/${folderId}?page=${page}&pageSize=${pageSize}`, { signal });
+    return transport.call("getMessages", { accountId, folderId, page, pageSize });
 }
 export function getUnifiedInbox(page = 1, pageSize = 50) {
-    if (hasIPC)
-        return mailxapi.getUnifiedInbox(page, pageSize);
-    const signal = newMessageListSignal();
-    return api(`/messages/unified/inbox?page=${page}&pageSize=${pageSize}`, { signal });
+    return transport.call("getUnifiedInbox", { page, pageSize });
 }
 export function searchMessages(query, page = 1, pageSize = 50, scope = "all", accountId = "", folderId = 0) {
-    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}`);
+    return transport.call("searchMessages", { query, page, pageSize, scope, accountId, folderId });
 }
 export function getMessage(accountId, uid, allowRemote = false, 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}`);
+    return transport.call("getMessage", { accountId, uid, allowRemote, folderId });
 }
 export function updateFlags(accountId, uid, flags) {
-    if (hasIPC)
-        return mailxapi.updateFlags(accountId, uid, flags);
-    return api(`/message/${accountId}/${uid}/flags`, {
-        method: "PATCH",
-        body: JSON.stringify({ flags })
-    });
+    return transport.call("updateFlags", { accountId, uid, flags });
 }
 export function triggerSync() {
-    if (hasIPC)
-        return mailxapi.syncAll();
-    return api("/sync", { method: "POST" });
-}
-export function getVersion() {
-    if (hasIPC)
-        return mailxapi.getVersion();
-    return api("/version");
+    return transport.call("triggerSync");
 }
 export function getSyncPending() {
-    if (hasIPC)
-        return mailxapi.getSyncPending();
-    return api("/sync/pending");
+    return transport.call("getSyncPending");
 }
 export function searchContacts(query) {
-    if (hasIPC)
-        return mailxapi.searchContacts(query);
-    return api(`/contacts?q=${encodeURIComponent(query)}`);
+    return transport.call("searchContacts", { query });
 }
 export function allowRemoteContent(type, value) {
-    if (hasIPC)
-        return mailxapi.allowRemoteContent(type, value);
-    return api("/settings/allow-remote", {
-        method: "POST",
-        body: JSON.stringify({ type, value })
-    });
-}
-// ── Message actions ──
-// IMPORTANT: All server operations MUST go through these centralized methods
-// so IPC mode works. Never use fetch("/api/...") directly in components.
+    return transport.call("allowRemoteContent", { type, value });
+}
 export function deleteMessage(accountId, uid) {
-    if (hasIPC)
-        return mailxapi.deleteMessage(accountId, uid);
-    return api(`/message/${accountId}/${uid}`, { method: "DELETE" });
+    return transport.call("deleteMessage", { accountId, uid });
 }
 export function undeleteMessage(accountId, uid, folderId) {
-    if (hasIPC)
-        return mailxapi.undeleteMessage(accountId, uid, folderId);
-    return api(`/message/${accountId}/${uid}/undelete`, {
-        method: "POST",
-        body: JSON.stringify({ folderId })
-    });
+    return transport.call("undeleteMessage", { accountId, uid, folderId });
 }
 export function 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)
-    });
+    return transport.call("moveMessage", { accountId, uid, targetFolderId, targetAccountId });
 }
 export function restartServer() {
-    if (hasIPC)
-        return mailxapi.restart?.();
-    return api("/restart", { method: "POST" }).catch(() => { });
+    return transport.call("restartServer").catch(() => { });
 }
 export function rebuildServer() {
-    return api("/rebuild", { method: "POST" }).catch(() => { });
+    return transport.call("rebuildServer").catch(() => { });
 }
-// ── Folder management ──
 export function markFolderRead(accountId, folderId) {
-    if (hasIPC)
-        return mailxapi.markFolderRead?.(accountId, folderId);
-    return api(`/folder/${accountId}/${folderId}/mark-read`, { method: "POST" });
+    return transport.call("markFolderRead", { accountId, folderId });
 }
 export function createFolder(accountId, parentPath, name) {
-    if (hasIPC)
-        return mailxapi.createFolder?.(accountId, parentPath, name);
-    return api(`/folder/${accountId}`, {
-        method: "POST",
-        body: JSON.stringify({ parentPath, name })
-    });
+    return transport.call("createFolder", { accountId, parentPath, name });
 }
 export function renameFolder(accountId, folderId, newName) {
-    if (hasIPC)
-        return mailxapi.renameFolder?.(accountId, folderId, newName);
-    return api(`/folder/${accountId}/${folderId}/rename`, {
-        method: "POST",
-        body: JSON.stringify({ newName })
-    });
+    return transport.call("renameFolder", { accountId, folderId, newName });
 }
 export function deleteFolder(accountId, folderId) {
-    if (hasIPC)
-        return mailxapi.deleteFolder?.(accountId, folderId);
-    return api(`/folder/${accountId}/${folderId}`, { method: "DELETE" });
+    return transport.call("deleteFolder", { accountId, folderId });
 }
 export function emptyFolder(accountId, folderId) {
-    if (hasIPC)
-        return mailxapi.emptyFolder?.(accountId, folderId);
-    return api(`/folder/${accountId}/${folderId}/empty`, { method: "POST" });
+    return transport.call("emptyFolder", { accountId, folderId });
 }
-// ── Compose ──
 export function sendMessage(body) {
-    if (hasIPC)
-        return mailxapi.sendMessage?.(body);
-    return api("/send", { method: "POST", body: JSON.stringify(body) });
+    return transport.call("sendMessage", { body });
 }
 export function saveDraft(body) {
-    if (hasIPC)
-        return mailxapi.saveDraft?.(body);
-    return api("/draft", { method: "POST", body: JSON.stringify(body) });
+    return transport.call("saveDraft", { body });
 }
-const eventHandlers = [];
 export function onEvent(handler) {
-    eventHandlers.push(handler);
+    transport.onEvent(handler);
 }
 export function connectEvents() {
-    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);
-        };
-    }
+    transport.connect();
 }
 // Legacy exports for backward compatibility
 export const connectWebSocket = connectEvents;

package/client/styles/layout.css

@@ -56,6 +56,37 @@ body {
     background: var(--color-accent);
 }
 
+/* Responsive: mid-width (tablets, foldables) — hide folders, keep list + preview */
+@media (max-width: 1100px) and (min-width: 769px) {
+    body {
+        grid-template-columns: 1fr;
+        grid-template-rows: var(--toolbar-height) auto 1fr var(--statusbar-height);
+        grid-template-areas:
+            "toolbar"
+            "alert"
+            "main"
+            "status";
+    }
+
+    /* Folder panel: overlay slide-in from left (same as narrow) */
+    .folder-panel {
+        position: fixed;
+        left: -280px;
+        top: var(--toolbar-height);
+        bottom: var(--statusbar-height);
+        width: 280px;
+        z-index: 50;
+        transition: left 0.2s ease;
+        background: var(--color-bg);
+        border-right: 1px solid var(--color-border);
+        box-shadow: 2px 0 8px rgba(0,0,0,0.3);
+    }
+    .folder-panel.open { left: 0; }
+
+    /* Show hamburger */
+    #btn-menu { display: inline-flex !important; }
+}
+
 /* Responsive: narrow viewport — single panel navigation */
 @media (max-width: 768px) {
     body {

package/download/index.html

@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>mailx - Download</title>
+    <link rel="icon" type="image/svg+xml" href="../client/favicon.svg">
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: system-ui, sans-serif; background: #1e1e2e; color: #cdd6f4; min-height: 100vh; padding: 2rem; }
+        .container { max-width: 640px; margin: 0 auto; }
+        h1 { font-size: 1.8rem; margin-bottom: 0.5rem; }
+        h1 .version { font-size: 0.9rem; color: #89b4fa; font-weight: normal; }
+        .subtitle { color: #a6adc8; margin-bottom: 2rem; }
+        .section { background: #313244; border-radius: 12px; padding: 1.5rem; margin-bottom: 1.5rem; }
+        .section h2 { font-size: 1.1rem; margin-bottom: 1rem; color: #89b4fa; }
+        .dl-row { display: flex; align-items: center; justify-content: space-between; padding: 0.75rem 0; border-bottom: 1px solid #45475a; }
+        .dl-row:last-child { border-bottom: none; }
+        .dl-info { flex: 1; }
+        .dl-name { font-weight: 600; }
+        .dl-meta { font-size: 0.85rem; color: #a6adc8; }
+        .btn { display: inline-block; padding: 0.5rem 1.2rem; border-radius: 8px; text-decoration: none; font-weight: 600; font-size: 0.9rem; }
+        .btn-primary { background: #89b4fa; color: #1e1e2e; }
+        .btn-primary:hover { background: #b4d0fb; }
+        .btn-secondary { background: #45475a; color: #cdd6f4; }
+        .btn-secondary:hover { background: #585b70; }
+        .btn-disabled { background: #45475a; color: #6c7086; pointer-events: none; }
+        code { background: #45475a; padding: 2px 6px; border-radius: 4px; font-size: 0.9em; }
+        .install-cmd { display: block; background: #11111b; padding: 0.75rem 1rem; border-radius: 8px; margin: 0.5rem 0; font-family: monospace; font-size: 0.9rem; color: #a6e3a1; }
+        details { margin-top: 1.5rem; }
+        summary { cursor: pointer; color: #89b4fa; font-weight: 600; }
+        details ol { padding-left: 1.5rem; margin-top: 0.5rem; color: #a6adc8; }
+        details li { margin: 0.5rem 0; }
+        footer { text-align: center; margin-top: 2rem; font-size: 0.8rem; color: #6c7086; }
+        footer a { color: #89b4fa; text-decoration: none; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>mailx <span class="version" id="version"></span></h1>
+        <p class="subtitle">Local-first email client with IMAP sync. Replaces Thunderbird/Outlook.</p>
+
+        <div class="section">
+            <h2>Android</h2>
+            <div id="apk-list">
+                <div class="dl-row">
+                    <div class="dl-info">
+                        <span class="dl-name">Loading...</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="section">
+            <h2>Desktop (Windows / Linux / Mac)</h2>
+            <div class="dl-row">
+                <div class="dl-info">
+                    <span class="dl-name">Install via npm</span>
+                    <span class="dl-meta">Requires Node.js 22+</span>
+                </div>
+            </div>
+            <code class="install-cmd">npm install -g @bobfrankston/mailx && mailx</code>
+        </div>
+
+        <details>
+            <summary>Android installation help</summary>
+            <ol>
+                <li>Tap Download &rarr; tap the notification when done &rarr; Install</li>
+                <li>If blocked: Settings &rarr; Apps &rarr; Install unknown apps &rarr; allow your browser</li>
+                <li>The app needs a mailx server running on your network (desktop or server)</li>
+                <li>On first launch, enter your server address (e.g. <code>http://192.168.1.x:9333</code>)</li>
+            </ol>
+        </details>
+
+        <footer>
+            <a href="https://github.com/BobFrankston/mailx">GitHub</a> &middot;
+            <a href="https://www.npmjs.com/package/@bobfrankston/mailx">npm</a>
+        </footer>
+    </div>
+
+    <script>
+        async function load() {
+            try {
+                const resp = await fetch('versions.json', { cache: 'no-cache' });
+                if (!resp.ok) return;
+                const v = await resp.json();
+
+                document.getElementById('version').textContent = 'v' + v.version;
+
+                const list = document.getElementById('apk-list');
+                list.innerHTML = v.apks.map(apk => {
+                    const size = apk.sizeMB ? apk.sizeMB + ' MB' : '';
+                    const date = apk.built ? new Date(apk.built).toLocaleDateString() : '';
+                    return '<div class="dl-row">' +
+                        '<div class="dl-info">' +
+                            '<span class="dl-name">' + apk.name + '</span><br>' +
+                            '<span class="dl-meta">' + apk.description + ' &middot; ' + size + ' &middot; ' + date + '</span>' +
+                        '</div>' +
+                        '<a href="' + apk.file + '" class="btn btn-primary" id="dl-' + apk.name + '">Download APK</a>' +
+                    '</div>';
+                }).join('');
+
+                // Check file exists
+                v.apks.forEach(async apk => {
+                    try {
+                        const r = await fetch(apk.file, { method: 'HEAD' });
+                        if (!r.ok) {
+                            const dl = document.getElementById('dl-' + apk.name);
+                            if (dl) { dl.className = 'btn btn-disabled'; dl.removeAttribute('href'); dl.textContent = 'N/A'; }
+                        }
+                    } catch { }
+                });
+            } catch { }
+        }
+        load();
+    </script>
+</body>
+</html>

package/download/versions.json

@@ -0,0 +1,19 @@
+{
+  "version": "1.0.68",
+  "buildDate": "2026-04-02T21:39:00-04:00",
+  "apks": [
+    {
+      "name": "mailx",
+      "description": "mailx email client (connects to your mailx server)",
+      "file": "apks/mailx-debug.apk",
+      "sizeMB": 4.1,
+      "built": "2026-04-02T20:46:00-04:00",
+      "default": true
+    }
+  ],
+  "downloads": {
+    "npm": "npm install -g @bobfrankston/mailx",
+    "windows": "npm install -g @bobfrankston/mailx && mailx",
+    "linux": "npm install -g @bobfrankston/mailx && mailx -server"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.64",
+  "version": "1.0.69",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,16 +20,19 @@
     "postinstall": "node launcher/builder/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.30",
+    "@bobfrankston/iflow": "^1.0.32",
     "@bobfrankston/miscinfo": "^1.0.6",
-    "@bobfrankston/oauthsupport": "^1.0.14",
+    "@bobfrankston/oauthsupport": "^1.0.17",
     "@bobfrankston/rust-builder": "^0.1.2",
-    "mailparser": "^3.7.2",
-    "quill": "^2.0.3",
+    "@capacitor/android": "^8.3.0",
+    "@capacitor/cli": "^8.3.0",
+    "@capacitor/core": "^8.3.0",
     "express": "^4.21.0",
+    "jsonc-parser": "^3.3.1",
+    "mailparser": "^3.7.2",
     "nodemailer": "^7.0.0",
-    "ws": "^8.18.0",
-    "jsonc-parser": "^3.3.1"
+    "quill": "^2.0.3",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6"
@@ -55,11 +58,14 @@
     "@bobfrankston/miscinfo": "file:../../projects/npm/miscinfo",
     "@bobfrankston/oauthsupport": "file:../../projects/oauth/oauthsupport",
     "@bobfrankston/rust-builder": "file:../../utils/rust-builder",
-    "mailparser": "^3.7.2",
-    "quill": "^2.0.3",
+    "@capacitor/android": "^8.3.0",
+    "@capacitor/cli": "^8.3.0",
+    "@capacitor/core": "^8.3.0",
     "express": "^4.21.0",
+    "jsonc-parser": "^3.3.1",
+    "mailparser": "^3.7.2",
     "nodemailer": "^7.0.0",
-    "ws": "^8.18.0",
-    "jsonc-parser": "^3.3.1"
+    "quill": "^2.0.3",
+    "ws": "^8.18.0"
   }
 }