@bobfrankston/mailx 1.0.142 → 1.0.144

package/bin/mailx.js

@@ -18,7 +18,7 @@ import fs from "node:fs";
 import path from "node:path";
 import net from "node:net";
 import { ports } from "@bobfrankston/miscinfo";
-import { showMessageBox } from "@bobfrankston/msger";
+import { showMessageBox, showService } from "@bobfrankston/msger";
 const PORT = ports.mailx;
 const args = process.argv.slice(2);
 // Normalize: accept both -flag and --flag
@@ -488,16 +488,7 @@ async function main() {
             console.log("No mailx configuration found.");
         await runSetup();
     }
-    // Check if server is already running
-    const inUse = await isPortInUse(PORT);
-    if (inUse) {
-        const url = `http://127.0.0.1:${PORT}`;
-        if (!noBrowser)
-            launchMsger(url);
-        return;
-    }
     // Redirect console to log file — keep terminal clean
-    // Server also logs, but this catches CLI startup messages
     if (!verbose) {
         const home = process.env.USERPROFILE || process.env.HOME || ".";
         const logDir = path.join(home, ".mailx", "logs");
@@ -505,28 +496,95 @@ async function main() {
         const logDate = new Date().toISOString().slice(0, 10);
         const logPath = path.join(logDir, `mailx-${logDate}.log`);
         const logStream = fs.createWriteStream(logPath, { flags: "a" });
-        const origLog = console.log;
-        const origErr = console.error;
         console.log = (...a) => { logStream.write(a.join(" ") + "\n"); };
         console.error = (...a) => { logStream.write("ERROR " + a.join(" ") + "\n"); };
     }
-    // Start Express server in-process
-    console.log("Starting mailx server...");
-    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;
+    // --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
+    console.log("Starting mailx service...");
+    const { MailxDB } = await import("@bobfrankston/mailx-store");
+    const { ImapManager } = await import("@bobfrankston/mailx-imap");
+    const { MailxService } = await import("@bobfrankston/mailx-service");
+    const { dispatch } = await import("@bobfrankston/mailx-service/jsonrpc.js");
+    const { loadSettings, loadAccountsAsync, getConfigDir, getStorageInfo } = await import("@bobfrankston/mailx-settings");
+    let settings = loadSettings();
+    if (settings.accounts.length === 0) {
+        const cloudAccounts = await loadAccountsAsync();
+        if (cloudAccounts.length > 0) {
+            settings = { ...settings, accounts: cloudAccounts };
+            console.log(`  Loaded ${cloudAccounts.length} account(s) from cloud`);
+        }
+    }
+    const db = new MailxDB(getConfigDir());
+    const imapManager = new ImapManager(db);
+    imapManager.useNativeClient = true;
+    const svc = new MailxService(db, imapManager);
+    // Read mailxapi.js for injection into WebView
+    const mailxapiPath = path.join(import.meta.dirname, "..", "client", "lib", "mailxapi.js");
+    const mailxapiScript = fs.readFileSync(mailxapiPath, "utf-8");
+    // Open msger in service mode — file:// URL, no HTTP
+    const clientDir = path.join(import.meta.dirname, "..", "client");
+    const indexPath = path.join(clientDir, "index.html");
+    const handle = showService({
+        url: indexPath,
+        initScript: mailxapiScript,
+        size: { width: 1400, height: 900 },
+    });
+    // Handle requests from WebView → dispatch to MailxService
+    handle.onRequest(async (req) => {
+        const response = await dispatch(svc, req);
+        handle.send(response);
+    });
+    // Wire IMAP events → push to WebView
+    imapManager.on("syncProgress", (accountId, phase, progress) => {
+        handle.send({ _event: "syncProgress", type: "syncProgress", accountId, phase, progress });
+    });
+    imapManager.on("folderCountsChanged", (accountId, counts) => {
+        handle.send({ _event: "folderCountsChanged", type: "folderCountsChanged", accountId, counts });
+    });
+    imapManager.on("syncError", (accountId, error) => {
+        handle.send({ _event: "error", type: "error", message: `${accountId}: ${error}` });
+    });
+    imapManager.on("accountError", (accountId, error, hint, isOAuth) => {
+        handle.send({ _event: "accountError", type: "accountError", accountId, error, hint, isOAuth });
+    });
+    // Add accounts and start sync
+    for (const account of settings.accounts) {
+        if (!account.enabled)
+            continue;
+        try {
+            await imapManager.addAccount(account);
+            console.log(`  Account: ${account.label || account.name} (${account.id})`);
         }
-        launchMsger(url);
+        catch (e) {
+            console.error(`  Failed: ${account.id}: ${e.message}`);
+        }
+    }
+    if (settings.accounts.some(a => a.enabled)) {
+        imapManager.syncAll().catch(e => console.error(`  Sync error: ${e.message}`));
     }
-    // Keep process alive — server is running
-    await new Promise(() => { });
+    imapManager.startPeriodicSync(settings.sync.intervalMinutes);
+    imapManager.startOutboxWorker();
+    // Wait for window close, then shut down
+    await handle.closed;
+    console.log("Window closed — shutting down");
+    imapManager.stopPeriodicSync();
+    try {
+        await imapManager.shutdown();
+    }
+    catch { /* proceed */ }
+    db.close();
+    process.exit(0);
 }
 main().catch(console.error);
 //# sourceMappingURL=mailx.js.map

