@bobfrankston/mailx 1.0.136 → 1.0.139

package/bin/mailx.js

@@ -3,17 +3,22 @@
  * mailx -- email client
  *
  * Usage:
- *   mailx                    Launch native app or fallback to browser
- *   mailx --server           Start Express server + open browser
- *   mailx --no-browser       Server mode, don't open browser
- *   mailx --external         Bind to all interfaces (server mode only)
+ *   mailx                    Start server + open in msger (or browser fallback)
+ *   mailx --server           Start server + open browser (skip msger)
+ *   mailx --no-browser       Start server only (headless)
+ *   mailx --external         Bind to all interfaces
  *   mailx --verbose          Show detailed startup info
  *   mailx -v / --version     Show version and exit
+ *   mailx -kill              Kill running mailx processes
+ *   mailx -setup             Interactive first-time setup
+ *   mailx -test              Test account connectivity
+ *   mailx -rebuild           Wipe local cache, keep accounts
  */
 import fs from "node:fs";
 import path from "node:path";
 import net from "node:net";
-const PORT = 9333;
+import { ports } from "@bobfrankston/miscinfo";
+const PORT = ports.mailx;
 const args = process.argv.slice(2);
 // Normalize: accept both -flag and --flag
 function hasFlag(name) { return args.includes(`-${name}`) || args.includes(`--${name}`); }
@@ -76,13 +81,6 @@ if (hasFlag("kill")) {
             }
         }
         catch { /* */ }
-        // Kill mailx-app.exe
-        try {
-            execSync("taskkill /F /IM mailx-app.exe", { stdio: "pipe" });
-            console.log("Killed mailx-app.exe");
-            killed++;
-        }
-        catch { /* */ }
     }
     else {
         try {
@@ -102,13 +100,6 @@ if (hasFlag("kill")) {
         }
         catch { /* */ }
     }
-    // Remove lock file
-    const lockPath = path.join(mailxDir, "mailx-app.lock");
-    try {
-        fs.unlinkSync(lockPath);
-        log("Removed lock file");
-    }
-    catch { /* */ }
     if (killed === 0)
         console.log("No mailx processes found");
     process.exit(0);
@@ -188,49 +179,31 @@ function openBrowser(url) {
             exec(`xdg-open "${url}"`);
     });
 }
+/** Launch msger pointing at the server URL; fall back to browser if msger not found */
+function launchMsger(url) {
+    import("node:child_process").then(({ spawn }) => {
+        const child = spawn("msger", ["-url", url], { detached: true, stdio: "ignore" });
+        child.on("error", () => {
+            log("msger not found — opening in browser");
+            openBrowser(url);
+        });
+        child.unref();
+    });
+}
 async function prompt(question) {
     const readline = await import("readline");
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise(resolve => rl.question(question, (ans) => { rl.close(); resolve(ans.trim()); }));
 }
-/** Detect mounted cloud drives that might have settings */
-function findCloudSettings() {
-    const home = process.env.USERPROFILE || process.env.HOME || "";
-    const checks = [
-        // OneDrive
-        { provider: "onedrive", dir: process.env.OneDrive ? path.join(process.env.OneDrive, "home", ".mailx") : "" },
-        { provider: "onedrive", dir: path.join(home, "OneDrive", "home", ".mailx") },
-        { provider: "onedrive", dir: path.join(home, "onedrive", "home", ".mailx") },
-        // Google Drive
-        { provider: "gdrive", dir: path.join(home, "Google Drive", "My Drive", "home", ".mailx") },
-        { provider: "gdrive", dir: path.join(home, "Google Drive Streaming", "My Drive", "home", ".mailx") },
-        // Dropbox
-        { provider: "dropbox", dir: path.join(home, "Dropbox", "home", ".mailx") },
-    ];
-    // Drive letters on Windows
-    if (process.platform === "win32") {
-        for (const letter of ["G", "H", "I", "J", "K"]) {
-            checks.push({ provider: "gdrive", dir: path.join(`${letter}:`, "My Drive", "home", ".mailx") });
-        }
-    }
-    for (const c of checks) {
-        if (c.dir && fs.existsSync(c.dir) && (fs.existsSync(path.join(c.dir, "settings.jsonc")) || fs.existsSync(path.join(c.dir, "accounts.jsonc")))) {
-            return c;
-        }
-    }
-    return null;
-}
-/** Check if mailx is configured (has accounts) */
+/** Check if mailx is configured (has local config or accounts) */
 function hasConfig() {
     const home = process.env.USERPROFILE || process.env.HOME || "";
     const mailxDir = path.join(home, ".mailx");
-    // Check local settings
-    for (const f of ["settings.jsonc", "accounts.jsonc", "config.jsonc"]) {
+    for (const f of ["config.jsonc", "accounts.jsonc", "settings.jsonc"]) {
         if (fs.existsSync(path.join(mailxDir, f)))
             return true;
     }
-    // Check cloud drives
-    return findCloudSettings() !== null;
+    return false;
 }
 /** Try to auto-discover mail server settings from email domain */
 async function autoDiscover(domain) {
@@ -265,6 +238,29 @@ async function autoDiscover(domain) {
         }
     }
     catch { /* DNS failed */ }
+    // 3. Try MX-based detection (Google Workspace, Microsoft 365)
+    try {
+        const dns = await import("node:dns/promises");
+        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 {
+                    imap: { host: "imap.gmail.com", port: 993, auth: "oauth2" },
+                    smtp: { host: "smtp.gmail.com", port: 587, auth: "oauth2" },
+                    source: `MX → Google (${host})`,
+                };
+            }
+            if (host.endsWith(".outlook.com") || host.endsWith(".protection.outlook.com")) {
+                return {
+                    imap: { host: "outlook.office365.com", port: 993, auth: "oauth2" },
+                    smtp: { host: "smtp.office365.com", port: 587, auth: "oauth2" },
+                    source: `MX → Microsoft (${host})`,
+                };
+            }
+        }
+    }
+    catch { /* DNS failed */ }
     return null;
 }
 /** Prompt user for account details, auto-discover where possible */
@@ -307,44 +303,15 @@ async function promptForAccount(intro) {
         smtp: { host: smtpHost },
     };
 }
