@bobfrankston/mailx 1.0.136 → 1.0.138

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.138",
   "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) {
+                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,23 @@
 /**
- * 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.
+ * Cloud storage for mailx settings — Google Drive API.
+ * Reads/writes settings files on Google Drive when no local mount is available.
  * Falls back to local cache when offline.
+ *
+ * ── 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";
+export type CloudProvider = "gdrive" | "google" | "local";
 export interface CloudFile {
     read(filePath: string): Promise<string | null>;
     write(filePath: string, content: string): Promise<boolean>;
     exists(filePath: string): Promise<boolean>;
 }
-export declare function getCloudProvider(provider: CloudProvider): CloudFile | null;
+export declare function getCloudProvider(provider: string): CloudFile | null;
 //# sourceMappingURL=cloud.d.ts.map

package/packages/mailx-settings/cloud.js

@@ -1,19 +1,23 @@
 /**
- * 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.
+ * Cloud storage for mailx settings — Google Drive API.
+ * Reads/writes settings files on Google Drive when no local mount is available.
  * Falls back to local cache when offline.
+ *
+ * ── 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
@@ -42,23 +46,6 @@ function findGoogleCredentials() {
 const GDRIVE_TOKEN_DIR = path.join(SETTINGS_DIR, "tokens", "gdrive");
 const GDRIVE_SCOPES = "https://www.googleapis.com/auth/drive.file";
 // ── 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) {
@@ -80,86 +67,7 @@ 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) {
-    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`;
-            }
-        }
-        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)
-            return null;
-        const data = await res.json();
-        return data.files?.[0]?.id || null;
-    }
-    catch {
-        return null;
-    }
-}
 async function gDriveRead(filePath) {
     const token = await getGoogleDriveToken();
     if (!token) {
@@ -290,12 +198,6 @@ async function gDriveWrite(filePath, content) {
 }
 export function getCloudProvider(provider) {
     switch (provider) {
-        case "onedrive":
-            return {
-                read: oneDriveRead,
-                write: oneDriveWrite,
-                exists: oneDriveExists,
-            };
         case "google":
         case "gdrive":
             return {
@@ -303,9 +205,6 @@ export function getCloudProvider(provider) {
                 write: gDriveWrite,
                 exists: async (p) => (await gDriveRead(p)) !== null,
             };
-        case "dropbox":
-            // TODO: Dropbox API
-            return null;
         case "local":
             return {
                 read: async (p) => { try {
@@ -324,6 +223,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,8 @@ 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 */
+export declare function initCloudConfig(provider?: "gdrive", cloudPath?: string): 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

@@ -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,9 +103,7 @@ 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) */
@@ -164,7 +146,7 @@ export async function cloudWrite(filename, content) {
 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 +154,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 +508,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,8 +526,8 @@ 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 */
+export function initCloudConfig(provider = "gdrive", cloudPath = "home/.mailx") {
     const existing = readLocalConfig();
     if (existing.sharedDir)
         return; // Already configured