@bobfrankston/mailx 1.0.135 → 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.135",
+  "version": "1.0.138",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,7 +20,7 @@
     "postinstall": "node launcher/builder/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.51",
+    "@bobfrankston/iflow": "^1.0.52",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
     "@bobfrankston/rust-builder": "^0.1.3",

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-imap/index.d.ts

@@ -34,6 +34,9 @@ export declare class ImapManager extends EventEmitter {
     useNativeClient: boolean;
     /** Accounts hitting connection limits — back off until this time */
     private connectionBackoff;
+    /** Per-account connection semaphore — limits concurrent IMAP connections */
+    private connectionSemaphore;
+    private static MAX_CONNECTIONS;
     constructor(db: MailxDB);
     /** Get OAuth access token for an account (for SMTP auth) */
     getOAuthToken(accountId: string): Promise<string | null>;
@@ -51,9 +54,16 @@ export declare class ImapManager extends EventEmitter {
     createPublicClient(accountId: string): any;
     /** Track active IMAP connections for diagnostics */
     private activeConnections;
+    /** Acquire a connection slot. Resolves when a slot is available. */
+    private acquireConnection;
+    /** Release a connection slot, unblocking the next waiter. */
+    private releaseConnection;
+    /** Create client with semaphore — acquires slot, wraps logout to release it. */
+    createClientWithLimit(accountId: string): Promise<any>;
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag.
-     *  The client's logout() is wrapped to auto-decrement the connection counter. */
+     *  The client's logout() is wrapped to auto-decrement the connection counter.
+     *  Prefer createClientWithLimit() for concurrent operations — it waits for a semaphore slot. */
     private createClient;
     /** Track client logout for connection counting (called automatically by wrapped logout) */
     private trackLogout;

package/packages/mailx-imap/index.js

@@ -71,6 +71,26 @@ async function extractPreview(source) {
         return { bodyHtml: "", bodyText: "", preview: "", hasAttachments: false };
     }
 }
+/** Race a promise against a timeout. On timeout, forcibly logout the client to prevent hanging. */
+async function withTimeout(promise, ms, client, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            // Force-close the client to unblock the hanging promise
+            try {
+                client.logout?.();
+            }
+            catch { /* ignore */ }
+            reject(new Error(`${label} timeout (${ms / 1000}s)`));
+        }, ms);
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 export class ImapManager extends EventEmitter {
     configs = new Map();
     watchers = new Map();
@@ -86,6 +106,9 @@ export class ImapManager extends EventEmitter {
     useNativeClient = false;
     /** Accounts hitting connection limits — back off until this time */
     connectionBackoff = new Map();
+    /** Per-account connection semaphore — limits concurrent IMAP connections */
+    connectionSemaphore = new Map();
+    static MAX_CONNECTIONS = 2; // 1 for sync/fetch, 1 for IDLE
     constructor(db) {
         super();
         this.db = db;
@@ -186,9 +209,68 @@ export class ImapManager extends EventEmitter {
     // private legacyFallbacks = new Set<string>();
     /** Track active IMAP connections for diagnostics */
     activeConnections = new Map(); // accountId → count
+    /** Acquire a connection slot. Resolves when a slot is available. */
+    acquireConnection(accountId) {
+        let sem = this.connectionSemaphore.get(accountId);
+        if (!sem) {
+            sem = { active: 0, waiting: [] };
+            this.connectionSemaphore.set(accountId, sem);
+        }
+        if (sem.active < ImapManager.MAX_CONNECTIONS) {
+            sem.active++;
+            return Promise.resolve();
+        }
+        // At limit — queue and wait
+        return new Promise((resolve) => {
+            sem.waiting.push(() => { sem.active++; resolve(); });
+        });
+    }
+    /** Release a connection slot, unblocking the next waiter. */
+    releaseConnection(accountId) {
+        const sem = this.connectionSemaphore.get(accountId);
+        if (!sem)
+            return;
+        sem.active = Math.max(0, sem.active - 1);
+        if (sem.waiting.length > 0 && sem.active < ImapManager.MAX_CONNECTIONS) {
+            const next = sem.waiting.shift();
+            next();
+        }
+    }
+    /** Create client with semaphore — acquires slot, wraps logout to release it. */
+    async createClientWithLimit(accountId) {
+        await this.acquireConnection(accountId);
+        try {
+            const client = this.createClient(accountId);
+            // Wrap logout to also release the semaphore slot
+            const originalLogout = client.logout;
+            let released = false;
+            client.logout = async () => {
+                await originalLogout.call(client);
+                if (!released) {
+                    released = true;
+                    this.releaseConnection(accountId);
+                }
+            };
+            // Safety: release slot if client is never logged out (leak protection)
+            const leakRelease = setTimeout(() => {
+                if (!released) {
+                    released = true;
+                    this.releaseConnection(accountId);
+                }
+            }, 310000); // slightly after the 5min leak timer in createClient
+            if (leakRelease.unref)
+                leakRelease.unref();
+            return client;
+        }
+        catch (e) {
+            this.releaseConnection(accountId);
+            throw e;
+        }
+    }
     /** Create a fresh IMAP client for an account (disposable, single-use).
      *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag.
-     *  The client's logout() is wrapped to auto-decrement the connection counter. */
+     *  The client's logout() is wrapped to auto-decrement the connection counter.
+     *  Prefer createClientWithLimit() for concurrent operations — it waits for a semaphore slot. */
     createClient(accountId) {
         if (this.reauthenticating.has(accountId))
             throw new Error(`Account ${accountId} is re-authenticating`);
@@ -201,6 +283,10 @@ export class ImapManager extends EventEmitter {
         if (!config)
             throw new Error(`No config for account ${accountId}`);
         const count = (this.activeConnections.get(accountId) || 0) + 1;
+        // Hard limit: warn if exceeding max, but still allow (callers should use createClientWithLimit)
+        if (count > ImapManager.MAX_CONNECTIONS) {
+            console.warn(`  [conn] ${accountId}: WARNING exceeding limit (${count} > ${ImapManager.MAX_CONNECTIONS})`);
+        }
         this.activeConnections.set(accountId, count);
         const clientType = this.useNativeClient ? "native" : "imapflow";
         console.log(`  [conn] ${accountId}: +1 ${clientType} (${count} active)`);
@@ -537,11 +623,8 @@ export class ImapManager extends EventEmitter {
             let client = null;
             try {
                 const t0 = Date.now();
-                client = this.createClient(accountId);
-                const folders = await Promise.race([
-                    this.syncFolders(accountId, client),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("Folder list timeout (30s)")), 30000))
-                ]);
+                client = await this.createClientWithLimit(accountId);
+                const folders = await withTimeout(this.syncFolders(accountId, client), 30000, client, "Folder list");
                 console.log(`  [timing] ${accountId}: folder list ${Date.now() - t0}ms (${folders.length} folders)`);
                 // Legacy fallback removed — was doubling connections.
                 // If native client has issues, set useNativeClient=false or use --legacy-imap flag.
@@ -552,11 +635,8 @@ export class ImapManager extends EventEmitter {
                 const inbox = folders.find(f => f.specialUse === "inbox");
                 if (inbox) {
                     try {
-                        client = this.createClient(accountId);
-                        await Promise.race([
-                            this.syncFolder(accountId, inbox.id, client),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout (60s)")), 60000))
-                        ]);
+                        client = await this.createClientWithLimit(accountId);
+                        await withTimeout(this.syncFolder(accountId, inbox.id, client), 60000, client, "Inbox sync");
                         await client.logout();
                         client = null;
                     }
@@ -644,7 +724,7 @@ export class ImapManager extends EventEmitter {
             // Reuse one IMAP connection per account for all folders (avoid 87+ TLS handshakes)
             let client = null;
             try {
-                client = this.createClient(accountId);
+                client = await this.createClientWithLimit(accountId);
                 for (const folder of remaining) {
                     // Skip Trash subfolders on first sync — they're large and low priority
                     const isTrashChild = folder.path.includes("/") && folder.path.toLowerCase().startsWith("trash");
@@ -656,10 +736,7 @@ export class ImapManager extends EventEmitter {
                     // Longer timeout for folders we know are large (Trash, first sync)
                     const timeout = highestUid === 0 ? 180000 : 60000;
                     try {
-                        await Promise.race([
-                            this.syncFolder(accountId, folder.id, client),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout (${timeout / 1000}s) on ${folder.path}`)), timeout))
-                        ]);
+                        await withTimeout(this.syncFolder(accountId, folder.id, client), timeout, client, `Sync ${folder.path}`);
                     }
                     catch (e) {
                         if (e.responseText?.includes("doesn't exist")) {
@@ -673,7 +750,7 @@ export class ImapManager extends EventEmitter {
                                 await client.logout();
                             }
                             catch { /* */ }
-                            client = this.createClient(accountId);
+                            client = await this.createClientWithLimit(accountId);
                         }
                     }
                 }
@@ -706,7 +783,7 @@ export class ImapManager extends EventEmitter {
                     // Try up to 2 times with fresh clients
                     for (let attempt = 0; attempt < 2; attempt++) {
                         try {
-                            client = this.createClient(accountId);
+                            client = await this.createClientWithLimit(accountId);
                             await this.syncFolder(accountId, inbox.id, client);
                             await client.logout();
                             client = null;
@@ -750,13 +827,17 @@ export class ImapManager extends EventEmitter {
             return;
         if (this.reauthenticating.has(accountId))
             return;
+        // Skip if at connection limit — don't queue, just skip this cycle
+        const sem = this.connectionSemaphore.get(accountId);
+        if (sem && sem.active >= ImapManager.MAX_CONNECTIONS)
+            return;
         this.quickCheckRunning.add(accountId);
         let client = null;
         try {
             const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
             if (!inbox)
                 return;
-            client = this.createClient(accountId);
+            client = await this.createClientWithLimit(accountId);
             const count = await client.getMessagesCount("INBOX");
             await client.logout();
             client = null;
@@ -764,7 +845,7 @@ export class ImapManager extends EventEmitter {
             this.lastInboxCounts.set(accountId, count);
             if (count !== prev) {
                 console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
-                client = this.createClient(accountId);
+                client = await this.createClientWithLimit(accountId);
                 await this.syncFolder(accountId, inbox.id, client);
                 await client.logout();
                 client = null;
@@ -839,7 +920,7 @@ export class ImapManager extends EventEmitter {
             if (this.watchers.has(accountId))
                 continue;
             try {
-                const watchClient = this.createClient(accountId);
+                const watchClient = await this.createClientWithLimit(accountId);
                 const stop = await watchClient.watchMailbox("INBOX", (newCount) => {
                     console.log(`  [idle] ${accountId}: ${newCount} new message(s)`);
                     // Sync just INBOX for speed — full sync runs on the configured interval
@@ -877,10 +958,10 @@ export class ImapManager extends EventEmitter {
         return next;
     }
     /** Get or create a persistent client for body fetching */
-    getFetchClient(accountId) {
+    async getFetchClient(accountId) {
         let client = this.fetchClients.get(accountId);
         if (!client) {
-            client = this.createClient(accountId);
+            client = await this.createClientWithLimit(accountId);
             this.fetchClients.set(accountId, client);
         }
         return client;
@@ -904,12 +985,9 @@ export class ImapManager extends EventEmitter {
             }
             for (let attempt = 0; attempt < 2; attempt++) {
                 try {
-                    const client = this.getFetchClient(accountId);
+                    const client = await this.getFetchClient(accountId);
                     // 30s timeout — prevents hanging on stale connections
-                    const msg = await Promise.race([
-                        client.fetchMessageByUid(folder.path, uid, { source: true }),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error("Body fetch timeout (30s)")), 30000))
-                    ]);
+                    const msg = await withTimeout(client.fetchMessageByUid(folder.path, uid, { source: true }), 30000, client, "Body fetch");
                     if (!msg?.source)
                         return null;
                     const raw = Buffer.from(msg.source, "utf-8");
@@ -1359,7 +1437,7 @@ export class ImapManager extends EventEmitter {
             return;
         try {
             const outboxPath = await this.ensureOutbox(accountId);
-            const client = this.createClient(accountId);
+            const client = await this.createClientWithLimit(accountId);
             try {
                 for (const file of files) {
                     const filePath = path.join(localQueue, file);
@@ -1389,7 +1467,7 @@ export class ImapManager extends EventEmitter {
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
             return;
-        const client = this.createClient(accountId);
+        const client = await this.createClientWithLimit(accountId);
         try {
             // Get all UIDs in Outbox
             const uids = await client.getUids(outboxFolder.path);

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