@bobfrankston/mailx 1.0.138 → 1.0.139

package/bin/mailx.js

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

package/package.json

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

package/packages/mailx-api/index.js

@@ -148,7 +148,7 @@ export function createApiRouter(db, imapManager) {
             const domain = email.split("@")[1]?.toLowerCase() || "";
             const detected = await detectEmailProvider(domain);
             if (detected?.cloud) {
-                initCloudConfig(detected.cloud);
+                await initCloudConfig(detected.cloud);
             }
             // Build account config
             const account = { email, name: name || email.split("@")[0] };

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

@@ -1,7 +1,10 @@
 /**
- * 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.
+ * Cloud storage for mailx settings — Google Drive API (drive.file scope).
+ *
+ * Uses a single app-owned "mailx" folder on Drive, accessed by folder ID.
+ * The drive.file scope only sees files/folders created by this OAuth client,
+ * which prevents conflicts with existing folders of the same name.
+ * All machines using the same OAuth client ID share the same folder.
  *
  * ── Restoring removed providers ──
  * OneDrive (removed 2026-04-06): Required microsoft-credentials.json in ~/.mailx/,
@@ -13,11 +16,20 @@
  * Dropbox (removed 2026-04-06): Never implemented — placeholder only.
  *   Would need Dropbox OAuth app, token management, and Dropbox API v2 calls.
  */
+/** Find the app-owned "mailx" folder, or create it. Returns folder ID. */
+export declare function gDriveFindOrCreateFolder(): Promise<string | null>;
 export type CloudProvider = "gdrive" | "google" | "local";
 export interface CloudFile {
+    /** Read a file. For gdrive, path is just the filename (folder ID is implicit). */
     read(filePath: string): Promise<string | null>;
+    /** Write a file. For gdrive, path is just the filename. */
     write(filePath: string, content: string): Promise<boolean>;
+    /** Check if a file exists. */
     exists(filePath: string): Promise<boolean>;
 }
-export declare function getCloudProvider(provider: string): CloudFile | null;
+/**
+ * Get a cloud file provider. For gdrive, pass the folder ID.
+ * Files are stored flat in the folder (no subdirectory navigation).
+ */
+export declare function getCloudProvider(provider: string, folderId?: string): CloudFile | null;
 //# sourceMappingURL=cloud.d.ts.map

package/packages/mailx-settings/cloud.js

@@ -1,7 +1,10 @@
 /**
- * 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.
+ * Cloud storage for mailx settings — Google Drive API (drive.file scope).
+ *
+ * Uses a single app-owned "mailx" folder on Drive, accessed by folder ID.
+ * The drive.file scope only sees files/folders created by this OAuth client,
+ * which prevents conflicts with existing folders of the same name.
+ * All machines using the same OAuth client ID share the same folder.
  *
  * ── Restoring removed providers ──
  * OneDrive (removed 2026-04-06): Required microsoft-credentials.json in ~/.mailx/,
@@ -24,9 +27,7 @@ function findGoogleCredentials() {
     const local = path.join(SETTINGS_DIR, "google-credentials.json");
     if (fs.existsSync(local))
         return local;
-    // Try to find iflow's credentials via import.meta.resolve or node_modules walk
     try {
-        // Walk up from this package to find iflow in node_modules
         let dir = import.meta.dirname;
         for (let i = 0; i < 5; i++) {
             for (const name of ["iflow-credentials.json", "credentials.json"]) {
@@ -44,7 +45,10 @@ function findGoogleCredentials() {
     return null;
 }
 const GDRIVE_TOKEN_DIR = path.join(SETTINGS_DIR, "tokens", "gdrive");
+// drive.file: app can only see files it created. Safe, publishable without security audit.
+// All machines sharing the same OAuth client ID see the same files.
 const GDRIVE_SCOPES = "https://www.googleapis.com/auth/drive.file";
+const GDRIVE_FOLDER_NAME = "mailx";
 // ── Token helpers ──
 async function getGoogleDriveToken() {
     const creds = findGoogleCredentials();
@@ -52,6 +56,18 @@ async function getGoogleDriveToken() {
         console.error("  [cloud] No Google credentials found (checked ~/.mailx/google-credentials.json and iflow package)");
         return null;
     }
+    // Delete stale token if scope changed (drive → drive.file or vice versa)
+    const tokenPath = path.join(GDRIVE_TOKEN_DIR, "token.json");
+    if (fs.existsSync(tokenPath)) {
+        try {
+            const existing = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+            if (existing.scope && existing.scope !== GDRIVE_SCOPES) {
+                console.log(`  [cloud] Scope changed — re-authenticating...`);
+                fs.unlinkSync(tokenPath);
+            }
+        }
+        catch { /* ignore parse errors */ }
+    }
     try {
         const token = await authenticateOAuth(creds, {
             scope: GDRIVE_SCOPES,
@@ -67,111 +83,97 @@ async function getGoogleDriveToken() {
         return null;
     }
 }
-// ── Google Drive API ──
-async function gDriveRead(filePath) {
+// ── Google Drive API (folder-ID based) ──
+/** Find the app-owned "mailx" folder, or create it. Returns folder ID. */
+export async function gDriveFindOrCreateFolder() {
+    const token = await getGoogleDriveToken();
+    if (!token)
+        return null;
+    try {
+        // Search for existing folder (created by this OAuth client)
+        const query = `name='${GDRIVE_FOLDER_NAME}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
+        const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id,name)`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok) {
+            console.error(`  [cloud] gdrive folder search: ${res.status} ${res.statusText}`);
+            return null;
+        }
+        const data = await res.json();
+        if (data.files?.[0]) {
+            console.log(`  [cloud] Found existing '${GDRIVE_FOLDER_NAME}' folder: ${data.files[0].id}`);
+            return data.files[0].id;
+        }
+        // Create folder
+        const createRes = await fetch("https://www.googleapis.com/drive/v3/files", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ name: GDRIVE_FOLDER_NAME, mimeType: "application/vnd.google-apps.folder" }),
+        });
+        if (!createRes.ok) {
+            console.error(`  [cloud] gdrive folder create: ${createRes.status} ${createRes.statusText}`);
+            return null;
+        }
+        const created = await createRes.json();
+        console.log(`  [cloud] Created '${GDRIVE_FOLDER_NAME}' folder: ${created.id}`);
+        return created.id;
+    }
+    catch (e) {
+        console.error(`  [cloud] gdrive folder setup: ${e.message}`);
+        return null;
+    }
+}
+/** Read a file by name from a folder (by ID) */
+async function gDriveReadFromFolder(folderId, fileName) {
     const token = await getGoogleDriveToken();
     if (!token) {
-        console.error(`  [cloud] gdrive read ${filePath}: no token`);
+        console.error(`  [cloud] gdrive read ${fileName}: no token`);
         return null;
     }
     try {
-        // Parse path: "home/.mailx/settings.jsonc" → find by folder structure
-        const parts = filePath.split("/");
-        const fileName = parts.pop();
-        let parentId = null;
-        // Navigate folder structure
-        for (const folder of parts) {
-            let query = `name='${folder}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
-            if (parentId)
-                query += ` and '${parentId}' in parents`;
-            const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
-            if (!res.ok) {
-                console.error(`  [cloud] gdrive folder lookup '${folder}': ${res.status} ${res.statusText}`);
-                return null;
-            }
-            const data = await res.json();
-            if (!data.files?.[0]) {
-                console.error(`  [cloud] gdrive folder '${folder}' not found (drive.file scope can only see app-created files)`);
-                return null;
-            }
-            parentId = data.files[0].id;
-        }
-        // Find the file
-        let query = `name='${fileName}' and trashed=false`;
-        if (parentId)
-            query += ` and '${parentId}' in parents`;
-        const fileRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
+        // Find file in folder
+        const query = `name='${fileName}' and '${folderId}' in parents and trashed=false`;
+        const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
             headers: { Authorization: `Bearer ${token}` },
         });
-        if (!fileRes.ok) {
-            console.error(`  [cloud] gdrive file lookup '${fileName}': ${fileRes.status} ${fileRes.statusText}`);
+        if (!res.ok) {
+            console.error(`  [cloud] gdrive lookup '${fileName}': ${res.status}`);
             return null;
         }
-        const fileData = await fileRes.json();
-        const fileId = fileData.files?.[0]?.id;
-        if (!fileId) {
-            console.error(`  [cloud] gdrive file '${fileName}' not found in ${parts.join("/")}`);
+        const data = await res.json();
+        const fileId = data.files?.[0]?.id;
+        if (!fileId)
             return null;
-        }
         // Download content
         const contentRes = await fetch(`https://www.googleapis.com/drive/v3/files/${fileId}?alt=media`, {
             headers: { Authorization: `Bearer ${token}` },
         });
         if (!contentRes.ok) {
-            console.error(`  [cloud] gdrive download ${fileId}: ${contentRes.status} ${contentRes.statusText}`);
+            console.error(`  [cloud] gdrive download ${fileName}: ${contentRes.status}`);
             return null;
         }
         return await contentRes.text();
     }
     catch (e) {
-        console.error(`  [cloud] gdrive read ${filePath}: ${e.message}`);
+        console.error(`  [cloud] gdrive read ${fileName}: ${e.message}`);
         return null;
     }
 }
