@bobfrankston/mailx 1.0.199 → 1.0.200

package/bin/bin/postinstall.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * Post-install script: creates symlinks for workspace packages
+ * so they resolve as @bobfrankston/mailx-* in node_modules.
+ */
+import fs from "node:fs";
+import path from "node:path";
+const root = path.resolve(import.meta.dirname, "..");
+const packagesDir = path.join(root, "packages");
+const nmDir = path.join(root, "node_modules", "@bobfrankston");
+if (!fs.existsSync(packagesDir))
+    process.exit(0); // not in workspace layout
+fs.mkdirSync(nmDir, { recursive: true });
+for (const dir of fs.readdirSync(packagesDir)) {
+    const pkgPath = path.join(packagesDir, dir, "package.json");
+    if (!fs.existsSync(pkgPath))
+        continue;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    const name = pkg.name?.split("/")[1]; // e.g., "mailx-store" from "@bobfrankston/mailx-store"
+    if (!name)
+        continue;
+    const linkPath = path.join(nmDir, name);
+    const targetPath = path.join(packagesDir, dir);
+    if (fs.existsSync(linkPath))
+        continue; // already linked
+    try {
+        // Use junction on Windows (no admin needed), symlink on Unix
+        if (process.platform === "win32") {
+            fs.symlinkSync(targetPath, linkPath, "junction");
+        }
+        else {
+            fs.symlinkSync(targetPath, linkPath, "dir");
+        }
+    }
+    catch (e) {
+        console.error(`Failed to link ${name}: ${e.message}`);
+    }
+}
+//# sourceMappingURL=postinstall.js.map

package/bin/mailx.js

@@ -18,6 +18,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import os from "node:os";
 import net from "node:net";
 import { ports } from "@bobfrankston/miscinfo";
 import { showMessageBox, showService } from "@bobfrankston/msger";
@@ -25,14 +26,12 @@ 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}`); }
-const serverMode = hasFlag("server");
-const noBrowser = hasFlag("no-browser");
 const verbose = hasFlag("verbose");
 const isDaemon = hasFlag("daemon"); // internal: re-spawned detached process
 // Auto-detach: re-spawn as background process so terminal returns immediately
-// Skip for: --verbose (want console), --server (needs terminal), --daemon (already detached),
+// Skip for: --verbose (want console), --daemon (already detached),
 // and any command flags (setup, kill, test, etc.)
-if (!verbose && !serverMode && !isDaemon && !process.argv.slice(2).some(a => /^-/.test(a) && !["--no-browser"].includes(a))) {
+if (!verbose && !isDaemon && !process.argv.slice(2).some(a => /^-/.test(a) && !["--no-browser"].includes(a))) {
     const { spawn } = await import("node:child_process");
     const child = spawn(process.execPath, [...process.argv.slice(1), "--daemon"], {
         detached: true,
@@ -49,12 +48,12 @@ const rebuildMode = hasFlag("rebuild");
 const repairMode = hasFlag("repair");
 const importMode = hasFlag("import");
 // Validate arguments
-const knownFlags = ["server", "no-browser", "verbose", "external", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "native-imap", "log", "import", "email", "mail", "daemon"];
+const knownFlags = ["verbose", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "log", "import", "email", "mail", "daemon"];
 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] [-rebuild] [-v] [-setup] [-no-browser] [-external]");
+        console.error("Usage: mailx [-verbose] [-kill] [-rebuild] [-v] [-setup]");
         process.exit(1);
     }
 }
@@ -578,10 +577,62 @@ async function runTest() {
     console.log("Test complete. Check your inbox for the test message(s).");
     process.exit(0);
 }
+/** Register this client on GDrive — writes/updates clients.jsonc with device info */
+async function registerClient(settings) {
+    const { cloudRead, cloudWrite } = await import("@bobfrankston/mailx-settings");
+    // Device ID: stable per machine, stored locally
+    const deviceIdPath = path.join(os.homedir(), ".mailx", "device-id");
+    let deviceId;
+    if (fs.existsSync(deviceIdPath)) {
+        deviceId = fs.readFileSync(deviceIdPath, "utf-8").trim();
+    }
+    else {
+        deviceId = `${os.hostname()}-${Date.now().toString(36)}`;
+        fs.mkdirSync(path.dirname(deviceIdPath), { recursive: true });
+        fs.writeFileSync(deviceIdPath, deviceId);
+    }
+    // Get local IP
+    let localIp = "";
+    try {
+        const nets = os.networkInterfaces();
+        for (const addrs of Object.values(nets)) {
+            for (const addr of addrs || []) {
+                if (addr.family === "IPv4" && !addr.internal) {
+                    localIp = addr.address;
+                    break;
+                }
+            }
+            if (localIp)
+                break;
+        }
+    }
+    catch { /* ignore */ }
+    // Read existing clients.jsonc from cloud
+    let clients = {};
+    try {
+        const content = await cloudRead("clients.jsonc");
+        if (content)
+            clients = JSON.parse(content);
+    }
+    catch { /* start fresh */ }
+    // Update this device's entry
+    clients[deviceId] = {
+        hostname: os.hostname(),
+        platform: `${process.platform} ${process.arch}`,
+        accounts: settings.accounts.map((a) => a.id),
+        lastSeen: new Date().toISOString(),
+        ip: localIp,
+        version: JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8")).version,
+    };
+    // Write back
+    const ok = await cloudWrite("clients.jsonc", JSON.stringify(clients, null, 2));
+    if (ok)
+        console.log(`  [client] Registered device: ${deviceId}`);
+}
 async function main() {
     log(`Platform: ${process.platform} ${process.arch}`);
     log(`Node: ${process.version}`);
-    log(`Mode: ${serverMode ? "server" : setupMode ? "setup" : "auto"}`);
+    log(`Mode: ${setupMode ? "setup" : "auto"}`);
     // Test connectivity
     if (testMode) {
         await runTest();
@@ -632,18 +683,7 @@ async function main() {
         console.log = (...a) => { logStream.write(`${ts()} ${a.join(" ")}\n`); };
         console.error = (...a) => { logStream.write(`${ts()} ERROR ${a.join(" ")}\n`); };
     }
-    // --server mode: Express + HTTP (for dev/remote access)
-    if (serverMode) {
-        console.log("Starting mailx HTTP server...");
-        if (hasFlag("external"))
-            process.argv.push("--external");
-        await import("../packages/mailx-server/index.js");
-        if (!noBrowser)
-            launchMsger(`http://127.0.0.1:${PORT}`);
-        await new Promise(() => { }); // keep alive
-        return;
-    }
-    // Default: service mode — no TCP, IPC via msger
+    // IPC service mode — no HTTP server
     console.log("Starting mailx service...");
     const { MailxDB } = await import("@bobfrankston/mailx-store");
     const { ImapManager } = await import("@bobfrankston/mailx-imap");
