@bobfrankston/mailx 1.0.292 → 1.0.294

package/package.json

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

package/packages/mailx-settings/cloud.js

@@ -47,13 +47,17 @@ 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";
-/** Default folder name when config.path isn't set. The actual folder name
- *  is taken from pendingCloudConfig.path or readLocalConfig().sharedDir.path
- *  so each user can use their own convention (e.g. "home/.mailx"). */
-const GDRIVE_FOLDER_NAME_DEFAULT = "mailx";
+// drive: full access so we can find pre-existing folders like "home/.mailx"
+// that weren't created by this OAuth client. drive.file was safer but couldn't
+// discover folders created manually or by other tools — which broke first-run
+// setup when the user's convention is a nested path.
+// The Gmail scope is already mail.google.com (full email), so this isn't a
+// bigger privacy ask. Token cache at tokens/gdrive/ will re-auth on scope change.
+const GDRIVE_SCOPES = "https://www.googleapis.com/auth/drive";
+/** Paths to try when no config.path is set (fresh install). Order matters:
+ *  "home/.mailx" is the user convention for shared family settings; "mailx"
+ *  is the auto-created default. First one that exists on GDrive wins. */
+const GDRIVE_PATH_SEARCH_ORDER = ["home/.mailx", "mailx"];
 // ── Token helpers ──
 async function getGoogleDriveToken() {
     const creds = findGoogleCredentials();
@@ -102,6 +106,55 @@ async function getGoogleDriveToken() {
     }
 }
 // ── Google Drive API (folder-ID based) ──
