@bobfrankston/mailx 1.0.83 → 1.0.87

package/client/lib/local-service.js

@@ -6,6 +6,118 @@
  * This is the Android equivalent of the Express server + MailxService.
  */
 import * as store from "./local-store.js";
+// ── IMAP Parsing Helpers ──
+/** Extract a balanced parenthesized group starting at position */
+function extractParenGroup(s, start) {
+    if (s[start] !== "(")
+        return "";
+    let depth = 0;
+    for (let i = start; i < s.length; i++) {
+        if (s[i] === "(")
+            depth++;
+        else if (s[i] === ")") {
+            depth--;
+            if (depth === 0)
+                return s.substring(start, i + 1);
+        }
+    }
+    return s.substring(start);
+}
+/** Tokenize top-level items in a parenthesized IMAP list */
+function tokenizeEnvelope(s) {
+    const tokens = [];
+    const str = s.trim();
+    const start = str.startsWith("(") ? 1 : 0;
+    const end = str.endsWith(")") ? str.length - 1 : str.length;
+    let i = start;
+    while (i < end) {
+        while (i < end && str[i] === " ")
+            i++;
+        if (i >= end)
+            break;
+        if (str[i] === "(") {
+            let depth = 1, j = i + 1;
+            while (j < end && depth > 0) {
+                if (str[j] === "(")
+                    depth++;
+                else if (str[j] === ")")
+                    depth--;
+                j++;
+            }
+            tokens.push(str.substring(i, j));
+            i = j;
+        }
+        else if (str[i] === '"') {
+            let j = i + 1;
+            while (j < end) {
+                if (str[j] === "\\" && j + 1 < end) {
+                    j += 2;
+                    continue;
+                }
+                if (str[j] === '"') {
+                    j++;
+                    break;
+                }
+                j++;
+            }
+            tokens.push(str.substring(i, j));
+            i = j;
+        }
+        else if (str.substring(i, i + 3).toUpperCase() === "NIL") {
+            tokens.push("NIL");
+            i += 3;
+        }
+        else {
+            let j = i;
+            while (j < end && str[j] !== " " && str[j] !== ")" && str[j] !== "(")
+                j++;
+            tokens.push(str.substring(i, j));
+            i = j;
+        }
+    }
+    return tokens;
+}
+/** Remove quotes from an IMAP string */
+function unquoteImap(s) {
+    if (!s || s === "NIL")
+        return "";
+    if (s.startsWith('"') && s.endsWith('"'))
+        return s.slice(1, -1).replace(/\\(.)/g, "$1");
+    return s;
+}
+/** Parse IMAP address list: ((name NIL mailbox host)...) */
+function parseImapAddressList(token) {
+    if (!token || token === "NIL")
+        return [];
+    const addrs = [];
+    const re = /\(([^)]*)\)/g;
+    let m;
+    while ((m = re.exec(token)) !== null) {
+        const parts = tokenizeEnvelope(m[1]);
+        if (parts.length >= 4) {
+            const name = unquoteImap(parts[0]);
+            const mailbox = unquoteImap(parts[2]);
+            const host = unquoteImap(parts[3]);
+            addrs.push({ name, address: mailbox && host ? `${mailbox}@${host}` : mailbox || "" });
+        }
+    }
+    return addrs;
+}
+/** Decode =?charset?encoding?text?= encoded words */
+function decodeEncodedWords(s) {
+    if (!s)
+        return "";
+    return s.replace(/=\?([^?]+)\?([BQ])\?([^?]+)\?=/gi, (_match, _charset, encoding, text) => {
+        try {
+            if (encoding.toUpperCase() === "B")
+                return atob(text);
+            return text.replace(/=([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/_/g, " ");
+        }
+        catch {
+            return text;
+        }
+    });
+}
 let settings = null;
 const eventHandlers = [];
 function emit(event) {
@@ -132,32 +244,52 @@ class BridgeImapClient {
     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"))
+        // Join all response lines to handle multi-line FETCH responses
+        const fullResp = resp.join("\r\n");
+        // Split on "* N FETCH" boundaries
+        const fetchBlocks = fullResp.split(/(?=\* \d+ FETCH)/);
+        for (const block of fetchBlocks) {
+            if (!block.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+\(/);
+            const uid = block.match(/UID\s+(\d+)/)?.[1];
+            if (!uid)
+                continue;
+            const flags = block.match(/FLAGS\s+\(([^)]*)\)/)?.[1] || "";
+            const size = block.match(/RFC822\.SIZE\s+(\d+)/)?.[1] || "0";
+            const dateMatch = block.match(/INTERNALDATE\s+"([^"]+)"/);
+            // Parse ENVELOPE: (date subject from sender reply-to to cc bcc in-reply-to message-id)
             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,
-                });
+            let toAddrs = [];
+            let ccAddrs = [];
+            const envStart = block.indexOf("ENVELOPE (");
+            if (envStart >= 0) {
+                const envStr = extractParenGroup(block, envStart + 9);
+                const tokens = tokenizeEnvelope(envStr);
+                // tokens[0]=date, [1]=subject, [2]=from, [3]=sender, [4]=reply-to, [5]=to, [6]=cc, [7]=bcc, [8]=in-reply-to, [9]=message-id
+                if (tokens.length >= 10) {
+                    subject = unquoteImap(tokens[1]);
+                    messageId = unquoteImap(tokens[9]);
+                    const fromList = parseImapAddressList(tokens[2]);
+                    if (fromList.length > 0) {
+                        fromName = fromList[0].name;
+                        fromAddr = fromList[0].address;
+                    }
+                    toAddrs = parseImapAddressList(tokens[5]);
+                    ccAddrs = parseImapAddressList(tokens[6]);
+                }
             }
+            messages.push({
+                uid: parseInt(uid),
+                flags: flags.split(/\s+/).filter(Boolean),
+                size: parseInt(size),
+                date: dateMatch ? new Date(dateMatch[1]).getTime() : Date.now(),
+                subject: decodeEncodedWords(subject),
+                fromName: decodeEncodedWords(fromName),
+                fromAddr,
+                messageId,
+                to: toAddrs,
+                cc: ccAddrs,
+            });
         }
         return messages;
     }
