@bobfrankston/mailx 1.0.74 → 1.0.83

package/bin/mailx.js

@@ -31,7 +31,7 @@ const testMode = hasFlag("test");
 const rebuildMode = hasFlag("rebuild");
 
 // Validate arguments
-const knownFlags = ["server", "no-browser", "verbose", "external", "kill", "v", "version", "setup", "add", "test", "rebuild"];
+const knownFlags = ["server", "no-browser", "verbose", "external", "kill", "v", "version", "setup", "add", "test", "rebuild", "native-imap"];
 for (const arg of args) {
     const flag = arg.replace(/^--?/, "");
     if (arg.startsWith("-") && !knownFlags.includes(flag)) {

package/client/app.js

@@ -801,14 +801,99 @@ async function checkServer() {
     }
     catch {
         const startupStatus = document.getElementById("startup-status");
-        if (isApp) {
+        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 {
-            // Show server URL prompt
+            // Browser mode — prompt for server URL
             promptForServer();
         }
     }

package/client/lib/api-client.js

@@ -189,9 +189,40 @@ const httpRoutes = {
     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 || {});
+    }
+    onEvent(handler) {
+        this.handlers.push(handler);
+    }
+    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);
+        });
+    }
+}
 // ── Select transport ──
 const hasIPC = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-const transport = hasIPC ? new IpcTransport() : new HttpTransport();