-async function gDriveWrite(filePath, content) {
+/** Write a file by name to a folder (by ID) — creates or updates */
+async function gDriveWriteToFolder(folderId, fileName, content) {
     const token = await getGoogleDriveToken();
     if (!token)
         return false;
     try {
-        const parts = filePath.split("/");
-        const fileName = parts.pop();
-        // Ensure folder structure exists
-        let parentId = null;
-        for (const folder of parts) {
-            let query = `name='${folder}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
-            if (parentId)
-                query += ` and '${parentId}' in parents`;
-            const res = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
-            const data = await res.json();
-            if (data.files?.[0]) {
-                parentId = data.files[0].id;
-            }
-            else {
-                // Create folder
-                const createRes = await fetch("https://www.googleapis.com/drive/v3/files", {
-                    method: "POST",
-                    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-                    body: JSON.stringify({ name: folder, mimeType: "application/vnd.google-apps.folder", parents: parentId ? [parentId] : [] }),
-                });
-                const created = await createRes.json();
-                parentId = created.id;
-            }
-        }
-        // Check if file exists
-        let query = `name='${fileName}' and trashed=false`;
-        if (parentId)
-            query += ` and '${parentId}' in parents`;
+        // Check if file exists in folder
+        const query = `name='${fileName}' and '${folderId}' in parents and trashed=false`;
         const findRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
             headers: { Authorization: `Bearer ${token}` },
         });
         const findData = await findRes.json();
         const existingId = findData.files?.[0]?.id;
         if (existingId) {
-            // Update existing
+            // Update existing file
             const res = await fetch(`https://www.googleapis.com/upload/drive/v3/files/${existingId}?uploadType=media`, {
                 method: "PATCH",
                 headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
@@ -180,9 +182,9 @@ async function gDriveWrite(filePath, content) {
             return res.ok;
         }
         else {
-            // Create new — multipart upload with metadata
+            // Create new file in folder
             const boundary = "mailx_boundary_" + Date.now();
-            const metadata = JSON.stringify({ name: fileName, parents: parentId ? [parentId] : [] });
+            const metadata = JSON.stringify({ name: fileName, parents: [folderId] });
             const body = `--${boundary}\r\nContent-Type: application/json\r\n\r\n${metadata}\r\n--${boundary}\r\nContent-Type: application/json\r\n\r\n${content}\r\n--${boundary}--`;
             const res = await fetch("https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart", {
                 method: "POST",
@@ -192,18 +194,27 @@ async function gDriveWrite(filePath, content) {
             return res.ok;
         }
     }
-    catch {
+    catch (e) {
+        console.error(`  [cloud] gdrive write ${fileName}: ${e.message}`);
         return false;
     }
 }
-export function getCloudProvider(provider) {
+/**
+ * Get a cloud file provider. For gdrive, pass the folder ID.
+ * Files are stored flat in the folder (no subdirectory navigation).
+ */
+export function getCloudProvider(provider, folderId) {
     switch (provider) {
         case "google":
         case "gdrive":
+            if (!folderId) {
+                console.error("  [cloud] gdrive requires a folder ID — run initCloudConfig first");
+                return null;
+            }
             return {
-                read: gDriveRead,
-                write: gDriveWrite,
-                exists: async (p) => (await gDriveRead(p)) !== null,
+                read: (fileName) => gDriveReadFromFolder(folderId, fileName),
+                write: (fileName, content) => gDriveWriteToFolder(folderId, fileName, content),
+                exists: async (fileName) => (await gDriveReadFromFolder(folderId, fileName)) !== null,
             };
         case "local":
             return {

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

@@ -90,8 +90,9 @@ export declare function getConfigDir(): string;
 export { getSharedDir };
 /** Initialize local config if it doesn't exist */
 export declare function initLocalConfig(sharedDir?: string, storePath?: string): void;
-/** Initialize config with Google Drive cloud storage */
-export declare function initCloudConfig(provider?: "gdrive", cloudPath?: string): void;
+/** Initialize config with Google Drive cloud storage.
+ *  Finds or creates the app-owned "mailx" folder on Drive and stores its ID. */
+export declare function initCloudConfig(provider?: "gdrive"): Promise<void>;
 declare const DEFAULT_SETTINGS: MailxSettings;
 /** Get historyDays for an account: per-account override > system override > shared default */
 export declare function getHistoryDays(accountId?: string): number;

package/packages/mailx-settings/index.js

@@ -18,7 +18,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
-import { getCloudProvider } from "./cloud.js";
+import { getCloudProvider, gDriveFindOrCreateFolder } from "./cloud.js";
 // ── Paths ──
 const LOCAL_DIR = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx");
 const LOCAL_CONFIG_PATH = path.join(LOCAL_DIR, "config.jsonc");
@@ -110,14 +110,19 @@ function getSharedDir() {
 export async function cloudRead(filename) {
     if (!pendingCloudConfig)
         return null;
-    const provider = getCloudProvider(pendingCloudConfig.provider);
+    // Ensure we have a folder ID
+    if (!pendingCloudConfig.folderId) {
+        pendingCloudConfig.folderId = await gDriveFindOrCreateFolder() || undefined;
+        if (pendingCloudConfig.folderId)
+            saveFolderIdToConfig(pendingCloudConfig.folderId);
+    }
+    const provider = getCloudProvider(pendingCloudConfig.provider, pendingCloudConfig.folderId);
     if (!provider) {
         lastCloudError = `No cloud provider for ${pendingCloudConfig.provider}`;
         return null;
     }
-    const cloudPath = `${pendingCloudConfig.path}/${filename}`;
-    console.log(`  [cloud] Reading ${cloudPath} via ${pendingCloudConfig.provider} API...`);
-    const content = await provider.read(cloudPath);
+    console.log(`  [cloud] Reading ${filename} via ${pendingCloudConfig.provider} API...`);
+    const content = await provider.read(filename);
     if (content) {
         lastCloudError = null;
         // Cache locally
@@ -128,7 +133,7 @@ export async function cloudRead(filename) {
         catch { /* ignore cache write failure */ }
     }
     else {
-        lastCloudError = `Could not read ${filename} from ${pendingCloudConfig.provider} (check credentials and drive.file scope)`;
+        lastCloudError = `Could not read ${filename} from ${pendingCloudConfig.provider} (check credentials)`;
     }
     return content;
 }
@@ -136,11 +141,27 @@ export async function cloudRead(filename) {
 export async function cloudWrite(filename, content) {
     if (!pendingCloudConfig)
         return false;
-    const provider = getCloudProvider(pendingCloudConfig.provider);
+    // Ensure we have a folder ID
+    if (!pendingCloudConfig.folderId) {
+        pendingCloudConfig.folderId = await gDriveFindOrCreateFolder() || undefined;
+        if (pendingCloudConfig.folderId)
+            saveFolderIdToConfig(pendingCloudConfig.folderId);
+    }
+    const provider = getCloudProvider(pendingCloudConfig.provider, pendingCloudConfig.folderId);
     if (!provider)
         return false;
-    const cloudPath = `${pendingCloudConfig.path}/${filename}`;
-    return provider.write(cloudPath, content);
+    return provider.write(filename, content);
+}
+/** Persist the discovered folder ID back to config.jsonc so we don't search again */
+function saveFolderIdToConfig(folderId) {
+    try {
+        const config = readLocalConfig();
+        if (config.sharedDir && typeof config.sharedDir === "object" && !Array.isArray(config.sharedDir)) {
+            config.sharedDir.folderId = folderId;
+            atomicWrite(LOCAL_CONFIG_PATH, config);
+        }
+    }
+    catch { /* non-critical */ }
 }
 /** Whether cloud API fallback is active */
 export function isCloudMode() {
@@ -526,21 +547,25 @@ export function initLocalConfig(sharedDir, storePath) {
     fs.mkdirSync(LOCAL_DIR, { recursive: true });
     atomicWrite(LOCAL_CONFIG_PATH, config);
 }
-/** Initialize config with Google Drive cloud storage */
-export function initCloudConfig(provider = "gdrive", cloudPath = "home/.mailx") {
+/** Initialize config with Google Drive cloud storage.
+ *  Finds or creates the app-owned "mailx" folder on Drive and stores its ID. */
+export async function initCloudConfig(provider = "gdrive") {
     const existing = readLocalConfig();
     if (existing.sharedDir)
         return; // Already configured
+    // Find or create the "mailx" folder on Google Drive
+    const folderId = await gDriveFindOrCreateFolder();
+    const sharedDir = { provider, path: "mailx", folderId: folderId || undefined };
     const config = {
         ...existing,
-        sharedDir: { provider, path: cloudPath },
+        sharedDir: sharedDir,
         storePath: existing.storePath || DEFAULT_STORE_PATH,
     };
     fs.mkdirSync(LOCAL_DIR, { recursive: true });
     atomicWrite(LOCAL_CONFIG_PATH, config);
     // Set up cloud API fallback immediately
-    pendingCloudConfig = { provider, path: cloudPath };
-    console.log(`  Initialized cloud config: ${provider} → ${cloudPath}`);
+    pendingCloudConfig = sharedDir;
+    console.log(`  Initialized cloud config: ${provider} (folder ID: ${folderId || "pending"})`);
 }
 const DEFAULT_SETTINGS = {
     accounts: [],