-/** Find a mounted cloud drive (for saving new settings) */
-function findMountedDrive() {
-    const home = process.env.USERPROFILE || process.env.HOME || "";
-    const checks = [
-        { provider: "onedrive", base: process.env.OneDrive || "", dir: process.env.OneDrive ? path.join(process.env.OneDrive, "home", ".mailx") : "" },
-        { provider: "onedrive", base: path.join(home, "OneDrive"), dir: path.join(home, "OneDrive", "home", ".mailx") },
-        { provider: "onedrive", base: path.join(home, "onedrive"), dir: path.join(home, "onedrive", "home", ".mailx") },
-        { provider: "gdrive", base: path.join(home, "Google Drive", "My Drive"), dir: path.join(home, "Google Drive", "My Drive", "home", ".mailx") },
-        { provider: "gdrive", base: path.join(home, "Google Drive Streaming", "My Drive"), dir: path.join(home, "Google Drive Streaming", "My Drive", "home", ".mailx") },
-        { provider: "dropbox", base: path.join(home, "Dropbox"), dir: path.join(home, "Dropbox", "home", ".mailx") },
-    ];
-    for (const c of checks) {
-        if (c.base && fs.existsSync(c.base))
-            return c;
-    }
-    return null;
-}
-/** Interactive first-time setup */
+/** Interactive first-time setup — GDrive API for cloud storage */
 async function runSetup() {
     console.log("\nmailx — first-time setup\n");
     const home = process.env.USERPROFILE || process.env.HOME || "";
     const mailxDir = path.join(home, ".mailx");
-    // Check for existing cloud settings
-    const cloud = findCloudSettings();
-    if (cloud) {
-        console.log(`Found existing settings on ${cloud.provider}: ${cloud.dir}`);
-        fs.mkdirSync(mailxDir, { recursive: true });
-        const config = { sharedDir: { provider: cloud.provider, path: "home/.mailx" } };
-        fs.writeFileSync(path.join(mailxDir, "config.jsonc"), JSON.stringify(config, null, 2));
-        console.log(`Created ~/.mailx/config.jsonc pointing to ${cloud.provider}`);
-        console.log("Setup complete. Starting mailx...\n");
-        return true;
-    }
-    // No cloud settings found — prompt for email
-    console.log("No existing settings found on OneDrive, Google Drive, or Dropbox.\n");
-    const account = await promptForAccount("Gmail is recommended as the first account (provides contacts + cloud sync).\n");
+    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(`\nCreate settings manually at: ${path.join(mailxDir, "settings.jsonc")}`);
+        console.log(`\nNo account added. Open http://127.0.0.1:${PORT} in a browser to set up via the UI.`);
         fs.mkdirSync(mailxDir, { recursive: true });
         return false;
     }
@@ -356,43 +323,47 @@ async function runSetup() {
         sync: { intervalMinutes: 5, historyDays: 0 },
     };
     const domain = account.email.split("@")[1]?.toLowerCase() || "";