@@ -335,8 +467,8 @@ async function syncFolder(client, accountId, folder) {
             subject: msg.subject || "(no subject)",
             fromName: msg.fromName || "",
             fromAddress: msg.fromAddr || "",
-            toJson: "[]",
-            ccJson: "[]",
+            toJson: JSON.stringify(msg.to || []),
+            ccJson: JSON.stringify(msg.cc || []),
             flags: msg.flags.join(","),
             size: msg.size,
             hasAttachments: false,
@@ -454,6 +586,16 @@ export async function initialize(initialSettings) {
             syncAccount(account).catch(e => console.error(`[local-service] ${e.message}`));
         }
     }
+    // Periodic re-sync every 30 seconds
+    setInterval(async () => {
+        if (!settings)
+            return;
+        for (const account of settings.accounts) {
+            if (account.enabled !== false) {
+                syncAccount(account).catch(e => console.error(`[local-service] periodic: ${e.message}`));
+            }
+        }
+    }, 30000);
 }
 export function getSettings() {
     return settings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.83",
+  "version": "1.0.87",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,7 +20,7 @@
     "postinstall": "node launcher/builder/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.38",
+    "@bobfrankston/iflow": "^1.0.39",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
     "@bobfrankston/rust-builder": "^0.1.3",

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

@@ -31,6 +31,8 @@ export declare class ImapManager extends EventEmitter {
     private inboxSyncing;
     /** Use native IMAP client instead of imapflow. Set to true to enable. */
     useNativeClient: boolean;
+    /** Accounts hitting connection limits — back off until this time */
+    private connectionBackoff;
     constructor(db: MailxDB);
     /** Get OAuth access token for an account (for SMTP auth) */
     getOAuthToken(accountId: string): Promise<string | null>;

package/packages/mailx-imap/index.js

@@ -71,6 +71,8 @@ export class ImapManager extends EventEmitter {
     inboxSyncing = false;
     /** Use native IMAP client instead of imapflow. Set to true to enable. */
     useNativeClient = false;
+    /** Accounts hitting connection limits — back off until this time */
+    connectionBackoff = new Map();
     constructor(db) {
         super();
         this.db = db;
@@ -169,6 +171,11 @@ export class ImapManager extends EventEmitter {
     createClient(accountId) {
         if (this.reauthenticating.has(accountId))
             throw new Error(`Account ${accountId} is re-authenticating`);
+        // Check connection backoff
+        const backoffUntil = this.connectionBackoff.get(accountId);
+        if (backoffUntil && Date.now() < backoffUntil) {
+            throw new Error(`Account ${accountId} in connection backoff (${Math.round((backoffUntil - Date.now()) / 1000)}s remaining)`);
+        }
         const config = this.configs.get(accountId);
         if (!config)
             throw new Error(`No config for account ${accountId}`);
@@ -457,15 +464,23 @@ export class ImapManager extends EventEmitter {
                 }
             }
             catch (e) {
-                this.emit("syncError", accountId, imapError(e));
-                console.error(`Sync error for ${accountId}: ${imapError(e)}`);
+                const errMsg = imapError(e);
+                this.emit("syncError", accountId, errMsg);
+                console.error(`Sync error for ${accountId}: ${errMsg}`);
+                // Connection limit — back off for 60 seconds
+                if (errMsg.includes("max_userip_connections") || errMsg.includes("Too many simultaneous")) {
+                    this.connectionBackoff.set(accountId, Date.now() + 60000);
+                    console.log(`  [backoff] ${accountId}: connection limit hit, backing off 60s`);
+                }
                 // Emit user-facing error once per account per session
                 if (!this.accountErrorShown.has(accountId)) {
                     this.accountErrorShown.add(accountId);
                     const config = this.configs.get(accountId);
                     const isOAuth = !!config?.tokenProvider;
-                    const hint = isOAuth ? "Authentication may have expired" : "Check server connectivity";
-                    this.emit("accountError", accountId, imapError(e), hint);
+                    const hint = errMsg.includes("max_userip_connections") || errMsg.includes("Too many")
+                        ? "Too many connections — backing off"
+                        : isOAuth ? "Authentication may have expired" : "Check server connectivity";
+                    this.emit("accountError", accountId, errMsg, hint);
                 }
             }
             finally {

package/packages/mailx-server/index.js

@@ -208,6 +208,17 @@ imapManager.on("accountError", (accountId, error, hint) => {
 });
 // ── Startup ──
 async function start() {
+    // Check if another instance is already running on this port
+    const net = await import("node:net");
+    const portInUse = await new Promise((resolve) => {
+        const s = net.createConnection({ port: PORT, host: "127.0.0.1" });
+        s.once("connect", () => { s.destroy(); resolve(true); });
+        s.once("error", () => resolve(false));
+    });
+    if (portInUse) {
+        console.log(`mailx server already running on port ${PORT} — exiting`);
+        process.exit(0);
+    }
     console.log("mailx server starting...");
     // Seed contacts (fast — skips existing)
     const seeded = db.seedContactsFromMessages();