@bobfrankston/mailx 1.0.151 → 1.0.153

package/bin/mailx.js

@@ -72,9 +72,9 @@ if (hasFlag("kill")) {
             }
         }
         catch { /* no process on port */ }
-        // Kill any node.exe running mailx-server (uses tasklist + powershell instead of wmic)
+        // Kill any node.exe running mailx (server or IPC service)
         try {
-            const ps = execSync(`powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"name='node.exe'\\" | Where-Object { $_.CommandLine -match 'mailx-server|mailx\\\\packages' } | Select-Object -ExpandProperty ProcessId"`, { encoding: "utf-8" }).trim();
+            const ps = execSync(`powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"name='node.exe'\\" | Where-Object { $_.CommandLine -match 'mailx-server|mailx\\\\packages|mailx\\\\bin' } | Select-Object -ExpandProperty ProcessId"`, { encoding: "utf-8" }).trim();
             for (const pid of ps.split("\n").map(s => s.trim()).filter(s => /^\d+$/.test(s))) {
                 try {
                     execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" });
@@ -368,27 +368,20 @@ async function runSetup() {
     console.log("\nmailx — first-time setup\n");
     const home = process.env.USERPROFILE || process.env.HOME || "";
     const mailxDir = path.join(home, ".mailx");
-    console.log("Gmail is recommended as the first account (provides contacts, calendar, and cloud settings sync).\n");
-    const account = await promptForAccount();
-    if (!account) {
-        console.log(`\nNo account added. Open http://127.0.0.1:${PORT} in a browser to set up via the UI.`);
+    // Ask for email first — if it's Gmail, check Drive for existing accounts before prompting further
+    console.log("Enter your email address to get started (Gmail recommended for cloud sync).\n");
+    const email = await prompt("Email address: ");
+    if (!email || !email.includes("@")) {
+        console.log(`\nNo account added. The UI will show a setup form.`);
         fs.mkdirSync(mailxDir, { recursive: true });
         return false;
     }
-    const name = await prompt(`Your name (for From: header) [${account.email.split("@")[0]}]: `) || account.email.split("@")[0];
-    const settings = {
-        name,
-        accounts: [account],
-        ui: { theme: "system" },
-        sync: { intervalMinutes: 5, historyDays: 0 },
-    };
-    const domain = account.email.split("@")[1]?.toLowerCase() || "";
-    // Detect if this is a Google-hosted domain (for GDrive cloud storage)
+    const domain = email.split("@")[1]?.toLowerCase() || "";
     let isGoogle = ["gmail.com", "googlemail.com"].includes(domain);
     if (!isGoogle) {
         try {
-            const dns = await import("node:dns/promises");
-            const records = await dns.resolveMx(domain);
+            const dnsmod = await import("node:dns/promises");
+            const records = await dnsmod.resolveMx(domain);
             isGoogle = records.some(mx => {
                 const host = mx.exchange.toLowerCase();
                 return host.endsWith(".google.com") || host.endsWith(".googlemail.com");
@@ -398,67 +391,86 @@ async function runSetup() {
         }
         catch { /* DNS lookup failed */ }
     }
-    fs.mkdirSync(mailxDir, { recursive: true });
+    // For Google-hosted accounts, check Drive for existing settings first
     if (isGoogle) {
-        // Save to Google Drive via API — merge with existing settings if present
-        console.log("\nSaving settings to Google Drive via API...");
+        fs.mkdirSync(mailxDir, { recursive: true });
+        console.log("\nChecking Google Drive for existing mailx settings...");
         try {
             const { gDriveFindOrCreateFolder, getCloudProvider } = await import("@bobfrankston/mailx-settings/cloud.js");
             const folderId = await gDriveFindOrCreateFolder();
             if (folderId) {
+                console.log(`  Drive folder: My Drive/mailx/ (${folderId})`);
                 const gdrive = getCloudProvider("gdrive", folderId);
                 if (gdrive) {
-                    // Read existing accounts from Drive to merge (don't overwrite other accounts)
-                    let accountsList = [account];
-                    // Check accounts.jsonc first, then legacy settings.jsonc
-                    const existingAccts = await gdrive.read("accounts.jsonc");
-                    const existingSettings = existingAccts ? null : await gdrive.read("settings.jsonc");
-                    const existingContent = existingAccts || existingSettings;
-                    if (existingContent) {
-                        try {
-                            const { parse: parseJsonc } = await import("jsonc-parser");
-                            const prev = parseJsonc(existingContent);
-                            const prevAccounts = prev?.accounts || (Array.isArray(prev) ? prev : []);
-                            if (prevAccounts.length > 0) {
-                                accountsList = [...prevAccounts];
-                                const newEmail = account.email.toLowerCase();
-                                if (!accountsList.some((a) => a.email?.toLowerCase() === newEmail)) {
-                                    accountsList.push(account);
-                                }
-                                console.log(`  Found ${prevAccounts.length} existing account(s) on Drive — merging`);
-                            }
+                    // Read accounts.jsonc (canonical) — ignore legacy settings.jsonc
+                    const existing = await gdrive.read("accounts.jsonc");
+                    if (existing) {
+                        const { parse: parseJsonc } = await import("jsonc-parser");
+                        const data = parseJsonc(existing);
+                        const accts = data?.accounts || (Array.isArray(data) ? data : []);
+                        if (accts.length > 0) {
+                            console.log(`\nFound ${accts.length} existing account(s) on Google Drive (My Drive/mailx/accounts.jsonc):`);
+                            for (const a of accts)
+                                console.log(`  • ${a.label || a.name || a.email}`);
+                            // Save config pointing to Drive — no prompts needed
+                            const config = { sharedDir: { provider: "gdrive", path: "mailx", folderId } };
+                            fs.writeFileSync(path.join(mailxDir, "config.jsonc"), JSON.stringify(config, null, 2));
+                            console.log("Local config created. Starting mailx...\n");
+                            return true;
                         }
-                        catch { /* parse failed, overwrite */ }
                     }
-                    const accountsData = { name, accounts: accountsList };
-                    const content = JSON.stringify(accountsData, null, 2);
-                    const ok = await gdrive.write("accounts.jsonc", content);
+                }
+                // No existing accounts — save Drive config for later
+                const config = { sharedDir: { provider: "gdrive", path: "mailx", folderId } };
+                fs.writeFileSync(path.join(mailxDir, "config.jsonc"), JSON.stringify(config, null, 2));
+            }
+        }
+        catch (e) {
+            console.log(`  Drive check failed: ${e.message} — continuing with manual setup`);
+        }
+    }
+    // No existing accounts found — build a new account
+    const account = { email };
+    const isOAuth = ["gmail.com", "googlemail.com", "outlook.com", "hotmail.com", "live.com"].includes(domain);
+    if (!isOAuth) {
+        account.password = await prompt("Password (app password for Yahoo/AOL/iCloud): ");
+    }
+    const name = await prompt(`Your name (for From: header) [${email.split("@")[0]}]: `) || email.split("@")[0];
+    fs.mkdirSync(mailxDir, { recursive: true });
+    if (isGoogle) {
+        // Save to Google Drive via API
+        console.log("\nSaving account to Google Drive...");
+        try {
+            const { gDriveFindOrCreateFolder, getCloudProvider } = await import("@bobfrankston/mailx-settings/cloud.js");
+            const folderId = await gDriveFindOrCreateFolder();
+            if (folderId) {
+                const gdrive = getCloudProvider("gdrive", folderId);
+                if (gdrive) {
+                    const accountsData = { name, accounts: [account] };
+                    const ok = await gdrive.write("accounts.jsonc", JSON.stringify(accountsData, null, 2));
                     if (ok) {
-                        console.log("Settings saved to Google Drive (mailx folder)");
-                        const config = { sharedDir: { provider: "gdrive", path: "mailx", folderId } };
-                        fs.writeFileSync(path.join(mailxDir, "config.jsonc"), JSON.stringify(config, null, 2));
-                        console.log("Local config created with Drive folder ID.");
+                        console.log("Account saved to Google Drive.");
+                        // config.jsonc may already exist from the Drive check above
+                        if (!fs.existsSync(path.join(mailxDir, "config.jsonc"))) {
+                            const config = { sharedDir: { provider: "gdrive", path: "mailx", folderId } };
+                            fs.writeFileSync(path.join(mailxDir, "config.jsonc"), JSON.stringify(config, null, 2));
+                        }
                     }
                     else {
-                        console.log("Google Drive write failed — saving locally instead.");
-                        fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
+                        console.log("Drive write failed — saving locally.");
+                        fs.writeFileSync(path.join(mailxDir, "accounts.jsonc"), JSON.stringify({ name, accounts: [account] }, null, 2));
                     }
                 }
             }
-            else {
-                console.log("Google Drive folder setup failed — saving locally.");
-                fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
-            }
         }
         catch (e) {
-            console.log(`Google Drive error: ${e.message} — saving locally.`);
-            fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
+            console.log(`Drive error: ${e.message} — saving locally.`);
+            fs.writeFileSync(path.join(mailxDir, "accounts.jsonc"), JSON.stringify({ name, accounts: [account] }, null, 2));
         }
     }
     else {
-        // Non-Google account — save locally
-        console.log(`\nSaving settings to ${mailxDir}...`);
-        fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
+        // Non-Google — save locally
+        fs.writeFileSync(path.join(mailxDir, "accounts.jsonc"), JSON.stringify({ name, accounts: [account] }, null, 2));
     }
     console.log("Setup complete. Starting mailx...\n");
     return true;

package/client/app.js

@@ -898,11 +898,19 @@ optAutocomplete?.addEventListener("change", () => {
     }).catch(() => { });
 });
 const isApp = typeof mailxapi !== "undefined" && mailxapi?.isApp;
-// Set baseline version text immediately (async getVersion updates it with storage info)
-const versionEl = document.getElementById("app-version");
-if (versionEl)
-    versionEl.textContent = "mailx";
-const versionPromise = getVersion();
+// Retry getVersion — IPC may not be ready on first call
+async function getVersionWithRetry() {
+    for (let i = 0; i < 5; i++) {
+        try {
+            return await getVersion();
+        }
+        catch {
+            await new Promise(r => setTimeout(r, 1000));
+        }
+    }
+    return { version: "?", storage: {} };
+}
+const versionPromise = getVersionWithRetry();
 versionPromise.then((d) => {
     const el = document.getElementById("app-version");
     const storage = d.storage || {};
@@ -911,10 +919,10 @@ versionPromise.then((d) => {
         : "";
     if (el) {
         el.textContent = `mailx v${d.version}${storageLabel}${isApp ? "" : " [browser]"}`;
-        // Tooltip: show cloud path and access mode on hover
+        // Tooltip: show Drive path on hover
         if (storage.provider && storage.provider !== "local") {
-            const modeDesc = storage.mode === "api" ? "API" : "mount";
-            el.title = `${storage.cloudPath || storage.provider} (${modeDesc})`;
+            const drivePath = storage.cloudPath ? `My Drive/${storage.cloudPath}/` : storage.provider;
+            el.title = drivePath;
         }
     }
     if (d.settingsError) {

package/client/components/folder-tree.js

@@ -330,7 +330,14 @@ async function loadFolderTree(container) {
         container.innerHTML = `<div class="folder-loading">Loading accounts...</div>`;
     }
     try {
-        const accounts = await getAccounts();
+        let accounts = await getAccounts();
+        // Accounts may still be registering (OAuth in progress) — retry a few times
+        if (accounts.length === 0) {
+            for (let retry = 0; retry < 5 && accounts.length === 0; retry++) {
+                await new Promise(r => setTimeout(r, 2000));
+                accounts = await getAccounts();
+            }
+        }
         if (accounts.length === 0) {
             container.innerHTML = `<div class="folder-loading">No accounts</div>`;
             // Hide the message list and show setup in the viewer pane (full width)
@@ -396,28 +403,43 @@ async function loadFolderTree(container) {
                         helpEl.textContent = help || "";
                     }
                 });
-                form?.addEventListener("submit", async (e) => {
-                    e.preventDefault();
-                    const name = document.getElementById("setup-name").value.trim();
+                // When a valid email is entered, try setup immediately — if cloud has
+                // existing accounts, loads them without needing name/password
+                let setupTriggered = false;
+                async function trySetup() {
                     const email = emailInput.value.trim();
-                    const password = document.getElementById("setup-password").value;
-                    if (!email)
+                    if (!email || !email.includes("@") || setupTriggered)
                         return;
-                    statusEl.textContent = "Setting up account...";
+                    const name = document.getElementById("setup-name").value.trim();
+                    const password = document.getElementById("setup-password").value;
+                    setupTriggered = true;
+                    statusEl.textContent = "Checking for existing accounts...";
                     try {
                         const data = await setupAccount(name, email, password);
                         if (data.ok) {
-                            statusEl.textContent = "Account added! Syncing...";
-                            // Wait for sync to populate folders before reloading
+                            statusEl.textContent = data.message || "Accounts loaded! Syncing...";
                             setTimeout(() => location.reload(), 5000);
                         }
                         else {
+                            setupTriggered = false;
                             statusEl.textContent = `Error: ${data.error || "Setup failed"}`;
                         }
                     }
                     catch (err) {
+                        setupTriggered = false;
                         statusEl.textContent = `Error: ${err.message}`;
                     }
+                }
+                form?.addEventListener("submit", async (e) => {
+                    e.preventDefault();
+                    await trySetup();
+                });
+                // Auto-trigger for OAuth providers when email looks complete
+                emailInput?.addEventListener("change", async () => {
+                    const domain = emailInput.value.split("@")[1]?.toLowerCase() || "";
+                    const isOAuth = ["gmail.com", "googlemail.com", "outlook.com", "hotmail.com", "live.com"].includes(domain);
+                    if (isOAuth)
+                        await trySetup();
                 });
                 // Show cloud storage status in setup form
                 getVersion().then((d) => {

package/client/index.html

@@ -39,7 +39,7 @@
                     <label class="tb-menu-item"><input type="checkbox" id="opt-autocomplete"> AI autocomplete</label>
                 </div>
             </div>
-            <span id="app-version" class="app-version"></span>
+            <span id="app-version" class="app-version">mailx</span>
         </div>
         <div class="toolbar-right">
             <button class="tb-btn" id="btn-sync" title="Sync all folders (F5)">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.151",
+  "version": "1.0.153",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -23,7 +23,7 @@
     "@bobfrankston/iflow": "^1.0.53",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
-    "@bobfrankston/msger": "^0.1.201",
+    "@bobfrankston/msger": "^0.1.203",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",

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 = 5; // sync, fetch, IDLE, outbox, sync-actions
+    static MAX_CONNECTIONS = 2; // 1 for all operations (sequential), 1 for IDLE
     constructor(db) {
         super();
         this.db = db;

package/packages/mailx-service/index.js

@@ -539,12 +539,30 @@ export class MailxService {
         if (detected?.cloud) {
             await initCloudConfig(detected.cloud);
         }
-        // Try to load existing accounts from cloud (merge, don't overwrite)
+        // Check cloud for existing accounts — if found, just load them all
         let accounts = loadAccounts();
         if (accounts.length === 0) {
             accounts = await loadAccountsAsync();
         }
-        // Build the new account entry
+        if (accounts.length > 0) {
+            // Existing accounts found on cloud — use them directly
+            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 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: `Loaded ${accounts.length} existing account(s) from cloud.` };
+        }
+        // No existing accounts — create new one
         const account = { email, name: name || email.split("@")[0] };
         if (password)
             account.password = password;
@@ -552,17 +570,9 @@ export class MailxService {
             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
+        account.id = domain.split(".")[0] || "account";
+        saveAccounts([account]);
+        // Re-read normalized settings and register
         const settings = loadSettings();
         for (const acct of settings.accounts) {
             if (!acct.enabled)

package/packages/mailx-settings/index.js

@@ -78,13 +78,11 @@ function getSharedDir() {
             if (resolved)
                 return resolved;
         }
-        // Nothing mounted — save last provider entry for API fallback (log once)
+        // Set pending cloud config for API access
         if (!pendingCloudConfig) {
             const lastProvider = [...entries].reverse().find(e => typeof e !== "string");
-            if (lastProvider) {
+            if (lastProvider)
                 pendingCloudConfig = lastProvider;
-                console.log(`  No cloud drive mounted — will try ${lastProvider.provider} API`);
-            }
         }
     }
     // Legacy settingsPath no longer used for shared dir — use loadLegacySettings() for reading only.
@@ -388,7 +386,7 @@ export function loadAccounts() {
         }
         const raw = accounts.accounts || accounts;
         const globalName = accounts.name || "";
-        const result = raw.map((a) => normalizeAccount(a, globalName));
+        const result = deduplicateAccounts(raw.map((a) => normalizeAccount(a, globalName)));
         return applyAccountOverrides(result);
     }
     // Legacy: read from settings.jsonc
@@ -397,6 +395,27 @@ export function loadAccounts() {
         return applyAccountOverrides(legacy.accounts.map((a) => normalizeAccount(a, legacy.name)));
     return DEFAULT_ACCOUNTS;
 }
+/** Normalize email for dedup — Gmail ignores dots before @ */
+function normalizeEmail(email) {
+    const [local, domain] = email.toLowerCase().split("@");
+    if (!domain)
+        return email.toLowerCase();
+    if (domain === "gmail.com" || domain === "googlemail.com") {
+        return local.replace(/\./g, "") + "@gmail.com";
+    }
+    return `${local}@${domain}`;
+}
+/** Remove duplicate accounts (same email after normalization) */
+function deduplicateAccounts(accounts) {
+    const seen = new Set();
+    return accounts.filter(a => {
+        const key = normalizeEmail(a.email);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 /** Apply local per-account overrides (enabled, etc.) */
 function applyAccountOverrides(accounts) {
     const localConfig = readLocalConfig();
@@ -430,14 +449,7 @@ export async function loadAccountsAsync() {
                 return applyAccountOverrides(raw.map((a) => normalizeAccount(a, globalName)));
             }
         }
-        // Also try legacy settings.jsonc
-        const legacy = await cloudRead("settings.jsonc");
-        if (legacy) {
-            const data = parseJsonc(legacy);
-            if (data?.accounts) {
-                return applyAccountOverrides(data.accounts.map((a) => normalizeAccount(a, data.name)));
-            }
-        }
+        // Legacy settings.jsonc is no longer read — use accounts.jsonc only
     }
     return [];
 }