@@ -667,7 +707,9 @@ async function main() {
     const clientDir = path.join(import.meta.dirname, "..", "client");
     const mailxapiPath = path.join(clientDir, "lib", "mailxapi.js");
     const mailxapiScript = fs.readFileSync(mailxapiPath, "utf-8");
+    const rootPkgVersion = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8")).version;
     const handle = showService({
+        title: `mailx v${rootPkgVersion}`,
         url: "index.html",
         contentDir: clientDir,
         initScript: mailxapiScript,
@@ -680,6 +722,11 @@ async function main() {
     const rootPkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8"));
     handle.onRequest(async (req) => {
         if (!req._action) {
+            // msger sends {"button":"OK","closed":true} on navigation — ignore it, don't exit
+            if (req.closed || req.button) {
+                console.log(`[ipc] ← ignored close signal during navigation: ${JSON.stringify(req).substring(0, 100)}`);
+                return;
+            }
             console.log(`[ipc] ← ignored (no _action): ${JSON.stringify(req).substring(0, 100)}`);
             return;
         }
@@ -743,6 +790,8 @@ async function main() {
             console.error(`  Failed: ${account.id}: ${e.message}`);
         }
     }
+    // Register this client device on GDrive (fire-and-forget)
+    registerClient(settings).catch(() => { });
     // Start sync in background — don't block
     if (settings.accounts.some(a => a.enabled)) {
         imapManager.syncAll().catch(e => console.error(`  Sync error: ${e.message}`));

package/bin/packages/mailx-settings/cloud.js

@@ -0,0 +1,243 @@
+/**
+ * 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/,
+ *   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 ──
+// 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 {
+        let dir = import.meta.dirname;
+        for (let i = 0; i < 5; i++) {
+            for (const pkg of ["iflow-direct", "iflow"]) {
+                for (const name of ["iflow-credentials.json"]) {
+                    const p = path.join(dir, "node_modules", "@bobfrankston", pkg, name);
+                    if (fs.existsSync(p))
+                        return p;
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { /* iflow not installed */ }
+    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();
+    if (!creds) {
+        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,
+            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;
+    }
+}
+// ── 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 ${fileName}: no token`);
+        return null;
+    }
+    try {
+        // 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 (!res.ok) {
+            console.error(`  [cloud] gdrive lookup '${fileName}': ${res.status}`);
+            return null;
+        }
+        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 ${fileName}: ${contentRes.status}`);
+            return null;
+        }
+        return await contentRes.text();
+    }
+    catch (e) {
+        console.error(`  [cloud] gdrive read ${fileName}: ${e.message}`);
+        return null;
+    }
+}
+/** 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 {
+        // 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 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" },
+                body: content,
+            });
+            return res.ok;
+        }
+        else {
+            // Create new file in folder
+            const boundary = "mailx_boundary_" + Date.now();
+            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",
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": `multipart/related; boundary=${boundary}` },
+                body,
+            });
+            return res.ok;
+        }
+    }
+    catch (e) {
+        console.error(`  [cloud] gdrive write ${fileName}: ${e.message}`);
+        return false;
+    }
+}
+/**
+ * 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: (fileName) => gDriveReadFromFolder(folderId, fileName),
+                write: (fileName, content) => gDriveWriteToFolder(folderId, fileName, content),
+                exists: async (fileName) => (await gDriveReadFromFolder(folderId, fileName)) !== 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:
+            console.error(`  [cloud] Provider "${provider}" not supported — only gdrive is available`);
+            return null;
+    }
+}
+//# sourceMappingURL=cloud.js.map