-    const isGmail = domain === "gmail.com" || domain === "googlemail.com";
-    // Ask where to store settings
-    const mountedDrive = findMountedDrive();
-    let storageChoice = "local";
-    if (mountedDrive) {
-        const useCloud = await prompt(`Store settings on ${mountedDrive.provider} (syncs across machines)? [Y/n]: `);
-        if (!useCloud || useCloud.toLowerCase() !== "n")
-            storageChoice = mountedDrive.provider;
-    }
-    else if (isGmail) {
-        const useGDrive = await prompt("Store settings on Google Drive (syncs across machines, editable via drive.google.com)? [Y/n]: ");
-        if (!useGDrive || useGDrive.toLowerCase() !== "n")
-            storageChoice = "gdrive-api";
+    // Detect if this is a Google-hosted domain (for GDrive cloud storage)
+    let isGoogle = ["gmail.com", "googlemail.com"].includes(domain);
+    if (!isGoogle) {
+        try {
+            const dns = await import("node:dns/promises");
+            const records = await dns.resolveMx(domain);
+            isGoogle = records.some(mx => {
+                const host = mx.exchange.toLowerCase();
+                return host.endsWith(".google.com") || host.endsWith(".googlemail.com");
+            });
+            if (isGoogle)
+                console.log(`  ${domain} is hosted on Google (detected via MX)`);
+        }
+        catch { /* DNS lookup failed */ }
     }
     fs.mkdirSync(mailxDir, { recursive: true });
-    if (storageChoice === "gdrive-api") {
-        // Save to Google Drive via API (not mounted)
+    if (isGoogle) {
+        // Save to Google Drive via API (folder-ID based, no path navigation)
         console.log("\nSaving settings to Google Drive via API...");
         try {
-            const { getCloudProvider } = await import("../packages/mailx-settings/cloud.js");
-            const gdrive = getCloudProvider("gdrive");
-            if (gdrive) {
-                const content = JSON.stringify(settings, null, 2);
-                const ok = await gdrive.write("home/.mailx/settings.jsonc", content);
-                if (ok) {
-                    console.log("Settings saved to Google Drive: home/.mailx/settings.jsonc");
-                    const config = { sharedDir: { provider: "gdrive", path: "home/.mailx" } };
-                    fs.writeFileSync(path.join(mailxDir, "config.jsonc"), JSON.stringify(config, null, 2));
-                    console.log("Local config created pointing to Google Drive.");
-                }
-                else {
-                    console.log("Google Drive write failed — saving locally instead.");
-                    fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
+            const { gDriveFindOrCreateFolder, getCloudProvider } = await import("@bobfrankston/mailx-settings/cloud.js");
+            const folderId = await gDriveFindOrCreateFolder();
+            if (folderId) {
+                const gdrive = getCloudProvider("gdrive", folderId);
+                if (gdrive) {
+                    const content = JSON.stringify(settings, null, 2);
+                    const ok = await gdrive.write("settings.jsonc", content);
+                    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.");
+                    }
+                    else {
+                        console.log("Google Drive write failed — saving locally instead.");
+                        fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
+                    }
                 }
             }
             else {
-                console.log("Google Drive API not available — saving locally.");
+                console.log("Google Drive folder setup failed — saving locally.");
                 fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
             }
         }
@@ -401,17 +372,8 @@ async function runSetup() {
             fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
         }
     }
-    else if (storageChoice !== "local" && mountedDrive) {
-        // Save to mounted cloud drive
-        console.log(`\nSaving settings to ${mountedDrive.provider} at ${mountedDrive.dir}...`);
-        fs.mkdirSync(mountedDrive.dir, { recursive: true });
-        fs.writeFileSync(path.join(mountedDrive.dir, "settings.jsonc"), JSON.stringify(settings, null, 2));
-        const config = { sharedDir: { provider: mountedDrive.provider, path: "home/.mailx" } };
-        fs.writeFileSync(path.join(mailxDir, "config.jsonc"), JSON.stringify(config, null, 2));
-        console.log("Settings saved to cloud drive + local config created.");
-    }
     else {
-        // Save locally
+        // Non-Google account — save locally
         console.log(`\nSaving settings to ${mailxDir}...`);
         fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
     }
@@ -507,7 +469,7 @@ async function runTest() {
 async function main() {
     log(`Platform: ${process.platform} ${process.arch}`);
     log(`Node: ${process.version}`);
-    log(`Mode: ${serverMode ? "server" : setupMode ? "setup" : "auto-detect"}`);
+    log(`Mode: ${serverMode ? "server" : setupMode ? "setup" : "auto"}`);
     // Test connectivity
     if (testMode) {
         await runTest();
@@ -537,87 +499,49 @@ async function main() {
         process.exit(0);
     }
     // Auto-detect first run — enter setup if no config exists
-    if (setupMode || (!serverMode && !hasConfig())) {
+    if (setupMode || !hasConfig()) {
         if (!setupMode)
             console.log("No mailx configuration found.");
         await runSetup();
     }
-    if (serverMode) {
-        // Server mode — Express + WebSocket, open browser
-        const inUse = await isPortInUse(PORT);
-        if (inUse) {
-            console.log(`mailx server already running on port ${PORT}`);
-            if (!noBrowser)
-                openBrowser(`http://127.0.0.1:${PORT}`);
-            return;
-        }
-        console.log("Starting mailx server...");
-        log(`Loading server from: ${path.join(import.meta.dirname, "..", "packages", "mailx-server", "index.js")}`);
-        if (hasFlag("external"))
-            process.argv.push("--external");
-        await import("../packages/mailx-server/index.js");
+    // Check if server is already running
+    const inUse = await isPortInUse(PORT);
+    if (inUse) {
+        console.log(`mailx server already running on port ${PORT}`);
+        const url = `http://127.0.0.1:${PORT}`;
         if (!noBrowser) {
-            for (let i = 0; i < 30; i++) {
-                await new Promise(r => setTimeout(r, 200));
-                if (await isPortInUse(PORT))
-                    break;
-            }
-            openBrowser(`http://127.0.0.1:${PORT}`);
-            console.log("mailx opened (browser)");
+            if (serverMode)
+                openBrowser(url);
+            else
+                launchMsger(url);
         }
-        // Keep process alive — server is running
-        await new Promise(() => { });
+        return;
     }
-    else {
-        // Default: launch native WebView app
-        let binaryName;
-        if (process.platform === "win32")
-            binaryName = "mailx-app.exe";
-        else if (process.platform === "darwin")
-            binaryName = process.arch === "arm64" ? "mailx-app-arm64" : "mailx-app";
-        else
-            binaryName = process.arch === "arm64" ? "mailx-app-linux-aarch64" : "mailx-app-linux";
-        const launcherPaths = [
-            path.join(import.meta.dirname, "..", "launcher", "bin", binaryName),
-            path.join(import.meta.dirname, "..", "launcher", "target", "release", binaryName),
-        ];
-        log(`Looking for native launcher: ${binaryName}`);
-        for (const p of launcherPaths)
-            log(`  ${fs.existsSync(p) ? "FOUND" : "not found"}: ${p}`);
-        let launcherPath = launcherPaths.find(p => fs.existsSync(p));
-        // On Linux, skip native launcher if no display server available
-        if (launcherPath && process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
-            log("No display server (DISPLAY/WAYLAND_DISPLAY not set) — skipping native launcher");
-            launcherPath = undefined;
+    // Start Express server in-process
+    console.log("Starting mailx server...");
+    log(`Loading server from: ${path.join(import.meta.dirname, "..", "packages", "mailx-server", "index.js")}`);
+    if (hasFlag("external"))
+        process.argv.push("--external");
+    await import("../packages/mailx-server/index.js");
+    // Open UI once server is ready
+    if (!noBrowser) {
+        const url = `http://127.0.0.1:${PORT}`;
+        for (let i = 0; i < 30; i++) {
+            await new Promise(r => setTimeout(r, 200));
+            if (await isPortInUse(PORT))
+                break;
         }
-        if (launcherPath) {
-            console.log("Starting mailx...");
-            log(`Launching: ${launcherPath}`);
-            const { spawn } = await import("node:child_process");
-            try {
-                const child = spawn(launcherPath, args, { detached: true, stdio: "ignore" });
-                child.on("error", () => {
-                    console.log("Native launcher failed, starting in browser mode...");
-                    process.argv.push("--server");
-                    main();
-                });
-                child.unref();
-                console.log("mailx launched");
-            }
-            catch (e) {
-                console.log(`Native launcher failed: ${e.message}`);
-                console.log("Starting in browser mode...");
-                process.argv.push("--server");
-                await main();
-            }
+        if (serverMode) {
+            openBrowser(url);
+            console.log("mailx opened (browser)");
         }
         else {
-            console.log("Starting in browser mode...");
-            log("No native launcher — falling back to --server mode");
-            process.argv.push("--server");
-            await main(); // recurse with --server
+            launchMsger(url);
+            console.log("mailx opened");
         }
     }
+    // Keep process alive — server is running
+    await new Promise(() => { });
 }
 main().catch(console.error);
 //# sourceMappingURL=mailx.js.map

package/client/app.js

@@ -904,10 +904,16 @@ fetch("/api/version").then(r => r.json()).then(d => {
     const el = document.getElementById("app-version");
     const storage = d.storage || {};
     const storageLabel = storage.provider && storage.provider !== "local"
-        ? ` [${storage.provider}${storage.mode === "api" ? " API" : ""}]`
+        ? ` [${storage.provider}]`
         : "";
-    if (el)
+    if (el) {
         el.textContent = `mailx v${d.version}${storageLabel}${isApp ? "" : " [browser]"}`;
+        // Tooltip: show cloud path and access mode on hover
+        if (storage.provider && storage.provider !== "local") {
+            const modeDesc = storage.mode === "api" ? "API" : "mount";
+            el.title = `${storage.cloudPath || storage.provider} (${modeDesc})`;
+        }
+    }
     if (d.settingsError) {
         showAlert(d.settingsError, "settings-error");
         // Add repair button to the banner

package/client/components/folder-tree.js

@@ -367,8 +367,9 @@ async function loadFolderTree(container) {
                     </form>
                     <details style="margin-top:2rem;color:var(--color-text-muted)">
                         <summary>Manual setup (advanced)</summary>
-                        <p style="margin-top:0.5rem">Create <code>~/.mailx/settings.jsonc</code> or point to shared settings:</p>
-                        <code style="display:block;padding:0.75rem;background:var(--color-bg-surface);border:1px solid var(--color-border);border-radius:4px;margin:0.5rem 0;white-space:pre;font-size:0.85rem">{ "sharedDir": "~/OneDrive/home/.mailx" }</code>
+                        <p style="margin-top:0.5rem">Create <code>~/.mailx/config.jsonc</code> with a cloud provider:</p>
+                        <code style="display:block;padding:0.75rem;background:var(--color-bg-surface);border:1px solid var(--color-border);border-radius:4px;margin:0.5rem 0;white-space:pre;font-size:0.85rem">{ "sharedDir": { "provider": "gdrive", "path": "home/.mailx" } }</code>
+                        <p style="margin-top:0.5rem;font-size:0.85rem">Settings sync via Google Drive API (auto-configured for Gmail accounts).</p>
                     </details>
                 </div>`;
                 // Wire up the setup form

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.136",
+  "version": "1.0.139",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

package/packages/mailx-api/index.js

@@ -3,8 +3,38 @@
  * 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, initLocalConfig, initCloudConfig, loadSettings } from "@bobfrankston/mailx-settings";
+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();
@@ -114,17 +144,21 @@ export function createApiRouter(db, imapManager) {
                 res.status(400).json({ error: "Email address required" });
                 return;
             }
-            // Ensure ~/.mailx exists
-            initLocalConfig();
-            // Default to gdrive for Gmail users (creates config.jsonc with gdrive provider)
+            // Detect provider via domain or MX records (Google Workspace, Microsoft 365 custom domains)
             const domain = email.split("@")[1]?.toLowerCase() || "";
-            if (["gmail.com", "googlemail.com"].includes(domain)) {
-                initCloudConfig("gdrive");
+            const detected = await detectEmailProvider(domain);
+            if (detected?.cloud) {
+                await initCloudConfig(detected.cloud);
             }
-            // Build account config (normalizeAccount handles provider detection)
+            // Build 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 };
+            }
             // Load existing accounts — try cloud API in case home/.mailx already exists on Drive
             let accounts = loadAccounts();
             if (accounts.length === 0) {

package/packages/mailx-server/index.js

@@ -55,7 +55,7 @@ if (settings.accounts.length === 0) {
         console.log(`  Loaded ${cloudAccounts.length} account(s) from cloud API`);
     }
     else {
-        console.log("  No accounts configured. Open http://127.0.0.1:9333 to set up.");
+        console.log("  No accounts configured. Open http://127.0.0.1:9333 to add your email account.");
     }
 }
 const dbDir = getConfigDir();
@@ -100,7 +100,7 @@ app.get("/api/version", (req, res) => {
     const settingsError = (dbAccounts > 0 && imapAccounts === 0)
         ? "No accounts loaded from settings — showing stale data. Check accounts.jsonc on your cloud drive."
         : undefined;
-    res.json({ version: SERVER_VERSION, theme: settings.ui?.theme || "system", storage, imapAccounts, settingsError });
+    res.json({ version: SERVER_VERSION, theme: settings.ui?.theme || "system", storage, imapAccounts, hasAccounts: imapAccounts > 0 || dbAccounts > 0, settingsError });
 });
 app.all("/info", (req, res) => {
     res.json({ version: SERVER_VERSION, uptime: Math.round(process.uptime()), port: PORT, imap: imapManager.useNativeClient ? "native" : "imapflow" });
@@ -203,10 +203,24 @@ const clients = new Set();
 function wireWebSocket() {
     wss.on("connection", (ws) => {
         clients.add(ws);
+        ws.__alive = true;
         const connected = { type: "connected" };
         ws.send(JSON.stringify(connected));
+        ws.on("pong", () => { ws.__alive = true; });
         ws.on("close", () => clients.delete(ws));
     });
+    // Heartbeat — detect dead connections, prevent CLOSE_WAIT zombie accumulation
+    setInterval(() => {
+        for (const ws of clients) {
+            if (ws.__alive === false) {
+                clients.delete(ws);
+                ws.terminate();
+                continue;
+            }
+            ws.__alive = false;
+            ws.ping();
+        }
+    }, 30000);
 }
 function broadcast(event) {
     const data = JSON.stringify(event);

package/packages/mailx-settings/cloud.d.ts

@@ -1,14 +1,35 @@
 /**
- * Cloud storage abstraction for mailx settings.
- * Reads/writes settings files on OneDrive (Graph API) or Google Drive (Drive API)
- * when the cloud drive is not mounted locally.
- * Falls back to local cache when offline.
+ * Cloud storage for mailx settings — Google Drive API (drive.file scope).
+ *
+ * Uses a single app-owned "mailx" folder on Drive, accessed by folder ID.
+ * The drive.file scope only sees files/folders created by this OAuth client,
+ * which prevents conflicts with existing folders of the same name.
+ * All machines using the same OAuth client ID share the same folder.
+ *
+ * ── Restoring removed providers ──
+ * OneDrive (removed 2026-04-06): Required microsoft-credentials.json in ~/.mailx/,
+ *   MS_SCOPES = "https://graph.microsoft.com/Files.ReadWrite offline_access",
+ *   authenticateOAuth with tokenDir ~/.mailx/tokens/microsoft/.
+ *   Read/write via Graph API: GET/PUT https://graph.microsoft.com/v1.0/me/drive/root:/{path}:/content
+ *   Azure AD app registration needed: https://portal.azure.com → App registrations → Desktop app
+ *
+ * Dropbox (removed 2026-04-06): Never implemented — placeholder only.
+ *   Would need Dropbox OAuth app, token management, and Dropbox API v2 calls.
  */
-export type CloudProvider = "onedrive" | "gdrive" | "google" | "dropbox" | "local";
+/** Find the app-owned "mailx" folder, or create it. Returns folder ID. */
+export declare function gDriveFindOrCreateFolder(): Promise<string | null>;
+export type CloudProvider = "gdrive" | "google" | "local";
 export interface CloudFile {
+    /** Read a file. For gdrive, path is just the filename (folder ID is implicit). */
     read(filePath: string): Promise<string | null>;
+    /** Write a file. For gdrive, path is just the filename. */
     write(filePath: string, content: string): Promise<boolean>;
+    /** Check if a file exists. */
     exists(filePath: string): Promise<boolean>;
 }
-export declare function getCloudProvider(provider: CloudProvider): CloudFile | null;
+/**
+ * Get a cloud file provider. For gdrive, pass the folder ID.
+ * Files are stored flat in the folder (no subdirectory navigation).
+ */
+export declare function getCloudProvider(provider: string, folderId?: string): CloudFile | null;
 //# sourceMappingURL=cloud.d.ts.map

package/packages/mailx-settings/cloud.js

@@ -1,28 +1,33 @@
 /**
- * Cloud storage abstraction for mailx settings.
- * Reads/writes settings files on OneDrive (Graph API) or Google Drive (Drive API)
- * when the cloud drive is not mounted locally.
- * Falls back to local cache when offline.
+ * Cloud storage for mailx settings — Google Drive API (drive.file scope).
+ *
+ * Uses a single app-owned "mailx" folder on Drive, accessed by folder ID.
+ * The drive.file scope only sees files/folders created by this OAuth client,
+ * which prevents conflicts with existing folders of the same name.
+ * All machines using the same OAuth client ID share the same folder.
+ *
+ * ── Restoring removed providers ──
+ * OneDrive (removed 2026-04-06): Required microsoft-credentials.json in ~/.mailx/,
+ *   MS_SCOPES = "https://graph.microsoft.com/Files.ReadWrite offline_access",
+ *   authenticateOAuth with tokenDir ~/.mailx/tokens/microsoft/.
+ *   Read/write via Graph API: GET/PUT https://graph.microsoft.com/v1.0/me/drive/root:/{path}:/content
+ *   Azure AD app registration needed: https://portal.azure.com → App registrations → Desktop app
+ *
+ * Dropbox (removed 2026-04-06): Never implemented — placeholder only.
+ *   Would need Dropbox OAuth app, token management, and Dropbox API v2 calls.
  */
 import fs from "node:fs";
 import path from "node:path";
 import { authenticateOAuth } from "@bobfrankston/oauthsupport";
 const SETTINGS_DIR = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx");
 // ── Credentials ──
-// Microsoft Graph: needs app registration in Azure AD
-// Create at: https://portal.azure.com → App registrations → New → Desktop app
-const MS_CREDENTIALS_PATH = path.join(SETTINGS_DIR, "microsoft-credentials.json");
-const MS_TOKEN_DIR = path.join(SETTINGS_DIR, "tokens", "microsoft");
-const MS_SCOPES = "https://graph.microsoft.com/Files.ReadWrite offline_access";
 // Google Drive: reuse iflow's OAuth credentials (same Google Cloud project)
 function findGoogleCredentials() {
     // Check mailx local dir first, then iflow package
     const local = path.join(SETTINGS_DIR, "google-credentials.json");
     if (fs.existsSync(local))
         return local;
-    // Try to find iflow's credentials via import.meta.resolve or node_modules walk
     try {
-        // Walk up from this package to find iflow in node_modules
         let dir = import.meta.dirname;
         for (let i = 0; i < 5; i++) {
             for (const name of ["iflow-credentials.json", "credentials.json"]) {
@@ -40,31 +45,29 @@ function findGoogleCredentials() {
     return null;
 }
 const GDRIVE_TOKEN_DIR = path.join(SETTINGS_DIR, "tokens", "gdrive");
+// drive.file: app can only see files it created. Safe, publishable without security audit.
+// All machines sharing the same OAuth client ID see the same files.
 const GDRIVE_SCOPES = "https://www.googleapis.com/auth/drive.file";
+const GDRIVE_FOLDER_NAME = "mailx";
 // ── Token helpers ──
-async function getMicrosoftToken() {
-    if (!fs.existsSync(MS_CREDENTIALS_PATH))
-        return null;
-    try {
-        const token = await authenticateOAuth(MS_CREDENTIALS_PATH, {
-            scope: MS_SCOPES,
-            tokenDirectory: MS_TOKEN_DIR,
-            tokenFileName: "token.json",
-            includeOfflineAccess: true,
-        });
-        return token?.access_token || null;
-    }
-    catch (e) {
-        console.error(`  [cloud] Microsoft auth failed: ${e.message}`);
-        return null;
-    }
-}
 async function getGoogleDriveToken() {
     const creds = findGoogleCredentials();
     if (!creds) {
         console.error("  [cloud] No Google credentials found (checked ~/.mailx/google-credentials.json and iflow package)");
         return null;
     }
+    // Delete stale token if scope changed (drive → drive.file or vice versa)
+    const tokenPath = path.join(GDRIVE_TOKEN_DIR, "token.json");
+    if (fs.existsSync(tokenPath)) {
+        try {
+            const existing = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+            if (existing.scope && existing.scope !== GDRIVE_SCOPES) {
+                console.log(`  [cloud] Scope changed — re-authenticating...`);
+                fs.unlinkSync(tokenPath);
+            }
+        }
+        catch { /* ignore parse errors */ }
+    }
     try {
         const token = await authenticateOAuth(creds, {
             scope: GDRIVE_SCOPES,
@@ -80,190 +83,97 @@ async function getGoogleDriveToken() {
         return null;
     }
 }
-// ── OneDrive Graph API ──
-async function oneDriveRead(filePath) {
-    const token = await getMicrosoftToken();
-    if (!token)
-        return null;
-    try {
-        const encoded = filePath.split("/").map(encodeURIComponent).join("/");
-        const res = await fetch(`https://graph.microsoft.com/v1.0/me/drive/root:/${encoded}:/content`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        if (!res.ok)
-            return null;
-        return await res.text();
-    }
-    catch {
-        return null;
-    }
-}
-async function oneDriveWrite(filePath, content) {
-    const token = await getMicrosoftToken();
-    if (!token)
-        return false;
-    try {
-        const encoded = filePath.split("/").map(encodeURIComponent).join("/");
-        const res = await fetch(`https://graph.microsoft.com/v1.0/me/drive/root:/${encoded}:/content`, {
-            method: "PUT",
-            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-            body: content,
-        });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-async function oneDriveExists(filePath) {
-    const token = await getMicrosoftToken();
-    if (!token)
-        return false;
-    try {
-        const encoded = filePath.split("/").map(encodeURIComponent).join("/");
-        const res = await fetch(`https://graph.microsoft.com/v1.0/me/drive/root:/${encoded}`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-// ── Google Drive API ──
-async function gDriveFind(fileName, parentName) {
+// ── Google Drive API (folder-ID based) ──
+/** Find the app-owned "mailx" folder, or create it. Returns folder ID. */
+export async function gDriveFindOrCreateFolder() {
     const token = await getGoogleDriveToken();
     if (!token)
         return null;
     try {
-        let query = `name='${fileName}' and trashed=false`;
-        if (parentName) {
-            // Find parent folder first
-            const parentRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(`name='${parentName}' and mimeType='application/vnd.google-apps.folder' and trashed=false`)}&fields=files(id)`, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
-            if (parentRes.ok) {
-                const data = await parentRes.json();
-                if (data.files?.[0])
-                    query += ` and '${data.files[0].id}' in parents`;
-            }
-        }
+        // Search for existing folder (created by this OAuth client)
+        const query = `name='${GDRIVE_FOLDER_NAME}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
         const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id,name)`, {
             headers: { Authorization: `Bearer ${token}` },
         });
-        if (!res.ok)
+        if (!res.ok) {
+            console.error(`  [cloud] gdrive folder search: ${res.status} ${res.statusText}`);
             return null;
+        }
         const data = await res.json();
-        return data.files?.[0]?.id || null;
+        if (data.files?.[0]) {
+            console.log(`  [cloud] Found existing '${GDRIVE_FOLDER_NAME}' folder: ${data.files[0].id}`);
+            return data.files[0].id;
+        }
+        // Create folder
+        const createRes = await fetch("https://www.googleapis.com/drive/v3/files", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ name: GDRIVE_FOLDER_NAME, mimeType: "application/vnd.google-apps.folder" }),
+        });
+        if (!createRes.ok) {
+            console.error(`  [cloud] gdrive folder create: ${createRes.status} ${createRes.statusText}`);
+            return null;
+        }
+        const created = await createRes.json();
+        console.log(`  [cloud] Created '${GDRIVE_FOLDER_NAME}' folder: ${created.id}`);
+        return created.id;
     }
-    catch {
+    catch (e) {
+        console.error(`  [cloud] gdrive folder setup: ${e.message}`);
         return null;
     }
 }
-async function gDriveRead(filePath) {
+/** Read a file by name from a folder (by ID) */
+async function gDriveReadFromFolder(folderId, fileName) {
     const token = await getGoogleDriveToken();
     if (!token) {
-        console.error(`  [cloud] gdrive read ${filePath}: no token`);
+        console.error(`  [cloud] gdrive read ${fileName}: no token`);
         return null;
     }
     try {
-        // Parse path: "home/.mailx/settings.jsonc" → find by folder structure
-        const parts = filePath.split("/");
-        const fileName = parts.pop();
-        let parentId = null;
-        // Navigate folder structure
-        for (const folder of parts) {
-            let query = `name='${folder}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
-            if (parentId)
-                query += ` and '${parentId}' in parents`;
-            const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
-            if (!res.ok) {
-                console.error(`  [cloud] gdrive folder lookup '${folder}': ${res.status} ${res.statusText}`);
-                return null;
-            }
-            const data = await res.json();
-            if (!data.files?.[0]) {
-                console.error(`  [cloud] gdrive folder '${folder}' not found (drive.file scope can only see app-created files)`);
-                return null;
-            }
-            parentId = data.files[0].id;
-        }
-        // Find the file
-        let query = `name='${fileName}' and trashed=false`;
-        if (parentId)
-            query += ` and '${parentId}' in parents`;
-        const fileRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
+        // Find file in folder
+        const query = `name='${fileName}' and '${folderId}' in parents and trashed=false`;
+        const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
             headers: { Authorization: `Bearer ${token}` },
         });
-        if (!fileRes.ok) {
-            console.error(`  [cloud] gdrive file lookup '${fileName}': ${fileRes.status} ${fileRes.statusText}`);
+        if (!res.ok) {
+            console.error(`  [cloud] gdrive lookup '${fileName}': ${res.status}`);
             return null;
         }
-        const fileData = await fileRes.json();
-        const fileId = fileData.files?.[0]?.id;
-        if (!fileId) {
-            console.error(`  [cloud] gdrive file '${fileName}' not found in ${parts.join("/")}`);
+        const data = await res.json();
+        const fileId = data.files?.[0]?.id;
+        if (!fileId)
             return null;
-        }
         // Download content
         const contentRes = await fetch(`https://www.googleapis.com/drive/v3/files/${fileId}?alt=media`, {
             headers: { Authorization: `Bearer ${token}` },
         });
         if (!contentRes.ok) {
-            console.error(`  [cloud] gdrive download ${fileId}: ${contentRes.status} ${contentRes.statusText}`);
+            console.error(`  [cloud] gdrive download ${fileName}: ${contentRes.status}`);
             return null;
         }
         return await contentRes.text();
     }
     catch (e) {
-        console.error(`  [cloud] gdrive read ${filePath}: ${e.message}`);
+        console.error(`  [cloud] gdrive read ${fileName}: ${e.message}`);
         return null;
     }
 }
-async function gDriveWrite(filePath, content) {
+/** Write a file by name to a folder (by ID) — creates or updates */
+async function gDriveWriteToFolder(folderId, fileName, content) {
     const token = await getGoogleDriveToken();
     if (!token)
         return false;
     try {
-        const parts = filePath.split("/");
-        const fileName = parts.pop();
-        // Ensure folder structure exists
-        let parentId = null;
-        for (const folder of parts) {
-            let query = `name='${folder}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
-            if (parentId)
-                query += ` and '${parentId}' in parents`;
-            const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
-            const data = await res.json();
-            if (data.files?.[0]) {
-                parentId = data.files[0].id;
-            }
-            else {
-                // Create folder
-                const createRes = await fetch("https://www.googleapis.com/drive/v3/files", {
-                    method: "POST",
-                    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-                    body: JSON.stringify({ name: folder, mimeType: "application/vnd.google-apps.folder", parents: parentId ? [parentId] : [] }),
-                });
-                const created = await createRes.json();
-                parentId = created.id;
-            }
-        }
-        // Check if file exists
-        let query = `name='${fileName}' and trashed=false`;
-        if (parentId)
-            query += ` and '${parentId}' in parents`;
+        // Check if file exists in folder
+        const query = `name='${fileName}' and '${folderId}' in parents and trashed=false`;
         const findRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
             headers: { Authorization: `Bearer ${token}` },
         });
         const findData = await findRes.json();
         const existingId = findData.files?.[0]?.id;
         if (existingId) {
-            // Update existing
+            // Update existing file
             const res = await fetch(`https://www.googleapis.com/upload/drive/v3/files/${existingId}?uploadType=media`, {
                 method: "PATCH",
                 headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
@@ -272,9 +182,9 @@ async function gDriveWrite(filePath, content) {
             return res.ok;
         }
         else {
-            // Create new — multipart upload with metadata
+            // Create new file in folder
             const boundary = "mailx_boundary_" + Date.now();
-            const metadata = JSON.stringify({ name: fileName, parents: parentId ? [parentId] : [] });
+            const metadata = JSON.stringify({ name: fileName, parents: [folderId] });
             const body = `--${boundary}\r\nContent-Type: application/json\r\n\r\n${metadata}\r\n--${boundary}\r\nContent-Type: application/json\r\n\r\n${content}\r\n--${boundary}--`;
             const res = await fetch("https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart", {
                 method: "POST",
@@ -284,28 +194,28 @@ async function gDriveWrite(filePath, content) {
             return res.ok;
         }
     }
-    catch {
+    catch (e) {
+        console.error(`  [cloud] gdrive write ${fileName}: ${e.message}`);
         return false;
     }
 }
-export function getCloudProvider(provider) {
+/**
+ * Get a cloud file provider. For gdrive, pass the folder ID.
+ * Files are stored flat in the folder (no subdirectory navigation).
+ */
+export function getCloudProvider(provider, folderId) {
     switch (provider) {
-        case "onedrive":
-            return {
-                read: oneDriveRead,
-                write: oneDriveWrite,
-                exists: oneDriveExists,
-            };
         case "google":
         case "gdrive":
+            if (!folderId) {
+                console.error("  [cloud] gdrive requires a folder ID — run initCloudConfig first");
+                return null;
+            }
             return {
-                read: gDriveRead,
-                write: gDriveWrite,
-                exists: async (p) => (await gDriveRead(p)) !== null,
+                read: (fileName) => gDriveReadFromFolder(folderId, fileName),
+                write: (fileName, content) => gDriveWriteToFolder(folderId, fileName, content),
+                exists: async (fileName) => (await gDriveReadFromFolder(folderId, fileName)) !== null,
             };
-        case "dropbox":
-            // TODO: Dropbox API
-            return null;
         case "local":
             return {
                 read: async (p) => { try {
@@ -324,6 +234,7 @@ export function getCloudProvider(provider) {
                 exists: async (p) => fs.existsSync(p),
             };
         default:
+            console.error(`  [cloud] Provider "${provider}" not supported — only gdrive is available`);
             return null;
     }
 }

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

@@ -24,10 +24,11 @@ export declare function cloudRead(filename: string): Promise<string | null>;
 export declare function cloudWrite(filename: string, content: string): Promise<boolean>;
 /** Whether cloud API fallback is active */
 export declare function isCloudMode(): boolean;
-/** Get storage provider info for display (e.g. "OneDrive", "Google Drive", "local") */
+/** Get storage provider info for display */
 export declare function getStorageInfo(): {
     provider: string;
     mode: "mount" | "api" | "local";
+    cloudPath?: string;
     cloudError?: string;
 };
 declare const DEFAULT_PREFERENCES: {
@@ -89,8 +90,9 @@ export declare function getConfigDir(): string;
 export { getSharedDir };
 /** Initialize local config if it doesn't exist */
 export declare function initLocalConfig(sharedDir?: string, storePath?: string): void;
-/** Initialize config with a cloud provider (e.g. gdrive for Gmail users) */
-export declare function initCloudConfig(provider: "gdrive" | "onedrive" | "dropbox", cloudPath?: string): void;
+/** Initialize config with Google Drive cloud storage.
+ *  Finds or creates the app-owned "mailx" folder on Drive and stores its ID. */
+export declare function initCloudConfig(provider?: "gdrive"): Promise<void>;
 declare const DEFAULT_SETTINGS: MailxSettings;
 /** Get historyDays for an account: per-account override > system override > shared default */
 export declare function getHistoryDays(accountId?: string): number;

package/packages/mailx-settings/index.js

@@ -18,7 +18,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
-import { getCloudProvider } from "./cloud.js";
+import { getCloudProvider, gDriveFindOrCreateFolder } from "./cloud.js";
 // ── Paths ──
 const LOCAL_DIR = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx");
 const LOCAL_CONFIG_PATH = path.join(LOCAL_DIR, "config.jsonc");
@@ -49,20 +49,11 @@ function readLocalConfig() {
         return {};
     return readJsonc(LOCAL_CONFIG_PATH) || {};
 }
-/** Resolve provider config to a filesystem path */
+/** 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 "onedrive": {
-            const candidates = [
-                process.env.OneDrive && path.join(process.env.OneDrive, rel),
-                process.env.OneDriveConsumer && path.join(process.env.OneDriveConsumer, rel),
-                home && path.join(home, "OneDrive", rel),
-                home && path.join(home, "onedrive", rel),
-            ].filter(Boolean);
-            return candidates.find(p => fs.existsSync(p));
-        }
         case "google":
         case "gdrive": {
             const candidates = [
@@ -77,13 +68,6 @@ function resolveProvider(cfg) {
             }
             return candidates.filter(Boolean).find(p => fs.existsSync(p));
         }
-        case "dropbox": {
-            const candidates = [
-                home && path.join(home, "Dropbox", rel),
-                home && path.join(home, "dropbox", rel),
-            ].filter(Boolean);
-            return candidates.find(p => fs.existsSync(p));
-        }
         case "local":
             return resolvePath(rel);
         default:
@@ -119,23 +103,26 @@ function getSharedDir() {
             }
         }
     }
-    // Legacy: derive from settingsPath
-    if (config.settingsPath)
-        return path.dirname(resolvePath(config.settingsPath));
+    // Legacy settingsPath no longer used for shared dir — use loadLegacySettings() for reading only.
     return LOCAL_DIR;
 }
 /** Read a file via cloud API (when filesystem mount not available) */
 export async function cloudRead(filename) {
     if (!pendingCloudConfig)
         return null;
-    const provider = getCloudProvider(pendingCloudConfig.provider);
+    // Ensure we have a folder ID
+    if (!pendingCloudConfig.folderId) {
+        pendingCloudConfig.folderId = await gDriveFindOrCreateFolder() || undefined;
+        if (pendingCloudConfig.folderId)
+            saveFolderIdToConfig(pendingCloudConfig.folderId);
+    }
+    const provider = getCloudProvider(pendingCloudConfig.provider, pendingCloudConfig.folderId);
     if (!provider) {
         lastCloudError = `No cloud provider for ${pendingCloudConfig.provider}`;
         return null;
     }
-    const cloudPath = `${pendingCloudConfig.path}/${filename}`;
-    console.log(`  [cloud] Reading ${cloudPath} via ${pendingCloudConfig.provider} API...`);
-    const content = await provider.read(cloudPath);
+    console.log(`  [cloud] Reading ${filename} via ${pendingCloudConfig.provider} API...`);
+    const content = await provider.read(filename);
     if (content) {
         lastCloudError = null;
         // Cache locally
@@ -146,7 +133,7 @@ export async function cloudRead(filename) {
         catch { /* ignore cache write failure */ }
     }
     else {
-        lastCloudError = `Could not read ${filename} from ${pendingCloudConfig.provider} (check credentials and drive.file scope)`;
+        lastCloudError = `Could not read ${filename} from ${pendingCloudConfig.provider} (check credentials)`;
     }
     return content;
 }
@@ -154,17 +141,33 @@ export async function cloudRead(filename) {
 export async function cloudWrite(filename, content) {
     if (!pendingCloudConfig)
         return false;
-    const provider = getCloudProvider(pendingCloudConfig.provider);
+    // Ensure we have a folder ID
+    if (!pendingCloudConfig.folderId) {
+        pendingCloudConfig.folderId = await gDriveFindOrCreateFolder() || undefined;
+        if (pendingCloudConfig.folderId)
+            saveFolderIdToConfig(pendingCloudConfig.folderId);
+    }
+    const provider = getCloudProvider(pendingCloudConfig.provider, pendingCloudConfig.folderId);
     if (!provider)
         return false;
-    const cloudPath = `${pendingCloudConfig.path}/${filename}`;
-    return provider.write(cloudPath, content);
+    return provider.write(filename, content);
+}
+/** Persist the discovered folder ID back to config.jsonc so we don't search again */
+function saveFolderIdToConfig(folderId) {
+    try {
+        const config = readLocalConfig();
+        if (config.sharedDir && typeof config.sharedDir === "object" && !Array.isArray(config.sharedDir)) {
+            config.sharedDir.folderId = folderId;
+            atomicWrite(LOCAL_CONFIG_PATH, config);
+        }
+    }
+    catch { /* non-critical */ }
 }
 /** Whether cloud API fallback is active */
 export function isCloudMode() {
     return pendingCloudConfig !== null;
 }
-/** Get storage provider info for display (e.g. "OneDrive", "Google Drive", "local") */
+/** Get storage provider info for display */
 export function getStorageInfo() {
     const config = readLocalConfig();
     if (config.sharedDir) {
@@ -172,20 +175,18 @@ export function getStorageInfo() {
         for (const entry of entries) {
             const resolved = resolveSharedEntry(entry);
             if (resolved && resolved !== LOCAL_DIR) {
-                // Mounted cloud drive
-                const name = typeof entry === "string" ? "cloud" :
-                    entry.provider === "onedrive" ? "OneDrive" :
-                        (entry.provider === "gdrive" || entry.provider === "google") ? "Google Drive" :
-                            entry.provider === "dropbox" ? "Dropbox" : entry.provider;
-                return { provider: name, mode: "mount" };
+                if (typeof entry === "string") {
+                    // Legacy string path — filesystem only, no cloud label
+                    return { provider: "local", mode: "local", cloudPath: resolved };
+                }
+                const name = (entry.provider === "gdrive" || entry.provider === "google") ? "gdrive" : entry.provider;
+                return { provider: name, mode: "mount", cloudPath: entry.path };
             }
         }
-        // Not mounted but using API fallback
+        // Not mounted — using API
         if (pendingCloudConfig) {
-            const name = pendingCloudConfig.provider === "onedrive" ? "OneDrive" :
-                (pendingCloudConfig.provider === "gdrive" || pendingCloudConfig.provider === "google") ? "Google Drive" :
-                    pendingCloudConfig.provider === "dropbox" ? "Dropbox" : pendingCloudConfig.provider;
-            return { provider: name, mode: "api", cloudError: lastCloudError || undefined };
+            const name = (pendingCloudConfig.provider === "gdrive" || pendingCloudConfig.provider === "google") ? "gdrive" : pendingCloudConfig.provider;
+            return { provider: name, mode: "api", cloudPath: pendingCloudConfig.path, cloudError: lastCloudError || undefined };
         }
     }
     return { provider: "local", mode: "local" };
@@ -528,58 +529,16 @@ export function getConfigDir() {
 }
 /** Get the shared settings directory */
 export { getSharedDir };
-/** Auto-detect shared settings on OneDrive or common cloud sync locations */
-function detectSharedDir() {
-    const home = process.env.USERPROFILE || process.env.HOME || "";
-    // Scan common drive letters for Google Drive mount
-    const driveLetters = [];
-    if (process.platform === "win32") {
-        for (const letter of ["G", "H", "I", "J", "K"]) {
-            driveLetters.push(path.join(`${letter}:`, "My Drive", "home", ".mailx"));
-            driveLetters.push(path.join(`${letter}:`, "My Drive", "mailx"));
-        }
-    }
-    const candidates = [
-        // OneDrive (Windows env vars)
-        process.env.OneDrive && path.join(process.env.OneDrive, "home", ".mailx"),
-        process.env.OneDriveConsumer && path.join(process.env.OneDriveConsumer, "home", ".mailx"),
-        // OneDrive (standard paths)
-        home && path.join(home, "OneDrive", "home", ".mailx"),
-        home && path.join(home, "onedrive", "home", ".mailx"),
-        // Google Drive for Desktop — home/.mailx convention (matches OneDrive)
-        home && path.join(home, "Google Drive", "My Drive", "home", ".mailx"),
-        home && path.join(home, "Google Drive Streaming", "My Drive", "home", ".mailx"),
-        // Google Drive — also check mailx at root
-        home && path.join(home, "Google Drive", "My Drive", "mailx"),
-        home && path.join(home, "Google Drive Streaming", "My Drive", "mailx"),
-        // Google Drive mount letters (Windows)
-        ...driveLetters,
-        // Dropbox
-        home && path.join(home, "Dropbox", ".mailx"),
-        home && path.join(home, "dropbox", ".mailx"),
-    ].filter(Boolean);
-    for (const dir of candidates) {
-        if (fs.existsSync(path.join(dir, "settings.jsonc")) || fs.existsSync(path.join(dir, "accounts.jsonc"))) {
-            return dir;
-        }
-    }
-    return undefined;
-}
+// detectSharedDir() removed — cloud storage is configured via API (gdrive/onedrive),
+// not auto-detected from filesystem mounts. Setup form triggers initCloudConfig().
 /** Initialize local config if it doesn't exist */
 export function initLocalConfig(sharedDir, storePath) {
     if (fs.existsSync(LOCAL_CONFIG_PATH) && !sharedDir && !storePath)
         return;
     const existing = readLocalConfig();
-    // Auto-detect shared settings if not configured
-    let resolvedSharedDir = sharedDir || existing.sharedDir;
-    if (!resolvedSharedDir && existing.settingsPath) {
-        resolvedSharedDir = path.dirname(existing.settingsPath);
-    }
-    if (!resolvedSharedDir) {
-        resolvedSharedDir = detectSharedDir();
-        if (resolvedSharedDir)
-            console.log(`  Auto-detected shared settings: ${resolvedSharedDir}`);
-    }
+    // Use explicit sharedDir or preserve existing — no auto-detection.
+    // Cloud storage is configured when user adds an account (initCloudConfig).
+    const resolvedSharedDir = sharedDir || existing.sharedDir;
     const config = {
         ...existing,
         sharedDir: resolvedSharedDir,
@@ -588,21 +547,25 @@ export function initLocalConfig(sharedDir, storePath) {
     fs.mkdirSync(LOCAL_DIR, { recursive: true });
     atomicWrite(LOCAL_CONFIG_PATH, config);
 }
-/** Initialize config with a cloud provider (e.g. gdrive for Gmail users) */
-export function initCloudConfig(provider, cloudPath = "home/.mailx") {
+/** Initialize config with Google Drive cloud storage.
+ *  Finds or creates the app-owned "mailx" folder on Drive and stores its ID. */
+export async function initCloudConfig(provider = "gdrive") {
     const existing = readLocalConfig();
     if (existing.sharedDir)
         return; // Already configured
+    // Find or create the "mailx" folder on Google Drive
+    const folderId = await gDriveFindOrCreateFolder();
+    const sharedDir = { provider, path: "mailx", folderId: folderId || undefined };
     const config = {
         ...existing,
-        sharedDir: { provider, path: cloudPath },
+        sharedDir: sharedDir,
         storePath: existing.storePath || DEFAULT_STORE_PATH,
     };
     fs.mkdirSync(LOCAL_DIR, { recursive: true });
     atomicWrite(LOCAL_CONFIG_PATH, config);
     // Set up cloud API fallback immediately
-    pendingCloudConfig = { provider, path: cloudPath };
-    console.log(`  Initialized cloud config: ${provider} → ${cloudPath}`);
+    pendingCloudConfig = sharedDir;
+    console.log(`  Initialized cloud config: ${provider} (folder ID: ${folderId || "pending"})`);
 }
 const DEFAULT_SETTINGS = {
     accounts: [],