@bobfrankston/mailx 1.0.40 → 1.0.42

package/bin/mailx.js

@@ -25,13 +25,16 @@ const serverMode = hasFlag("server");
 const noBrowser = hasFlag("no-browser");
 const verbose = hasFlag("verbose");
 
+const setupMode = hasFlag("setup");
+const addMode = hasFlag("add");
+
 // Validate arguments
-const knownFlags = ["server", "no-browser", "verbose", "external", "kill", "v", "version"];
+const knownFlags = ["server", "no-browser", "verbose", "external", "kill", "v", "version", "setup", "add"];
 for (const arg of args) {
     const flag = arg.replace(/^--?/, "");
     if (arg.startsWith("-") && !knownFlags.includes(flag)) {
         console.error(`Unknown option: ${arg}`);
-        console.error("Usage: mailx [-server] [-verbose] [-kill] [-v] [-no-browser] [-external]");
+        console.error("Usage: mailx [-server] [-verbose] [-kill] [-v] [-setup] [-no-browser] [-external]");
         process.exit(1);
     }
 }
@@ -125,10 +128,236 @@ function openBrowser(url) {
     });
 }
 
+function prompt(question) {
+    const readline = require("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) */
+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"]) {
+        if (fs.existsSync(path.join(mailxDir, f))) return true;
+    }
+    // Check cloud drives
+    return findCloudSettings() !== null;
+}
+
+/** Try to auto-discover mail server settings from email domain */
+async function autoDiscover(domain) {
+    // 1. Try Thunderbird ISPDB
+    try {
+        const res = await fetch(`https://autoconfig.thunderbird.net/v1.1/${domain}`, { signal: AbortSignal.timeout(5000) });
+        if (res.ok) {
+            const xml = await res.text();
+            const imap = xml.match(/<incomingServer type="imap">[\s\S]*?<hostname>(.*?)<\/hostname>[\s\S]*?<port>(\d+)<\/port>[\s\S]*?<authentication>(.*?)<\/authentication>/);
+            const smtp = xml.match(/<outgoingServer type="smtp">[\s\S]*?<hostname>(.*?)<\/hostname>[\s\S]*?<port>(\d+)<\/port>[\s\S]*?<authentication>(.*?)<\/authentication>/);
+            if (imap && smtp) {
+                return {
+                    imap: { host: imap[1], port: parseInt(imap[2]), auth: imap[3].includes("OAuth2") ? "oauth2" : "password" },
+                    smtp: { host: smtp[1], port: parseInt(smtp[2]), auth: smtp[3].includes("OAuth2") ? "oauth2" : "password" },
+                    source: "ISPDB",
+                };
+            }
+        }
+    } catch { /* timeout or not found */ }
+
+    // 2. Try DNS SRV records
+    try {
+        const dns = await import("node:dns/promises");
+        const imapSrv = await dns.resolveSrv(`_imaps._tcp.${domain}`).catch(() => null);
+        const smtpSrv = await dns.resolveSrv(`_submission._tcp.${domain}`).catch(() => null);
+        if (imapSrv?.[0] && smtpSrv?.[0]) {
+            return {
+                imap: { host: imapSrv[0].name, port: imapSrv[0].port, auth: "password" },
+                smtp: { host: smtpSrv[0].name, port: smtpSrv[0].port, auth: "password" },
+                source: "DNS SRV",
+            };
+        }
+    } catch { /* DNS failed */ }
+
+    return null;
+}
+
+/** Prompt user for account details, auto-discover where possible */
+async function promptForAccount(intro) {
+    if (intro) console.log(intro);
+    const email = await prompt("Email address (or 'skip'): ");
+    if (!email || email.toLowerCase() === "skip") return null;
+
+    const domain = email.split("@")[1]?.toLowerCase() || "";
+    const knownOAuth = ["gmail.com", "googlemail.com", "outlook.com", "hotmail.com"];
+
+    if (knownOAuth.includes(domain)) {
+        console.log(`  ${domain}: OAuth2 — no password needed. Browser will prompt for authorization.`);
+        return { email };
+    }
+
+    // Try auto-discovery
+    console.log(`  Looking up mail servers for ${domain}...`);
+    const discovered = await autoDiscover(domain);
+
+    if (discovered) {
+        console.log(`  Found via ${discovered.source}: IMAP ${discovered.imap.host}:${discovered.imap.port}, SMTP ${discovered.smtp.host}:${discovered.smtp.port}`);
+        if (discovered.imap.auth === "oauth2") {
+            console.log("  OAuth2 authentication — browser will prompt for authorization.");
+            return { email };
+        }
+        const password = await prompt("Password: ");
+        return {
+            email, password,
+            imap: { host: discovered.imap.host, port: discovered.imap.port },
+            smtp: { host: discovered.smtp.host, port: discovered.smtp.port },
+        };
+    }
+
+    // Manual fallback
+    console.log("  Could not auto-detect servers. Enter manually:");
+    const password = await prompt("Password: ");
+    const imapHost = await prompt(`IMAP host [imap.${domain}]: `) || `imap.${domain}`;
+    const smtpHost = await prompt(`SMTP host [smtp.${domain}]: `) || `smtp.${domain}`;
+    return {
+        email, password,
+        imap: { host: imapHost },
+        smtp: { host: smtpHost },
+    };
+}
+
+/** Interactive first-time setup */
+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");
+    if (!account) {
+        console.log(`\nCreate settings manually at: ${path.join(mailxDir, "settings.jsonc")}`);
+        fs.mkdirSync(mailxDir, { recursive: true });
+        return false;
+    }
+
+    const name = await prompt(`Your name (for From: header) [${account.email.split("@")[0]}]: `) || account.email.split("@")[0];
+
+    const settings = {
+        name,
+        accounts: [account],
+        ui: { theme: "system" },
+        sync: { intervalMinutes: 5, historyDays: 0 },
+    };
+
+    // Detect mounted cloud drive to save settings to
+    const mountedDrive = findMountedDrive();
+    if (mountedDrive) {
+        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));
+        // Create local config pointing to cloud
+        fs.mkdirSync(mailxDir, { recursive: true });
+        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
+        console.log(`\nSaving settings to ${mailxDir}...`);
+        fs.mkdirSync(mailxDir, { recursive: true });
+        fs.writeFileSync(path.join(mailxDir, "settings.jsonc"), JSON.stringify(settings, null, 2));
+    }
+
+    console.log("Setup complete. Starting mailx...\n");
+    return true;
+}
+
+/** 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;
+}
+
 async function main() {
     log(`Platform: ${process.platform} ${process.arch}`);
     log(`Node: ${process.version}`);
-    log(`Mode: ${serverMode ? "server" : "auto-detect"}`);
+    log(`Mode: ${serverMode ? "server" : setupMode ? "setup" : "auto-detect"}`);
+
+    // Add account to existing config
+    if (addMode) {
+        const account = await promptForAccount();
+        if (account) {
+            const home = process.env.USERPROFILE || process.env.HOME || "";
+            const mailxDir = path.join(home, ".mailx");
+            const settingsPath = path.join(mailxDir, "settings.jsonc");
+            let settings;
+            try { settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8").replace(/\r/g, "").replace(/\/\/.*/g, "")); } catch { settings = { accounts: [] }; }
+            if (!settings.accounts) settings.accounts = [];
+            settings.accounts.push(account);
+            fs.mkdirSync(mailxDir, { recursive: true });
+            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+            console.log(`Added ${account.email} to settings. Restart mailx to connect.`);
+        }
+        process.exit(0);
+    }
+
+    // Auto-detect first run — enter setup if no config exists
+    if (setupMode || (!serverMode && !hasConfig())) {
+        if (!setupMode) console.log("No mailx configuration found.");
+        await runSetup();
+    }
 
     if (serverMode) {
         // Server mode — Express + WebSocket, open browser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "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.20",
+    "@bobfrankston/iflow": "^1.0.22",
     "@bobfrankston/miscinfo": "^1.0.6",
     "@bobfrankston/oauthsupport": "^1.0.11",
     "@bobfrankston/rust-builder": "^0.1.2",

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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export type CloudProvider = "onedrive" | "gdrive" | "dropbox" | "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;
+//# sourceMappingURL=cloud.d.ts.map

package/packages/mailx-settings/cloud.js

@@ -0,0 +1,308 @@
+/**
+ * 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.
+ */
+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
+    try {
+        const iflowPkg = require.resolve("@bobfrankston/iflow/package.json");
+        const iflowDir = path.dirname(iflowPkg);
+        for (const name of ["iflow-credentials.json", "credentials.json"]) {
+            const p = path.join(iflowDir, name);
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    catch { /* iflow not installed */ }
+    return null;
+}
+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)
+        return null;
+    try {
+        const token = await authenticateOAuth(creds, {
+            scope: GDRIVE_SCOPES,
+            tokenDirectory: GDRIVE_TOKEN_DIR,
+            tokenFileName: "token.json",
+            credentialsKey: "installed",
+            includeOfflineAccess: true,
+        });
+        return token?.access_token || null;
+    }
+    catch (e) {
+        console.error(`  [cloud] Google Drive auth failed: ${e.message}`);
+        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)
+        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)
+                return null;
+            const data = await res.json();
+            if (!data.files?.[0])
+                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)`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!fileRes.ok)
+            return null;
+        const fileData = await fileRes.json();
+        const fileId = fileData.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)
+            return null;
+        return await contentRes.text();
+    }
+    catch {
+        return null;
+    }
+}
+async function gDriveWrite(filePath, 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`;
+        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
+            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" },
+                body: content,
+            });
+            return res.ok;
+        }
+        else {
+            // Create new — multipart upload with metadata
+            const boundary = "mailx_boundary_" + Date.now();
+            const metadata = JSON.stringify({ name: fileName, parents: parentId ? [parentId] : [] });
+            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",
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": `multipart/related; boundary=${boundary}` },
+                body,
+            });
+            return res.ok;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+export function getCloudProvider(provider) {
+    switch (provider) {
+        case "onedrive":
+            return {
+                read: oneDriveRead,
+                write: oneDriveWrite,
+                exists: oneDriveExists,
+            };
+        case "gdrive":
+            return {
+                read: gDriveRead,
+                write: gDriveWrite,
+                exists: async (p) => (await gDriveRead(p)) !== null,
+            };
+        case "dropbox":
+            // TODO: Dropbox API
+            return null;
+        case "local":
+            return {
+                read: async (p) => { try {
+                    return fs.readFileSync(p, "utf-8");
+                }
+                catch {
+                    return null;
+                } },
+                write: async (p, c) => { try {
+                    fs.writeFileSync(p, c);
+                    return true;
+                }
+                catch {
+                    return false;
+                } },
+                exists: async (p) => fs.existsSync(p),
+            };
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=cloud.js.map

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

@@ -18,6 +18,12 @@
 import type { MailxSettings, AccountConfig } from "@bobfrankston/mailx-types";
 declare const LOCAL_DIR: string;
 declare function getSharedDir(): string;
+/** Read a file via cloud API (when filesystem mount not available) */
+export declare function cloudRead(filename: string): Promise<string | null>;
+/** Write a file via cloud API */
+export declare function cloudWrite(filename: string, content: string): Promise<boolean>;
+/** Whether cloud API fallback is active */
+export declare function isCloudMode(): boolean;
 declare const DEFAULT_PREFERENCES: {
     ui: {
         theme: "system" | "dark" | "light";

package/packages/mailx-settings/index.js

@@ -18,6 +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";
 // ── Paths ──
 const LOCAL_DIR = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx");
 const LOCAL_CONFIG_PATH = path.join(LOCAL_DIR, "config.jsonc");
@@ -48,15 +49,100 @@ function readLocalConfig() {
         return {};
     return readJsonc(LOCAL_CONFIG_PATH) || {};
 }
+/** Resolve provider config to a filesystem path */
+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 "gdrive": {
+            const candidates = [
+                home && path.join(home, "Google Drive", "My Drive", rel),
+                home && path.join(home, "Google Drive Streaming", "My Drive", rel),
+            ];
+            // Check drive letters on Windows
+            if (process.platform === "win32") {
+                for (const letter of ["G", "H", "I", "J", "K"]) {
+                    candidates.push(path.join(`${letter}:`, "My Drive", rel));
+                }
+            }
+            return candidates.filter(Boolean).find(p => fs.existsSync(p));
+        }
+        case "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:
+            return undefined;
+    }
+}
+/** Pending cloud config for API fallback (set when mount not found) */
+let pendingCloudConfig = null;
 function getSharedDir() {
     const config = readLocalConfig();
-    if (config.sharedDir)
-        return resolvePath(config.sharedDir);
+    if (config.sharedDir) {
+        if (typeof config.sharedDir === "string")
+            return resolvePath(config.sharedDir);
+        // Object format: { provider, path }
+        const resolved = resolveProvider(config.sharedDir);
+        if (resolved)
+            return resolved;
+        // Mount not found — save config for API fallback
+        pendingCloudConfig = config.sharedDir;
+        console.log(`  ${config.sharedDir.provider} not mounted — will try API`);
+    }
     // Legacy: derive from settingsPath
     if (config.settingsPath)
         return path.dirname(resolvePath(config.settingsPath));
     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);
+    if (!provider)
+        return null;
+    const cloudPath = `${pendingCloudConfig.path}/${filename}`;
+    console.log(`  [cloud] Reading ${cloudPath} via ${pendingCloudConfig.provider} API...`);
+    const content = await provider.read(cloudPath);
+    if (content) {
+        // Cache locally
+        try {
+            fs.mkdirSync(LOCAL_DIR, { recursive: true });
+            fs.writeFileSync(path.join(LOCAL_DIR, filename), content);
+        }
+        catch { /* ignore cache write failure */ }
+    }
+    return content;
+}
+/** Write a file via cloud API */
+export async function cloudWrite(filename, content) {
+    if (!pendingCloudConfig)
+        return false;
+    const provider = getCloudProvider(pendingCloudConfig.provider);
+    if (!provider)
+        return false;
+    const cloudPath = `${pendingCloudConfig.path}/${filename}`;
+    return provider.write(cloudPath, content);
+}
+/** Whether cloud API fallback is active */
+export function isCloudMode() {
+    return pendingCloudConfig !== null;
+}
 // ── File helpers ──
 /** Read JSON or JSONC file. If exact path not found, tries .json/.jsonc variant. */
 function readJsonc(filePath) {
@@ -310,18 +396,32 @@ 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 paths (Windows)
+        // 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"),
-        // Linux/Mac — case variations
         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"),
-        // Local fallback — just use ~/.mailx itself
     ].filter(Boolean);
     for (const dir of candidates) {
         if (fs.existsSync(path.join(dir, "settings.jsonc")) || fs.existsSync(path.join(dir, "accounts.jsonc"))) {