+/** Walk a nested folder path on GDrive ("home/.mailx" → find "home", find
+ *  ".mailx" inside it). Returns the leaf folder ID, or null if any segment is
+ *  missing. When `create` is true, creates the LAST segment if missing (won't
+ *  create intermediate segments — that's a user error). */
+async function walkGDrivePath(token, segments, create) {
+    const fullPath = segments.join("/");
+    let parentId;
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const found = await gDriveFindFolder(token, seg, parentId);
+        if (found) {
+            console.log(`  [cloud] walk '${fullPath}': '${seg}' → ${found}${parentId ? ` (in ${parentId})` : ""}`);
+            parentId = found;
+        }
+        else if (create && i === segments.length - 1) {
+            const body = { name: seg, mimeType: "application/vnd.google-apps.folder" };
+            if (parentId)
+                body.parents = [parentId];
+            const res = await fetch("https://www.googleapis.com/drive/v3/files", {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                return null;
+            const created = await res.json();
+            parentId = created.id;
+        }
+        else {
+            return null;
+        }
+    }
+    return parentId || null;
+}
+/** Resolve a folder ID back to its name (for diagnostic logging). */
+async function gDriveGetFolderName(token, folderId) {
+    try {
+        const res = await fetch(`https://www.googleapis.com/drive/v3/files/${folderId}?fields=name,parents`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.name || null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Find a single folder by name, optionally inside a parent. */
 async function gDriveFindFolder(token, name, parentId) {
     let query = `name='${name}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
@@ -135,52 +188,31 @@ export async function gDriveFindOrCreateFolder() {
         }
     }
     catch { /* ignore */ }
-    const cfgPath = (typeof cfgEntry === "object" && cfgEntry?.path) ? cfgEntry.path : GDRIVE_FOLDER_NAME_DEFAULT;
-    const segments = cfgPath.split(/[/\\]/).filter(Boolean);
+    // Build search list: configured path first, then common conventions
+    const configuredPath = (typeof cfgEntry === "object" && cfgEntry?.path) ? cfgEntry.path : null;
+    const pathsToTry = configuredPath
+        ? [configuredPath]
+        : GDRIVE_PATH_SEARCH_ORDER;
     try {
-        // Walk nested path segments: "home/.mailx" → find "home", then ".mailx" inside it
-        let parentId;
-        for (let i = 0; i < segments.length; i++) {
-            const seg = segments[i];
-            const found = await gDriveFindFolder(token, seg, parentId);
-            if (found) {
-                console.log(`  [cloud] Found folder '${seg}': ${found}${parentId ? ` (in ${parentId})` : ""}`);
-                parentId = found;
-            }
-            else if (i === segments.length - 1) {
-                // Last segment missing — create it (don't create intermediate folders)
-                const body = { name: seg, mimeType: "application/vnd.google-apps.folder" };
-                if (parentId)
-                    body.parents = [parentId];
-                const createRes = await fetch("https://www.googleapis.com/drive/v3/files", {
-                    method: "POST",
-                    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-                    body: JSON.stringify(body),
-                });
-                if (!createRes.ok) {
-                    console.error(`  [cloud] gdrive folder create '${seg}': ${createRes.status}`);
-                    return null;
-                }
-                const created = await createRes.json();
-                console.log(`  [cloud] Created '${seg}' folder: ${created.id}`);
-                parentId = created.id;
-            }
-            else {
-                // Intermediate segment missing — can't create the whole tree
-                console.error(`  [cloud] gdrive path '${cfgPath}': intermediate folder '${seg}' not found`);
-                // Fall back to flat search for the leaf name
-                const leafId = await gDriveFindFolder(token, segments[segments.length - 1]);
-                if (leafId) {
-                    console.log(`  [cloud] Fallback: found '${segments[segments.length - 1]}' at root: ${leafId}`);
-                    return leafId;
-                }
-                return null;
+        for (const tryPath of pathsToTry) {
+            console.log(`  [cloud] Trying GDrive path: '${tryPath}'`);
+            const segments = tryPath.split(/[/\\]/).filter(Boolean);
+            const folderId = await walkGDrivePath(token, segments, false);
+            if (folderId) {
+                // Resolve folder ID back to name for verification
+                const name = await gDriveGetFolderName(token, folderId);
+                console.log(`  [cloud] Found existing '${tryPath}' → folder '${name || "?"}' (${folderId})`);
+                return folderId;
             }
+            console.log(`  [cloud] Path '${tryPath}' not found on GDrive`);
         }
-        if (parentId)
-            return parentId;
-        // Shouldn't reach here, but safety
-        return null;
+        // None found — create the last (simplest) path
+        const createPath = configuredPath || GDRIVE_PATH_SEARCH_ORDER[GDRIVE_PATH_SEARCH_ORDER.length - 1];
+        const segments = createPath.split(/[/\\]/).filter(Boolean);
+        const created = await walkGDrivePath(token, segments, true);
+        if (created)
+            console.log(`  [cloud] Created '${createPath}' folder: ${created}`);
+        return created;
     }
     catch (e) {
         console.error(`  [cloud] gdrive folder setup: ${e.message}`);

package/packages/mailx-settings/index.js

@@ -656,9 +656,14 @@ export async function initCloudConfig(provider = "gdrive") {
     const existing = readLocalConfig();
     if (existing.sharedDir)
         return; // Already configured
-    // Find or create the "mailx" folder via Drive API
+    // Find or create the settings folder via Drive API — tries "home/.mailx"
+    // first (family convention), then "mailx" (default). The found path gets
+    // saved so future lookups don't re-scan.
     const folderId = await gDriveFindOrCreateFolder();
-    const sharedDir = { provider, path: "mailx", folderId: folderId || undefined };
+    // Detect which path was actually found by reading back from the API
+    // (gDriveFindOrCreateFolder logs it). For now use "mailx" as default
+    // label — the folderId is what matters for subsequent reads/writes.
+    const sharedDir = { provider, path: "home/.mailx", folderId: folderId || undefined };
     const config = { ...existing, sharedDir, storePath: existing.storePath || DEFAULT_STORE_PATH };
     fs.mkdirSync(LOCAL_DIR, { recursive: true });
     atomicWrite(LOCAL_CONFIG_PATH, config);