package/package.json

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

package/packages/mailx-service/jsonrpc.d.ts

@@ -0,0 +1,25 @@
+/**
+ * JSON-RPC dispatcher for MailxService.
+ * Maps mailxapi action names to MailxService method calls.
+ * Used by msger's bidirectional IPC (Phase 3) and can also
+ * serve as a stdio JSON-RPC interface for testing.
+ */
+type ServiceLike = Record<string, (...args: any[]) => any>;
+export interface RpcRequest {
+    _action: string;
+    _cbid: string;
+    [key: string]: any;
+}
+export interface RpcResponse {
+    _cbid: string;
+    result?: any;
+    error?: string;
+}
+export interface RpcEvent {
+    _event: string;
+    [key: string]: any;
+}
+/** Dispatch an incoming mailxapi call to the appropriate MailxService method */
+export declare function dispatch(svc: ServiceLike, req: RpcRequest): Promise<RpcResponse>;
+export {};
+//# sourceMappingURL=jsonrpc.d.ts.map

package/packages/mailx-service/jsonrpc.js

@@ -0,0 +1,105 @@
+/**
+ * JSON-RPC dispatcher for MailxService.
+ * Maps mailxapi action names to MailxService method calls.
+ * Used by msger's bidirectional IPC (Phase 3) and can also
+ * serve as a stdio JSON-RPC interface for testing.
+ */
+/** Dispatch an incoming mailxapi call to the appropriate MailxService method */
+export async function dispatch(svc, req) {
+    const { _action, _cbid, ...params } = req;
+    try {
+        const result = await dispatchAction(svc, _action, params);
+        return { _cbid, result };
+    }
+    catch (e) {
+        return { _cbid, error: e.message || String(e) };
+    }
+}
+async function dispatchAction(svc, action, p) {
+    switch (action) {
+        // Accounts
+        case "getAccounts":
+            return svc.getAccounts();
+        case "getFolders":
+            return svc.getFolders(p.accountId);
+        // Messages
+        case "getMessages":
+            return svc.getMessages(p.accountId, p.folderId, p.page, p.pageSize);
+        case "getUnifiedInbox":
+            return svc.getUnifiedInbox(p.page || 1, p.pageSize || 50);
+        case "getMessage":
+            return svc.getMessage(p.accountId, p.uid, p.allowRemote, p.folderId);
+        // Flags & actions
+        case "updateFlags":
+            await svc.updateFlags(p.accountId, p.uid, p.flags);
+            return { ok: true };
+        case "deleteMessage":
+            await svc.deleteMessage(p.accountId, p.uid);
+            return { ok: true };
+        case "deleteMessages":
+            await svc.deleteMessages(p.accountId, p.uids);
+            return { ok: true, count: p.uids.length };
+        case "undeleteMessage":
+            await svc.undeleteMessage(p.accountId, p.uid, p.folderId);
+            return { ok: true };
+        case "moveMessage":
+            await svc.moveMessage(p.accountId, p.uid, p.targetFolderId, p.targetAccountId);
+            return { ok: true };
+        case "moveMessages":
+            await svc.moveMessages(p.accountId, p.uids, p.targetFolderId);
+            return { ok: true, count: p.uids.length };
+        // Folders
+        case "markFolderRead":
+            svc.markFolderRead(p.folderId);
+            return { ok: true };
+        case "createFolder":
+            await svc.createFolder(p.accountId, p.parentPath, p.name);
+            return { ok: true };
+        case "renameFolder":
+            await svc.renameFolder(p.accountId, p.folderId, p.newName);
+            return { ok: true };
+        case "deleteFolder":
+            await svc.deleteFolder(p.accountId, p.folderId);
+            return { ok: true };
+        case "emptyFolder":
+            await svc.emptyFolder(p.accountId, p.folderId);
+            return { ok: true };
+        // Compose
+        case "sendMessage":
+            await svc.send(p);
+            return { ok: true };
+        case "saveDraft":
+            return svc.saveDraft(p.accountId, p.subject, p.bodyHtml, p.bodyText, p.to, p.cc, p.previousDraftUid, p.draftId);
+        case "deleteDraft":
+            await svc.deleteDraft(p.accountId, p.draftUid);
+            return { ok: true };
+        // Sync
+        case "syncAll":
+            await svc.syncAll();
+            return { ok: true };
+        case "getSyncPending":
+            return svc.getSyncPending();
+        // Search & contacts
+        case "searchMessages":
+            return svc.search(p.query, p.page, p.pageSize, p.scope, p.accountId, p.folderId);
+        case "searchContacts":
+            return svc.searchContacts(p.query);
+        // Settings
+        case "getSettings":
+            return svc.getSettings();
+        case "saveSettingsData":
+            svc.saveSettings(p);
+            return { ok: true };
+        case "allowRemoteContent":
+            svc.allowRemoteContent(p.type, p.value);
+            return { ok: true };
+        case "getVersion":
+            return svc.getStorageInfo();
+        // Autocomplete
+        case "autocomplete":
+            return svc.autocomplete(p);
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}
+//# sourceMappingURL=jsonrpc.js.map

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

@@ -91,7 +91,9 @@ 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.
- *  Checks for existing settings on GDrive mount first, then falls back to API folder. */
+ *  Finds or creates the app-owned "mailx" folder via Drive API and stores its ID.
+ *  No mount scanning — API only. Existing settings at other paths (e.g., home/.mailx
+ *  from Desktop sync) must be migrated manually or via config.jsonc importPath. */
 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 */

package/packages/mailx-settings/index.js

@@ -548,28 +548,14 @@ export function initLocalConfig(sharedDir, storePath) {
     atomicWrite(LOCAL_CONFIG_PATH, config);
 }
 /** Initialize config with Google Drive cloud storage.
- *  Checks for existing settings on GDrive mount first, then falls back to API folder. */
+ *  Finds or creates the app-owned "mailx" folder via Drive API and stores its ID.
+ *  No mount scanning — API only. Existing settings at other paths (e.g., home/.mailx
+ *  from Desktop sync) must be migrated manually or via config.jsonc importPath. */
 export async function initCloudConfig(provider = "gdrive") {
     const existing = readLocalConfig();
     if (existing.sharedDir)
         return; // Already configured
-    // Check if settings already exist on a GDrive mount (e.g., home/.mailx from a previous setup)
-    const home = process.env.USERPROFILE || process.env.HOME || "";
-    const mountPaths = [
-        path.join(home, "Google Drive", "My Drive", "home", ".mailx"),
-        path.join(home, "Google Drive Streaming", "My Drive", "home", ".mailx"),
-    ];
-    for (const mountPath of mountPaths) {
-        if (fs.existsSync(path.join(mountPath, "accounts.jsonc")) || fs.existsSync(path.join(mountPath, "settings.jsonc"))) {
-            console.log(`  Found existing settings on GDrive mount: ${mountPath}`);
-            const sharedDir = { provider, path: "home/.mailx" };
-            const config = { ...existing, sharedDir, storePath: existing.storePath || DEFAULT_STORE_PATH };
-            fs.mkdirSync(LOCAL_DIR, { recursive: true });
-            atomicWrite(LOCAL_CONFIG_PATH, config);
-            return;
-        }
-    }
-    // No mount — find or create the "mailx" folder via Drive API
+    // Find or create the "mailx" folder via Drive API
     const folderId = await gDriveFindOrCreateFolder();
     const sharedDir = { provider, path: "mailx", folderId: folderId || undefined };
     const config = { ...existing, sharedDir, storePath: existing.storePath || DEFAULT_STORE_PATH };