+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) ──
 export function getAccounts() {
     return transport.call("getAccounts");

package/client/lib/local-service.js

@@ -0,0 +1,461 @@
+/**
+ * Local mail service — runs entirely in the WebView.
+ * Uses mailxapi.tcp bridge for IMAP, IndexedDB for storage.
+ * Implements the same MailxTransport interface so the client doesn't know the difference.
+ *
+ * This is the Android equivalent of the Express server + MailxService.
+ */
+import * as store from "./local-store.js";
+let settings = null;
+const eventHandlers = [];
+function emit(event) {
+    for (const h of eventHandlers) {
+        try {
+            h(event);
+        }
+        catch { /* ignore */ }
+    }
+}
+// ── IMAP via Bridge ──
+/** Minimal IMAP client that works through the mailxapi.tcp bridge */
+class BridgeImapClient {
+    streamId = null;
+    buffer = "";
+    dataResolve = null;
+    tagCounter = 0;
+    async connect(host, port, tls) {
+        this.streamId = await mailxapi.tcp.connect(host, port, tls);
+        mailxapi.tcp.onData(this.streamId, (data) => {
+            this.buffer += data;
+            if (this.dataResolve && this.buffer.includes("\r\n")) {
+                const resolve = this.dataResolve;
+                this.dataResolve = null;
+                resolve(this.buffer);
+            }
+        });
+        // Read greeting
+        return this.readLine();
+    }
+    nextTag() {
+        return `A${++this.tagCounter}`;
+    }
+    async readLine() {
+        // Check buffer first
+        const idx = this.buffer.indexOf("\r\n");
+        if (idx >= 0) {
+            const line = this.buffer.substring(0, idx);
+            this.buffer = this.buffer.substring(idx + 2);
+            return line;
+        }
+        // Wait for data
+        return new Promise(resolve => {
+            this.dataResolve = () => {
+                const idx = this.buffer.indexOf("\r\n");
+                if (idx >= 0) {
+                    const line = this.buffer.substring(0, idx);
+                    this.buffer = this.buffer.substring(idx + 2);
+                    resolve(line);
+                }
+            };
+        });
+    }
+    /** Read all responses until we get the tagged response */
+    async readUntilTag(tag) {
+        const lines = [];
+        const timeout = setTimeout(() => {
+            // Force resolve on timeout
+            if (this.dataResolve) {
+                this.dataResolve("");
+                this.dataResolve = null;
+            }
+        }, 30000);
+        while (true) {
+            const line = await this.readLine();
+            lines.push(line);
+            if (line.startsWith(tag + " ")) {
+                clearTimeout(timeout);
+                return lines;
+            }
+        }
+    }
+    async command(cmd) {
+        const tag = this.nextTag();
+        const full = `${tag} ${cmd}\r\n`;
+        if (this.streamId == null)
+            throw new Error("Not connected");
+        await mailxapi.tcp.write(this.streamId, full);
+        return this.readUntilTag(tag);
+    }
+    async login(user, pass) {
+        const resp = await this.command(`LOGIN "${user}" "${pass}"`);
+        return resp.some(l => l.includes(" OK "));
+    }
+    async xoauth2(user, token) {
+        const authStr = btoa(`user=${user}\x01auth=Bearer ${token}\x01\x01`);
+        const resp = await this.command(`AUTHENTICATE XOAUTH2 ${authStr}`);
+        return resp.some(l => l.includes(" OK "));
+    }
+    async list() {
+        const resp = await this.command('LIST "" "*"');
+        const folders = [];
+        for (const line of resp) {
+            const m = line.match(/^\* LIST \(([^)]*)\) "([^"]*)" (?:"([^"]+)"|(\S+))$/);
+            if (m) {
+                folders.push({
+                    flags: m[1] ? m[1].split(/\s+/).filter(Boolean) : [],
+                    delimiter: m[2] || ".",
+                    path: m[3] || m[4] || "",
+                });
+            }
+        }
+        return folders;
+    }
+    async select(mailbox) {
+        const resp = await this.command(`SELECT "${mailbox}"`);
+        let exists = 0;
+        for (const line of resp) {
+            const m = line.match(/^\* (\d+) EXISTS/);
+            if (m)
+                exists = parseInt(m[1]);
+        }
+        return { exists };
+    }
+    async status(mailbox) {
+        const resp = await this.command(`STATUS "${mailbox}" (MESSAGES)`);
+        for (const line of resp) {
+            const m = line.match(/MESSAGES\s+(\d+)/);
+            if (m)
+                return { messages: parseInt(m[1]) };
+        }
+        return { messages: 0 };
+    }
+    async fetchHeaders(range) {
+        const resp = await this.command(`UID FETCH ${range} (UID FLAGS ENVELOPE RFC822.SIZE INTERNALDATE)`);
+        const messages = [];
+        for (const line of resp) {
+            if (!line.startsWith("* ") || !line.includes("FETCH"))
+                continue;
+            const uid = line.match(/UID\s+(\d+)/)?.[1];
+            const flags = line.match(/FLAGS\s+\(([^)]*)\)/)?.[1] || "";
+            const size = line.match(/RFC822\.SIZE\s+(\d+)/)?.[1] || "0";
+            const dateMatch = line.match(/INTERNALDATE\s+"([^"]+)"/);
+            // Simplified envelope parsing — extract subject from the ENVELOPE
+            const envMatch = line.match(/ENVELOPE\s+\(/);
+            let subject = "", fromName = "", fromAddr = "", messageId = "";
+            if (envMatch) {
+                // Very simplified — real parsing would need the full tokenizer
+                const subMatch = line.match(/ENVELOPE\s+\("[^"]*"\s+"([^"]*)"/);
+                if (subMatch)
+                    subject = subMatch[1];
+            }
+            if (uid) {
+                messages.push({
+                    uid: parseInt(uid),
+                    flags: flags.split(/\s+/).filter(Boolean),
+                    size: parseInt(size),
+                    date: dateMatch ? new Date(dateMatch[1]).getTime() : Date.now(),
+                    subject,
+                    fromName, fromAddr, messageId,
+                });
+            }
+        }
+        return messages;
+    }
+    async fetchBody(uid) {
+        const tag = this.nextTag();
+        const cmd = `${tag} UID FETCH ${uid} (BODY.PEEK[])\r\n`;
+        if (this.streamId == null)
+            throw new Error("Not connected");
+        await mailxapi.tcp.write(this.streamId, cmd);
+        // Read response including literal data
+        let allData = "";
+        const deadline = Date.now() + 30000;
+        while (Date.now() < deadline) {
+            const chunk = await this.readLine();
+            allData += chunk + "\r\n";
+            if (chunk.startsWith(tag + " "))
+                break;
+        }
+        return allData;
+    }
+    async logout() {
+        try {
+            await this.command("LOGOUT");
+        }
+        catch { /* ignore */ }
+        if (this.streamId != null) {
+            mailxapi.tcp.close(this.streamId);
+            this.streamId = null;
+        }
+    }
+    async close() {
+        try {
+            await this.command("CLOSE");
+        }
+        catch { /* ignore */ }
+    }
+    async storeFlags(uid, action, flags) {
+        await this.command(`UID STORE ${uid} ${action} (${flags.join(" ")})`);
+    }
+    async copy(uid, dest) {
+        await this.command(`UID COPY ${uid} "${dest}"`);
+    }
+    async expunge() {
+        await this.command("EXPUNGE");
+    }
+    async search(criteria) {
+        const resp = await this.command(`UID SEARCH ${criteria}`);
+        for (const line of resp) {
+            if (line.startsWith("* SEARCH")) {
+                return line.substring(9).trim().split(/\s+/).map(Number).filter(n => !isNaN(n));
+            }
+        }
+        return [];
+    }
+}
+// ── Service Methods ──
+async function loadSettingsFromStorage() {
+    // Try IndexedDB meta first
+    const saved = await store.getMeta("settings");
+    if (saved)
+        return saved;
+    // Default empty
+    return { accounts: [] };
+}
+async function saveSettingsToStorage(s) {
+    settings = s;
+    await store.setMeta("settings", s);
+}
+async function syncAccount(account) {
+    const client = new BridgeImapClient();
+    try {
+        const greeting = await client.connect(account.imap.host, account.imap.port || 993, (account.imap.port || 993) === 993);
+        console.log(`[local-service] Connected to ${account.imap.host}: ${greeting}`);
+        // Authenticate
+        let authOk;
+        if (account.imap.auth === "oauth2") {
+            // TODO: OAuth token via bridge — for now skip
+            console.log("[local-service] OAuth not yet supported in bridge mode");
+            await client.logout();
+            return;
+        }
+        else {
+            authOk = await client.login(account.imap.user, account.imap.password || "");
+        }
+        if (!authOk) {
+            console.error("[local-service] Auth failed");
+            await client.logout();
+            return;
+        }
+        emit({ type: "syncProgress", accountId: account.id, phase: "folders", progress: 0 });
+        // Get folder list
+        const folders = await client.list();
+        let nextFolderId = (await store.getMeta("nextFolderId")) || 1;
+        for (const f of folders) {
+            const existing = (await store.getFolders(account.id)).find(ef => ef.path === f.path);
+            if (!existing) {
+                const flags = f.flags.map(fl => fl.toLowerCase());
+                let specialUse = "";
+                if (flags.includes("\\inbox") || f.path.toLowerCase() === "inbox")
+                    specialUse = "inbox";
+                else if (flags.includes("\\sent"))
+                    specialUse = "sent";
+                else if (flags.includes("\\trash"))
+                    specialUse = "trash";
+                else if (flags.includes("\\drafts"))
+                    specialUse = "drafts";
+                else if (flags.includes("\\junk"))
+                    specialUse = "junk";
+                else if (flags.includes("\\archive"))
+                    specialUse = "archive";
+                await store.upsertFolder({
+                    id: nextFolderId++,
+                    accountId: account.id,
+                    path: f.path,
+                    delimiter: f.delimiter,
+                    specialUse,
+                    totalCount: 0,
+                    unreadCount: 0,
+                });
+            }
+        }
+        await store.setMeta("nextFolderId", nextFolderId);
+        emit({ type: "syncProgress", accountId: account.id, phase: "folders", progress: 100 });
+        // Sync inbox
+        const allFolders = await store.getFolders(account.id);
+        const inbox = allFolders.find(f => f.specialUse === "inbox");
+        if (inbox) {
+            await syncFolder(client, account.id, inbox);
+        }
+        // Emit folder counts
+        const updatedFolders = await store.getFolders(account.id);
+        const counts = {};
+        for (const f of updatedFolders) {
+            counts[f.id] = { total: f.totalCount, unread: f.unreadCount };
+        }
+        emit({ type: "folderCountsChanged", accountId: account.id, counts });
+        await client.logout();
+    }
+    catch (e) {
+        console.error(`[local-service] Sync error: ${e.message}`);
+        emit({ type: "error", message: `${account.id}: ${e.message}` });
+    }
+}
+async function syncFolder(client, accountId, folder) {
+    emit({ type: "syncProgress", accountId, phase: `sync:${folder.path}`, progress: 0 });
+    const { exists } = await client.select(folder.path);
+    const highestUid = await store.getHighestUid(accountId, folder.id);
+    let msgs;
+    if (highestUid > 0) {
+        msgs = await client.fetchHeaders(`${highestUid + 1}:*`);
+        msgs = msgs.filter(m => m.uid > highestUid);
+    }
+    else {
+        // First sync — get recent messages
+        const uids = await client.search("ALL");
+        // Take last 200 UIDs (most recent)
+        const recent = uids.slice(-200);
+        if (recent.length > 0) {
+            msgs = await client.fetchHeaders(recent.join(","));
+        }
+        else {
+            msgs = [];
+        }
+    }
+    // Store messages
+    let newCount = 0;
+    for (const msg of msgs) {
+        await store.upsertMessage({
+            key: `${accountId}:${folder.id}:${msg.uid}`,
+            accountId,
+            folderId: folder.id,
+            uid: msg.uid,
+            messageId: msg.messageId || "",
+            date: msg.date,
+            subject: msg.subject || "(no subject)",
+            fromName: msg.fromName || "",
+            fromAddress: msg.fromAddr || "",
+            toJson: "[]",
+            ccJson: "[]",
+            flags: msg.flags.join(","),
+            size: msg.size,
+            hasAttachments: false,
+            preview: "",
+            bodyPath: "",
+        });
+        newCount++;
+    }
+    // Update folder counts
+    const allMsgs = await store.getMessages(accountId, folder.id, 1, 999999);
+    const total = allMsgs.total;
+    const unread = allMsgs.items.filter((m) => !m.flags.includes("\\Seen")).length;
+    await store.updateFolderCounts(folder.id, total, unread);
+    emit({ type: "syncProgress", accountId, phase: `sync:${folder.path}`, progress: 100 });
+    if (newCount > 0) {
+        console.log(`[local-service] ${folder.path}: ${newCount} new messages`);
+        emit({ type: "folderCountsChanged", accountId, counts: { [folder.id]: { total, unread } } });
+    }
+    await client.close();
+}
+export async function handleCall(method, params = {}) {
+    switch (method) {
+        case "getAccounts": {
+            const accounts = await store.getAccounts();
+            if (!settings)
+                settings = await loadSettingsFromStorage();
+            return accounts.map(a => {
+                const cfg = settings.accounts.find(s => s.id === a.id);
+                return { ...a, label: cfg?.label, defaultSend: cfg?.defaultSend || false };
+            });
+        }
+        case "getFolders":
+            return store.getFolders(params.accountId);
+        case "getMessages":
+            return store.getMessages(params.accountId, params.folderId, params.page, params.pageSize);
+        case "getUnifiedInbox":
+            return store.getUnifiedInbox(params.page, params.pageSize);
+        case "getMessage": {
+            const env = await store.getMessageByUid(params.accountId, params.uid, params.folderId);
+            if (!env)
+                return { error: "not found" };
+            // Try to get body from IndexedDB
+            const body = await store.getBody(env.accountId, env.folderId, env.uid);
+            return { ...env, bodyHtml: "", bodyText: body || "[Body not yet downloaded]", hasRemoteContent: false, remoteAllowed: false, attachments: [], emlPath: "", deliveredTo: "", returnPath: "", listUnsubscribe: "" };
+        }
+        case "searchContacts":
+            return store.searchContacts(params.query || "");
+        case "getSyncPending":
+            return { pending: 0 };
+        case "triggerSync": {
+            if (!settings)
+                settings = await loadSettingsFromStorage();
+            for (const account of settings.accounts) {
+                if (account.enabled !== false) {
+                    syncAccount(account).catch(e => console.error(`[local-service] ${e.message}`));
+                }
+            }
+            return { ok: true };
+        }
+        case "updateFlags":
+            // TODO: queue IMAP flag update
+            return { ok: true };
+        case "deleteMessage":
+            await store.deleteMessage(params.accountId, params.uid);
+            return { ok: true };
+        case "moveMessage":
+            // TODO: queue IMAP move
+            return { ok: true };
+        case "undeleteMessage":
+            return { ok: true };
+        case "searchMessages":
+            // Simple local search
+            return { items: [], total: 0, page: 1, pageSize: 50 };
+        case "allowRemoteContent":
+            return { ok: true };
+        case "markFolderRead":
+            return { ok: true };
+        case "restartServer":
+        case "rebuildServer":
+            return { ok: true };
+        case "createFolder":
+        case "renameFolder":
+        case "deleteFolder":
+        case "emptyFolder":
+            return { ok: true };
+        case "sendMessage":
+        case "saveDraft":
+            return { ok: true };
+        default:
+            console.warn(`[local-service] Unknown method: ${method}`);
+            return { error: `Unknown: ${method}` };
+    }
+}
+export function onEvent(handler) {
+    eventHandlers.push(handler);
+}
+/** Initialize the local service — load settings, start sync */
+export async function initialize(initialSettings) {
+    await store.init();
+    if (initialSettings) {
+        await saveSettingsToStorage(initialSettings);
+        settings = initialSettings;
+    }
+    else {
+        settings = await loadSettingsFromStorage();
+    }
+    // Register accounts in IndexedDB
+    for (const account of settings.accounts) {
+        await store.upsertAccount(account.id, account.name, account.email, JSON.stringify(account));
+    }
+    emit({ type: "connected" });
+    // Start initial sync
+    for (const account of settings.accounts) {
+        if (account.enabled !== false) {
+            syncAccount(account).catch(e => console.error(`[local-service] ${e.message}`));
+        }
+    }
+}
+export function getSettings() {
+    return settings;
+}
+//# sourceMappingURL=local-service.js.map