@bobfrankston/mailx 1.0.147 → 1.0.151

package/packages/mailx-api/index.js

@@ -3,38 +3,7 @@
  * Thin Express Router — delegates all logic to mailx-service.
  */
 import { Router } from "express";
-import * as dns from "node:dns/promises";
 import { MailxService } from "@bobfrankston/mailx-service";
-import { loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadSettings } from "@bobfrankston/mailx-settings";
-/** Detect email provider via MX records (Google Workspace, Microsoft 365 custom domains).
- *  Cloud storage is always gdrive (only for Google-hosted domains).
- *  Microsoft domains get correct IMAP/SMTP but no cloud auto-config. */
-async function detectEmailProvider(domain) {
-    // Known domains — no MX lookup needed
-    const GOOGLE_DOMAINS = ["gmail.com", "googlemail.com"];
-    const MS_DOMAINS = ["outlook.com", "hotmail.com", "live.com"];
-    if (GOOGLE_DOMAINS.includes(domain))
-        return { cloud: "gdrive", imapHost: "imap.gmail.com", smtpHost: "smtp.gmail.com", auth: "oauth2" };
-    if (MS_DOMAINS.includes(domain))
-        return { imapHost: "outlook.office365.com", smtpHost: "smtp.office365.com", auth: "oauth2" };
-    // MX lookup for custom domains (Google Workspace, Microsoft 365)
-    try {
-        const records = await dns.resolveMx(domain);
-        for (const mx of records) {
-            const host = mx.exchange.toLowerCase();
-            if (host.endsWith(".google.com") || host.endsWith(".googlemail.com")) {
-                console.log(`  [setup] MX for ${domain} → Google (${host})`);
-                return { cloud: "gdrive", imapHost: "imap.gmail.com", smtpHost: "smtp.gmail.com", auth: "oauth2" };
-            }
-            if (host.endsWith(".outlook.com") || host.endsWith(".protection.outlook.com")) {
-                console.log(`  [setup] MX for ${domain} → Microsoft (${host})`);
-                return { imapHost: "outlook.office365.com", smtpHost: "smtp.office365.com", auth: "oauth2" };
-            }
-        }
-    }
-    catch { /* DNS lookup failed — not critical */ }
-    return null;
-}
 export function createApiRouter(db, imapManager) {
     const svc = new MailxService(db, imapManager);
     const router = Router();
@@ -140,72 +109,10 @@ export function createApiRouter(db, imapManager) {
     router.post("/setup", async (req, res) => {
         try {
             const { name, email, password } = req.body;
-            if (!email) {
-                res.status(400).json({ error: "Email address required" });
-                return;
-            }
-            // Detect provider via domain or MX records (Google Workspace, Microsoft 365 custom domains)
-            const domain = email.split("@")[1]?.toLowerCase() || "";
-            const detected = await detectEmailProvider(domain);
-            if (detected?.cloud) {
-                await initCloudConfig(detected.cloud);
-            }
-            // Check if cloud config found existing accounts (e.g., from GDrive mount or API)
-            let accounts = loadAccounts();
-            if (accounts.length === 0) {
-                accounts = await loadAccountsAsync();
-            }
-            if (accounts.length > 0) {
-                // Existing accounts found on cloud — use them, don't create new
-                console.log(`  Found ${accounts.length} existing account(s) from cloud settings`);
-                const settings = loadSettings();
-                for (const acct of settings.accounts) {
-                    if (!acct.enabled)
-                        continue;
-                    try {
-                        await imapManager.addAccount(acct);
-                        console.log(`  Account loaded: ${acct.label || acct.name} (${acct.id})`);
-                    }
-                    catch (e) {
-                        console.error(`  Account ${acct.id} error: ${e.message}`);
-                    }
-                }
-                imapManager.syncAll().catch(() => { });
-                res.json({ ok: true, message: `Loaded ${accounts.length} existing account(s) from cloud settings.` });
-                return;
-            }
-            // No existing accounts — build new account config
-            const account = { email, name: name || email.split("@")[0] };
-            if (password)
-                account.password = password;
-            // For custom domains hosted on Google/Microsoft, set correct IMAP/SMTP servers
-            if (detected && !["gmail.com", "googlemail.com", "outlook.com", "hotmail.com", "live.com"].includes(domain)) {
-                account.imap = { host: detected.imapHost, port: 993, tls: true, auth: detected.auth, user: email };
-                account.smtp = { host: detected.smtpHost, port: 587, tls: true, auth: detected.auth, user: email };
-            }
-            const id = domain.split(".")[0] || "account";
-            if (accounts.some((a) => a.email === email)) {
-                res.json({ ok: false, error: "Account already exists" });
-                return;
-            }
-            account.id = id;
-            accounts.push(account);
-            saveAccounts(accounts);
-            // Reload settings and register the new account in DB + IMAP so it works immediately
-            const settings = loadSettings();
-            const normalized = settings.accounts.find(a => a.id === id);
-            if (normalized) {
-                try {
-                    await imapManager.addAccount(normalized);
-                    console.log(`  Account added: ${normalized.name} (${normalized.id})`);
-                    // Start syncing in background
-                    imapManager.syncAll().catch(() => { });
-                }
-                catch (e) {
-                    console.error(`  Account setup IMAP error: ${e.message}`);
-                }
-            }
-            res.json({ ok: true, message: "Account added and syncing." });
+            const result = await svc.setupAccount(name, email, password);
+            if (!result.ok)
+                res.status(400);
+            res.json(result);
         }
         catch (e) {
             res.status(500).json({ error: e.message });
@@ -214,40 +121,8 @@ export function createApiRouter(db, imapManager) {
     // ── Repair: restore accounts from DB cache to settings, re-register IMAP ──
     router.post("/repair-accounts", async (req, res) => {
         try {
-            // Get accounts from DB (stale but present)
-            const dbAccounts = db.getAccountConfigs();
-            if (dbAccounts.length === 0) {
-                res.json({ ok: false, error: "No cached accounts in database" });
-                return;
-            }
-            // Rebuild account configs from DB's stored config_json
-            const restored = [];
-            for (const a of dbAccounts) {
-                try {
-                    const cfg = JSON.parse(a.configJson);
-                    restored.push(cfg);
-                }
-                catch { /* skip corrupt entries */ }
-            }
-            if (restored.length === 0) {
-                res.json({ ok: false, error: "Could not parse cached account configs" });
-                return;
-            }
-            // Save back to shared dir (and cloud API if active)
-            saveAccounts(restored);
-            // Re-register in IMAP manager
-            for (const acct of restored) {
-                try {
-                    await imapManager.addAccount(acct);
-                    console.log(`  [repair] Re-registered account: ${acct.name} (${acct.id})`);
-                }
-                catch (e) {
-                    console.error(`  [repair] Failed to register ${acct.id}: ${e.message}`);
-                }
-            }
-            // Start sync
-            imapManager.syncAll().catch(() => { });
-            res.json({ ok: true, message: `Restored ${restored.length} account(s) and started sync.` });
+            const result = await svc.repairAccounts();
+            res.json(result);
         }
         catch (e) {
             res.status(500).json({ error: e.message });

package/packages/mailx-imap/index.js

@@ -108,7 +108,7 @@ export class ImapManager extends EventEmitter {
     connectionBackoff = new Map();
     /** Per-account connection semaphore — limits concurrent IMAP connections */
     connectionSemaphore = new Map();
-    static MAX_CONNECTIONS = 2; // 1 for sync/fetch, 1 for IDLE
+    static MAX_CONNECTIONS = 5; // sync, fetch, IDLE, outbox, sync-actions
     constructor(db) {
         super();
         this.db = db;
@@ -1144,7 +1144,7 @@ export class ImapManager extends EventEmitter {
         if (actions.length === 0)
             return;
         const folders = this.db.getFolders(accountId);
-        const client = this.createClient(accountId);
+        const client = await this.createClientWithLimit(accountId);
         try {
             for (const action of actions) {
                 const folder = folders.find(f => f.id === action.folderId);
@@ -1727,6 +1727,7 @@ export class ImapManager extends EventEmitter {
         this.stopPeriodicSync();
         this.stopOutboxWorker();
         await this.stopWatching();
+        // Disconnect all persistent fetch clients
         for (const [, client] of this.fetchClients) {
             try {
                 await client.logout();
@@ -1734,6 +1735,19 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
         this.fetchClients.clear();
+        // Force-release all semaphore slots to unblock any waiting operations
+        for (const [accountId, sem] of this.connectionSemaphore) {
+            sem.active = 0;
+            for (const waiter of sem.waiting) {
+                try {
+                    waiter();
+                }
+                catch { /* */ }
+            }
+            sem.waiting.length = 0;
+        }
+        this.connectionSemaphore.clear();
+        this.activeConnections.clear();
     }
 }
 //# sourceMappingURL=index.js.map

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

@@ -61,6 +61,16 @@ export declare class MailxService {
         provider: string;
         mode: string;
     };
+    setupAccount(name: string, email: string, password?: string): Promise<{
+        ok: boolean;
+        error?: string;
+        message?: string;
+    }>;
+    repairAccounts(): Promise<{
+        ok: boolean;
+        error?: string;
+        message?: string;
+    }>;
     getAutocompleteSettings(): AutocompleteSettings;
     saveAutocompleteSettings(settings: AutocompleteSettings): void;
     autocomplete(req: AutocompleteRequest): Promise<AutocompleteResponse>;

package/packages/mailx-service/index.js

@@ -3,8 +3,32 @@
  * Pure business logic — no HTTP, no Express.
  * Both the Express API (mailx-api) and the Android bridge call these functions.
  */
-import { loadSettings, saveSettings, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorePath, getStorageInfo } from "@bobfrankston/mailx-settings";
+import * as dns from "node:dns/promises";
+import { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorePath, getStorageInfo } from "@bobfrankston/mailx-settings";
 import { simpleParser } from "mailparser";
+// ── Email provider detection (MX-based) ──
+const GOOGLE_DOMAINS = ["gmail.com", "googlemail.com"];
+const MS_DOMAINS = ["outlook.com", "hotmail.com", "live.com"];
+async function detectEmailProvider(domain) {
+    if (GOOGLE_DOMAINS.includes(domain))
+        return { cloud: "gdrive", imapHost: "imap.gmail.com", smtpHost: "smtp.gmail.com", auth: "oauth2" };
+    if (MS_DOMAINS.includes(domain))
+        return { imapHost: "outlook.office365.com", smtpHost: "smtp.office365.com", auth: "oauth2" };
+    try {
+        const records = await dns.resolveMx(domain);
+        for (const mx of records) {
+            const host = mx.exchange.toLowerCase();
+            if (host.endsWith(".google.com") || host.endsWith(".googlemail.com")) {
+                return { cloud: "gdrive", imapHost: "imap.gmail.com", smtpHost: "smtp.gmail.com", auth: "oauth2" };
+            }
+            if (host.endsWith(".outlook.com") || host.endsWith(".protection.outlook.com")) {
+                return { imapHost: "outlook.office365.com", smtpHost: "smtp.office365.com", auth: "oauth2" };
+            }
+        }
+    }
+    catch { /* DNS lookup failed */ }
+    return null;
+}
 // ── Sanitize ──
 export function sanitizeHtml(html) {
     let hasRemoteContent = false;
@@ -506,6 +530,82 @@ export class MailxService {
     getStorageInfo() {
         return getStorageInfo();
     }
+    // ── Setup & Repair ──
+    async setupAccount(name, email, password) {
+        if (!email)
+            return { ok: false, error: "Email address required" };
+        const domain = email.split("@")[1]?.toLowerCase() || "";
+        const detected = await detectEmailProvider(domain);
+        if (detected?.cloud) {
+            await initCloudConfig(detected.cloud);
+        }
+        // Try to load existing accounts from cloud (merge, don't overwrite)
+        let accounts = loadAccounts();
+        if (accounts.length === 0) {
+            accounts = await loadAccountsAsync();
+        }
+        // Build the new account entry
+        const account = { email, name: name || email.split("@")[0] };
+        if (password)
+            account.password = password;
+        if (detected && !["gmail.com", "googlemail.com", "outlook.com", "hotmail.com", "live.com"].includes(domain)) {
+            account.imap = { host: detected.imapHost, port: 993, tls: true, auth: detected.auth, user: email };
+            account.smtp = { host: detected.smtpHost, port: 587, tls: true, auth: detected.auth, user: email };
+        }
+        const id = domain.split(".")[0] || "account";
+        // Add new account if not already present
+        if (!accounts.some((a) => a.email?.toLowerCase() === email.toLowerCase())) {
+            account.id = id;
+            accounts.push(account);
+        }
+        if (accounts.length > 0) {
+            console.log(`  Saving ${accounts.length} account(s) (merged with existing cloud settings)`);
+        }
+        saveAccounts(accounts);
+        // Re-read normalized settings and register ALL accounts
+        const settings = loadSettings();
+        for (const acct of settings.accounts) {
+            if (!acct.enabled)
+                continue;
+            try {
+                await this.imapManager.addAccount(acct);
+                console.log(`  Account loaded: ${acct.label || acct.name} (${acct.id})`);
+            }
+            catch (e) {
+                console.error(`  Account ${acct.id} error: ${e.message}`);
+            }
+        }
+        this.imapManager.syncAll().catch(() => { });
+        return { ok: true, message: `${settings.accounts.length} account(s) configured and syncing.` };
+    }
+    async repairAccounts() {
+        const dbAccounts = this.db.getAccountConfigs();
+        if (dbAccounts.length === 0) {
+            return { ok: false, error: "No cached accounts in database" };
+        }
+        const restored = [];
+        for (const a of dbAccounts) {
+            try {
+                restored.push(JSON.parse(a.configJson));
+            }
+            catch { /* skip corrupt */ }
+        }
+        if (restored.length === 0) {
+            return { ok: false, error: "Could not parse cached account configs" };
+        }
+        saveAccounts(restored);
+        for (const acct of restored) {
+            try {
+                await this.imapManager.addAccount(acct);
+                console.log(`  [repair] Re-registered account: ${acct.name} (${acct.id})`);
+            }
+            catch (e) {
+                console.error(`  [repair] Failed to register ${acct.id}: ${e.message}`);
+            }
+        }
+        this.imapManager.syncAll().catch(() => { });
+        return { ok: true, message: `Restored ${restored.length} account(s) and started sync.` };
+    }
     // ── Autocomplete ──
     getAutocompleteSettings() {
         return loadAutocomplete();

package/packages/mailx-service/jsonrpc.js

@@ -4,6 +4,11 @@
  * Used by msger's bidirectional IPC (Phase 3) and can also
  * serve as a stdio JSON-RPC interface for testing.
  */
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootPkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"));
 /** Dispatch an incoming mailxapi call to the appropriate MailxService method */
 export async function dispatch(svc, req) {
     const { _action, _cbid, ...params } = req;
@@ -94,13 +99,29 @@ async function dispatchAction(svc, action, p) {
             svc.allowRemoteContent(p.type, p.value);
             return { ok: true };
         case "getVersion": {
-            const settings = svc.getSettings();
-            const storage = svc.getStorageInfo();
-            return { version: p._version || "dev", theme: settings.ui?.theme || "system", storage };
+            try {
+                const settings = svc.getSettings();
+                const storage = svc.getStorageInfo();
+                return { version: rootPkg.version || "dev", theme: settings.ui?.theme || "system", storage };
+            }
+            catch (e) {
+                console.error(`  [jsonrpc] getVersion error: ${e.message}`);
+                return { version: rootPkg.version || "dev", theme: "system", storage: {} };
+            }
         }
         // Autocomplete
         case "autocomplete":
             return svc.autocomplete(p);
+        case "getAutocompleteSettings":
+            return svc.getAutocompleteSettings();
+        case "saveAutocompleteSettings":
+            svc.saveAutocompleteSettings(p);
+            return { ok: true };
+        // Setup & Repair
+        case "setupAccount":
+            return svc.setupAccount(p.name, p.email, p.password);
+        case "repairAccounts":
+            return svc.repairAccounts();
         default:
             throw new Error(`Unknown action: ${action}`);
     }

package/packages/mailx-settings/index.js

@@ -51,28 +51,12 @@ function readLocalConfig() {
 }
 /** Resolve provider config to a filesystem path (checks for local Google Drive mount) */
 function resolveProvider(cfg) {
-    const home = process.env.USERPROFILE || process.env.HOME || "";
-    const rel = cfg.path; // e.g., "home/.mailx"
-    switch (cfg.provider) {
-        case "google":
-        case "gdrive": {
-            const candidates = [
-                home && path.join(home, "Google Drive", "My Drive", rel),
-                home && path.join(home, "Google Drive Streaming", "My Drive", rel),
-            ];
-            // Check drive letters on Windows
-            if (process.platform === "win32") {
-                for (const letter of ["G", "H", "I", "J", "K"]) {
-                    candidates.push(path.join(`${letter}:`, "My Drive", rel));
-                }
-            }
-            return candidates.filter(Boolean).find(p => fs.existsSync(p));
-        }
-        case "local":
-            return resolvePath(rel);
-        default:
-            return undefined;
-    }
+    // Cloud providers use API only — no filesystem mount scanning
+    if (cfg.provider === "gdrive" || cfg.provider === "google")
+        return undefined;
+    if (cfg.provider === "local")
+        return resolvePath(cfg.path);
+    return undefined;
 }
 /** Pending cloud config for API fallback (set when mount not found) */
 let pendingCloudConfig = null;
@@ -173,17 +157,25 @@ export function getStorageInfo() {
     if (config.sharedDir) {
         const entries = Array.isArray(config.sharedDir) ? config.sharedDir : [config.sharedDir];
         for (const entry of entries) {
-            const resolved = resolveSharedEntry(entry);
-            if (resolved && resolved !== LOCAL_DIR) {
-                if (typeof entry === "string") {
-                    // Legacy string path — filesystem only, no cloud label
+            if (typeof entry === "string") {
+                const resolved = resolveSharedEntry(entry);
+                if (resolved && resolved !== LOCAL_DIR) {
                     return { provider: "local", mode: "local", cloudPath: resolved };
                 }
-                const name = (entry.provider === "gdrive" || entry.provider === "google") ? "gdrive" : entry.provider;
+                continue;
+            }
+            // Provider-based entry — check for API mode (folderId) first, then mount
+            const name = (entry.provider === "gdrive" || entry.provider === "google") ? "gdrive" : entry.provider;
+            if (entry.folderId) {
+                // Has folder ID → API mode (don't scan filesystem for mounts)
+                return { provider: name, mode: "api", cloudPath: entry.path, cloudError: lastCloudError || undefined };
+            }
+            const resolved = resolveSharedEntry(entry);
+            if (resolved && resolved !== LOCAL_DIR) {
                 return { provider: name, mode: "mount", cloudPath: entry.path };
             }
         }
-        // Not mounted — using API
+        // Not mounted and no folderId — check pendingCloudConfig from initCloudConfig()
         if (pendingCloudConfig) {
             const name = (pendingCloudConfig.provider === "gdrive" || pendingCloudConfig.provider === "google") ? "gdrive" : pendingCloudConfig.provider;
             return { provider: name, mode: "api", cloudPath: pendingCloudConfig.path, cloudError: lastCloudError || undefined };
@@ -266,26 +258,37 @@ function saveFile(filename, data) {
 }
 const PROVIDERS = {
     "gmail.com": {
+        label: "Gmail",
         imap: { host: "imap.gmail.com", port: 993, tls: true, auth: "oauth2" },
         smtp: { host: "smtp.gmail.com", port: 587, tls: true, auth: "oauth2" },
     },
     "googlemail.com": {
+        label: "Gmail",
         imap: { host: "imap.gmail.com", port: 993, tls: true, auth: "oauth2" },
         smtp: { host: "smtp.gmail.com", port: 587, tls: true, auth: "oauth2" },
     },
     "outlook.com": {
+        label: "Outlook",
         imap: { host: "outlook.office365.com", port: 993, tls: true, auth: "oauth2" },
         smtp: { host: "smtp.office365.com", port: 587, tls: true, auth: "oauth2" },
     },
     "hotmail.com": {
+        label: "Hotmail",
         imap: { host: "outlook.office365.com", port: 993, tls: true, auth: "oauth2" },
         smtp: { host: "smtp.office365.com", port: 587, tls: true, auth: "oauth2" },
     },
     "yahoo.com": {
+        label: "Yahoo",
         imap: { host: "imap.mail.yahoo.com", port: 993, tls: true, auth: "password" },
         smtp: { host: "smtp.mail.yahoo.com", port: 587, tls: true, auth: "password" },
     },
+    "aol.com": {
+        label: "AOL",
+        imap: { host: "imap.aol.com", port: 993, tls: true, auth: "password" },
+        smtp: { host: "smtp.aol.com", port: 587, tls: true, auth: "password" },
+    },
     "icloud.com": {
+        label: "iCloud",
         imap: { host: "imap.mail.me.com", port: 993, tls: true, auth: "password" },
         smtp: { host: "smtp.mail.me.com", port: 587, tls: true, auth: "password" },
     },
@@ -299,7 +302,7 @@ function normalizeAccount(acct, globalName) {
     return {
         id: acct.id || domain.split(".")[0] || "account",
         name: acct.name || globalName || email.split("@")[0],
-        label: acct.label,
+        label: acct.label || provider?.label,
         email,
         imap: {
             host: acct.imap?.host || provider?.imap.host || `imap.${domain}`,