@bobfrankston/mailx 1.0.12 → 1.0.14

package/packages/mailx-core/ipc.d.ts

@@ -0,0 +1,13 @@
+/**
+ * IPC protocol — stdin/stdout JSON lines for Rust↔Node communication.
+ * Rust launcher sends JSON requests, Node dispatches to core functions,
+ * sends JSON responses back. Events pushed to stdout as well.
+ *
+ * Protocol:
+ *   Request:  { "_action": "getMessages", "_cbid": "5", "accountId": "bobma", ... }
+ *   Response: { "_type": "response", "_cbid": "5", "result": { ... } }
+ *   Error:    { "_type": "error", "_cbid": "5", "error": "message" }
+ *   Event:    { "_type": "event", "data": { "type": "folderCountsChanged", ... } }
+ */
+export declare function startIPC(): Promise<void>;
+//# sourceMappingURL=ipc.d.ts.map

package/packages/mailx-core/ipc.js

@@ -0,0 +1,56 @@
+/**
+ * IPC protocol — stdin/stdout JSON lines for Rust↔Node communication.
+ * Rust launcher sends JSON requests, Node dispatches to core functions,
+ * sends JSON responses back. Events pushed to stdout as well.
+ *
+ * Protocol:
+ *   Request:  { "_action": "getMessages", "_cbid": "5", "accountId": "bobma", ... }
+ *   Response: { "_type": "response", "_cbid": "5", "result": { ... } }
+ *   Error:    { "_type": "error", "_cbid": "5", "error": "message" }
+ *   Event:    { "_type": "event", "data": { "type": "folderCountsChanged", ... } }
+ */
+import * as readline from "node:readline";
+import { dispatch, initialize, onEvent } from "./index.js";
+export async function startIPC() {
+    // Initialize core
+    await initialize();
+    // Push events to stdout
+    onEvent((event) => {
+        const line = JSON.stringify({ _type: "event", data: event });
+        process.stdout.write(line + "\n");
+    });
+    // Read JSON lines from stdin
+    const rl = readline.createInterface({ input: process.stdin, terminal: false });
+    rl.on("line", async (line) => {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return; // Skip malformed JSON
+        }
+        const { _action, _cbid, ...params } = msg;
+        if (!_action || !_cbid)
+            return;
+        try {
+            const result = await dispatch(_action, params);
+            process.stdout.write(JSON.stringify({ _type: "response", _cbid, result }) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ _type: "error", _cbid, error: e.message }) + "\n");
+        }
+    });
+    rl.on("close", () => {
+        console.error("IPC stdin closed, shutting down");
+        process.exit(0);
+    });
+    console.error("IPC ready");
+}
+// If run directly, start IPC mode
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("ipc.js")) {
+    startIPC().catch(e => {
+        console.error(`IPC startup error: ${e.message}`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=ipc.js.map

package/packages/mailx-core/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@bobfrankston/mailx-core",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@bobfrankston/mailx-types": "file:../mailx-types",
+    "@bobfrankston/mailx-store": "file:../mailx-store",
+    "@bobfrankston/mailx-imap": "file:../mailx-imap",
+    "@bobfrankston/mailx-settings": "file:../mailx-settings",
+    "mailparser": "^3.7.2"
+  }
+}

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

@@ -28,6 +28,10 @@ export declare class ImapManager extends EventEmitter {
     private syncing;
     private inboxSyncing;
     constructor(db: MailxDB);
+    /** Get OAuth access token for an account (for SMTP auth) */
+    getOAuthToken(accountId: string): Promise<string | null>;
+    /** Search messages on the IMAP server — returns matching UIDs */
+    searchOnServer(accountId: string, mailboxPath: string, criteria: any): Promise<number[]>;
     /** Create a fresh ImapClient for an account (disposable, single-use) */
     private createClient;
     /** Register an account */
@@ -59,6 +63,8 @@ export declare class ImapManager extends EventEmitter {
     trashMessage(accountId: string, folderId: number, uid: number): Promise<void>;
     /** Move a message between folders — local-first, queues IMAP sync */
     moveMessage(accountId: string, uid: number, fromFolderId: number, toFolderId: number): Promise<void>;
+    /** Move message across accounts using iflow's moveMessageToServer */
+    moveMessageCrossAccount(fromAccountId: string, uid: number, fromFolderId: number, toAccountId: string, toFolderId: number): Promise<void>;
     /** Undelete — move from Trash back to original folder */
     undeleteMessage(accountId: string, uid: number, originalFolderId: number): Promise<void>;
     /** Update flags — local-first, queues IMAP sync */
@@ -88,7 +94,7 @@ export declare class ImapManager extends EventEmitter {
     private processLocalQueue;
     /** Process Outbox — send pending messages with flag-based interlock */
     processOutbox(accountId: string): Promise<void>;
-    /** Start background Outbox worker — checks every 10 seconds */
+    /** Start background Outbox worker — runs immediately then every 10 seconds */
     startOutboxWorker(): void;
     /** Stop Outbox worker */
     stopOutboxWorker(): void;

package/packages/mailx-imap/index.js

@@ -55,6 +55,26 @@ export class ImapManager extends EventEmitter {
         const storePath = getStorePath();
         this.bodyStore = new FileMessageStore(storePath);
     }
+    /** Get OAuth access token for an account (for SMTP auth) */
+    async getOAuthToken(accountId) {
+        const config = this.configs.get(accountId);
+        if (!config || !config.tokenProvider)
+            return null;
+        return config.tokenProvider();
+    }
+    /** Search messages on the IMAP server — returns matching UIDs */
+    async searchOnServer(accountId, mailboxPath, criteria) {
+        const client = this.createClient(accountId);
+        try {
+            return await client.searchMessages(mailboxPath, criteria);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
     /** Create a fresh ImapClient for an account (disposable, single-use) */
     createClient(accountId) {
         const config = this.configs.get(accountId);
@@ -106,12 +126,7 @@ export class ImapManager extends EventEmitter {
             this.db.upsertFolder(accountId, folder.path, folder.name || folder.path.split(folder.delimiter || "/").pop() || folder.path, specialUse, folder.delimiter || "/");
         }
         this.emit("syncProgress", accountId, "folders", 100);
-        const dbFolders = this.db.getFolders(accountId);
-        // Register folder names for human-readable store paths
-        for (const f of dbFolders) {
-            this.bodyStore.registerFolder(f.id, f.path);
-        }
-        return dbFolders;
+        return this.db.getFolders(accountId);
     }
     /** Sync messages for a specific folder */
     async syncFolder(accountId, folderId, client) {
@@ -271,8 +286,6 @@ export class ImapManager extends EventEmitter {
                 const folders = await this.syncFolders(accountId, client);
                 await client.logout();
                 client = null;
-                // Fresh client for message sync (getFolderList corrupts imapflow state)
-                client = this.createClient(accountId);
                 // INBOX first so it's available fastest
                 folders.sort((a, b) => {
                     if (a.specialUse === "inbox")
@@ -281,11 +294,22 @@ export class ImapManager extends EventEmitter {
                         return 1;
                     return 0;
                 });
+                // Fresh client per folder — IMAP connections drop mid-sync on large accounts
                 for (const folder of folders) {
                     try {
+                        client = this.createClient(accountId);
                         await this.syncFolder(accountId, folder.id, client);
+                        await client.logout();
+                        client = null;
                     }
                     catch (e) {
+                        if (client) {
+                            try {
+                                await client.logout();
+                            }
+                            catch { /* ignore */ }
+                            client = null;
+                        }
                         if (e.responseText?.includes("doesn't exist")) {
                             console.log(`  Removing non-existent folder: ${folder.path}`);
                             this.db.deleteFolder(folder.id);
@@ -295,8 +319,6 @@ export class ImapManager extends EventEmitter {
                         }
                     }
                 }
-                await client.logout();
-                client = null;
                 this.emit("syncComplete", accountId);
             }
             catch (e) {
@@ -493,6 +515,38 @@ export class ImapManager extends EventEmitter {
         // Try immediate sync
         this.processSyncActions(accountId).catch(() => { });
     }
+    /** Move message across accounts using iflow's moveMessageToServer */
+    async moveMessageCrossAccount(fromAccountId, uid, fromFolderId, toAccountId, toFolderId) {
+        const fromFolders = this.db.getFolders(fromAccountId);
+        const fromFolder = fromFolders.find(f => f.id === fromFolderId);
+        if (!fromFolder)
+            throw new Error(`Source folder ${fromFolderId} not found`);
+        const toFolders = this.db.getFolders(toAccountId);
+        const toFolder = toFolders.find(f => f.id === toFolderId);
+        if (!toFolder)
+            throw new Error(`Target folder ${toFolderId} not found`);
+        const sourceClient = this.createClient(fromAccountId);
+        const targetClient = this.createClient(toAccountId);
+        try {
+            const msg = await sourceClient.fetchMessageByUid(fromFolder.path, uid, { source: true });
+            if (!msg)
+                throw new Error(`Message UID ${uid} not found in ${fromFolder.path}`);
+            await sourceClient.moveMessageToServer(msg, fromFolder.path, targetClient, toFolder.path);
+            // Remove from local DB
+            this.db.deleteMessage(fromAccountId, uid);
+            console.log(`  Cross-account move: ${fromAccountId}/${fromFolder.path} UID ${uid} → ${toAccountId}/${toFolder.path}`);
+        }
+        finally {
+            try {
+                await sourceClient.logout();
+            }
+            catch { /* ignore */ }
+            try {
+                await targetClient.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
     /** Undelete — move from Trash back to original folder */
     async undeleteMessage(accountId, uid, originalFolderId) {
         const trash = this.findFolder(accountId, "trash");
@@ -817,13 +871,21 @@ export class ImapManager extends EventEmitter {
                 }
                 // Send via SMTP
                 try {
+                    let smtpAuth;
+                    if (account.smtp.auth === "password") {
+                        smtpAuth = { user: account.smtp.user, pass: account.smtp.password };
+                    }
+                    else if (account.smtp.auth === "oauth2") {
+                        const accessToken = await this.getOAuthToken(accountId);
+                        if (!accessToken)
+                            throw new Error("OAuth token not available — re-authenticate");
+                        smtpAuth = { type: "OAuth2", user: account.smtp.user, accessToken };
+                    }
                     const transport = createTransport({
                         host: account.smtp.host,
                         port: account.smtp.port,
                         secure: account.smtp.port === 465,
-                        auth: account.smtp.auth === "password"
-                            ? { user: account.smtp.user, pass: account.smtp.password }
-                            : undefined,
+                        auth: smtpAuth,
                         tls: { rejectUnauthorized: false },
                     });
                     // Parse recipients from raw message headers for SMTP envelope
@@ -874,10 +936,23 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
-    /** Start background Outbox worker — checks every 10 seconds */
+    /** Start background Outbox worker — runs immediately then every 10 seconds */
     startOutboxWorker() {
         if (this.outboxInterval)
             return;
+        // Run once immediately on startup
+        const processAll = async () => {
+            for (const [accountId] of this.configs) {
+                try {
+                    await this.processLocalQueue(accountId);
+                    await this.processOutbox(accountId);
+                }
+                catch (e) {
+                    console.error(`  [outbox] Error for ${accountId}: ${e.message}`);
+                }
+            }
+        };
+        setTimeout(() => processAll(), 3000); // 3s after startup (let connections settle)
         this.outboxInterval = setInterval(async () => {
             for (const [accountId] of this.configs) {
                 try {

package/packages/mailx-server/index.js

@@ -11,10 +11,10 @@ import { ImapManager } from "@bobfrankston/mailx-imap";
 import { createApiRouter } from "@bobfrankston/mailx-api";
 import { loadSettings, getConfigDir, initLocalConfig } from "@bobfrankston/mailx-settings";
 import { ports } from "@bobfrankston/miscinfo";
-import { InitServerAsync, InitServerOptions } from "@bobfrankston/certsupport";
+import { createServer } from "node:http";
 const PORT = ports.mailx;
 // ── File logging ──
-const logDir = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx");
+const logDir = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx", "logs");
 fs.mkdirSync(logDir, { recursive: true });
 // Rotate: delete logs older than 7 days
 try {
@@ -53,7 +53,19 @@ const db = new MailxDB(dbDir);
 const imapManager = new ImapManager(db);
 // ── Express App ──
 const app = express();
-app.use(express.json());
+app.use(express.json({ limit: "Infinity" }));
+// Request logging
+app.use((req, res, next) => {
+    const start = Date.now();
+    res.on("finish", () => {
+        const ms = Date.now() - start;
+        // Skip noisy polling endpoints
+        if (req.path === "/api/sync/pending")
+            return;
+        console.log(`  ${req.method} ${req.path} ${res.statusCode} ${ms}ms`);
+    });
+    next();
+});
 // Serve client static files
 const clientDir = path.join(import.meta.dirname, "..", "..", "client");
 const rootDir = path.join(import.meta.dirname, "..", "..");
@@ -97,15 +109,14 @@ ${accountInfo.map((a) => `<tr><td>${a.name}</td><td>${a.folders}</td><td>${a.inb
 <p style="margin-top:2rem;font-size:0.8rem"><a href="/">Open mailx</a> | Auto-refreshes every 10s</p>
 </body></html>`);
 });
-// Dev: restart server + reload clients
+// Restart server + reload clients
 app.post("/api/restart", (req, res) => {
     res.json({ ok: true });
     broadcast({ type: "reload" });
-    // Touch the server file to trigger node --watch restart
-    const serverFile = path.join(import.meta.dirname, "index.js");
-    setTimeout(() => {
-        const now = new Date();
-        fs.utimesSync(serverFile, now, now);
+    // Graceful shutdown — node --watch will auto-restart
+    setTimeout(async () => {
+        console.log("  Restart requested via API");
+        await shutdown();
     }, 500);
 });
 // SPA fallback
@@ -113,8 +124,13 @@ app.get("*", (req, res) => {
     if (!req.path.startsWith("/api"))
         res.sendFile(path.join(clientDir, "index.html"));
 });
-// ── HTTPS Server (certsupport with SNI) ──
-const certspath = path.join(import.meta.dirname, "certs");
+// JSON error handler — all errors return JSON, never HTML
+app.use((err, _req, res, _next) => {
+    console.error(`ERROR ${err.message}`);
+    const status = err.status || err.statusCode || 500;
+    res.status(status).json({ error: err.message || "Internal server error" });
+});
+// ── HTTP Server ──
 let server;
 let wss;
 const clients = new Set();
@@ -147,19 +163,19 @@ async function start() {
     const seeded = db.seedContactsFromMessages();
     if (seeded > 0)
         console.log(`  Seeded ${seeded} contacts`);
-    // Search index — only rebuild if empty (new DB or after reset)
-    try {
-        const ftsCount = db.db.prepare("SELECT COUNT(*) as cnt FROM messages_fts").get();
-        if (!ftsCount?.cnt) {
+    // Search index — rebuild in background after server starts (non-blocking)
+    setTimeout(() => {
+        let ftsCount = 0;
+        try {
+            ftsCount = db.db.prepare("SELECT COUNT(*) as cnt FROM messages_fts").get()?.cnt || 0;
+        }
+        catch { /* */ }
+        if (ftsCount === 0) {
             const indexed = db.rebuildSearchIndex();
-            console.log(`  Search index built: ${indexed} messages`);
+            if (indexed > 0)
+                console.log(`  Search index: ${indexed} messages`);
         }
-    }
-    catch {
-        // FTS table might not exist yet
-        const indexed = db.rebuildSearchIndex();
-        console.log(`  Search index built: ${indexed} messages`);
-    }
+    }, 5000);
     // Add configured accounts
     for (const account of settings.accounts) {
         if (!account.enabled)
@@ -191,17 +207,12 @@ async function start() {
     imapManager.startOutboxWorker();
     // Start server — localhost only by default, --external for network access
     const externalAccess = process.argv.includes("--external");
-    const opts = new InitServerOptions({
-        port: PORT,
-        hostname: externalAccess ? undefined : "127.0.0.1",
-        app,
-        certspath,
-        msger: (msg) => console.log(`  [cert] ${msg}`),
-    });
-    server = await InitServerAsync(opts);
+    const hostname = externalAccess ? "0.0.0.0" : "127.0.0.1";
+    server = createServer(app);
     wss = new WebSocketServer({ server });
     wireWebSocket();
-    console.log(`mailx server running on port ${PORT} (http+https)`);
+    await new Promise((resolve) => server.listen(PORT, hostname, resolve));
+    console.log(`mailx server running on http://${hostname}:${PORT}`);
 }
 // ── Graceful Shutdown ──
 async function shutdown() {

package/packages/mailx-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-server",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -14,7 +14,6 @@
     "@bobfrankston/mailx-imap": "file:../mailx-imap",
     "@bobfrankston/mailx-api": "file:../mailx-api",
     "@bobfrankston/mailx-settings": "file:../mailx-settings",
-    "@bobfrankston/certsupport": "file:../../../../projects/nodejs/certsupport",
     "express": "^4.21.0",
     "ws": "^8.18.0"
   },

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

@@ -8,7 +8,7 @@
  *   allowlist.jsonc   — remote content allow-list
  *
  * Local overrides (~/.mailx/):
- *   config.json       — pointer to shared dir + local-only settings (storePath, historyDays)
+ *   config.jsonc      — pointer to shared dir + local-only settings (storePath, historyDays)
  *   accounts.jsonc    — cached copy, fallback when shared unavailable
  *   preferences.jsonc — local overrides merged on top of shared
  *   allowlist.jsonc   — cached copy

package/packages/mailx-settings/index.js

@@ -8,7 +8,7 @@
  *   allowlist.jsonc   — remote content allow-list
  *
  * Local overrides (~/.mailx/):
- *   config.json       — pointer to shared dir + local-only settings (storePath, historyDays)
+ *   config.jsonc      — pointer to shared dir + local-only settings (storePath, historyDays)
  *   accounts.jsonc    — cached copy, fallback when shared unavailable
  *   preferences.jsonc — local overrides merged on top of shared
  *   allowlist.jsonc   — cached copy
@@ -20,17 +20,17 @@ import * as path from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
 // ── Paths ──
 const LOCAL_DIR = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx");
-const LOCAL_CONFIG_PATH = path.join(LOCAL_DIR, "config.json");
+const LOCAL_CONFIG_PATH = path.join(LOCAL_DIR, "config.jsonc");
+const LEGACY_CONFIG_PATH = path.join(LOCAL_DIR, "config.json");
 const DEFAULT_STORE_PATH = path.join(LOCAL_DIR, "mailxstore");
 function readLocalConfig() {
-    if (!fs.existsSync(LOCAL_CONFIG_PATH))
-        return {};
-    try {
-        return JSON.parse(fs.readFileSync(LOCAL_CONFIG_PATH, "utf-8"));
+    // Migrate config.json → config.jsonc
+    if (!fs.existsSync(LOCAL_CONFIG_PATH) && fs.existsSync(LEGACY_CONFIG_PATH)) {
+        fs.renameSync(LEGACY_CONFIG_PATH, LOCAL_CONFIG_PATH);
     }
-    catch {
+    if (!fs.existsSync(LOCAL_CONFIG_PATH))
         return {};
-    }
+    return readJsonc(LOCAL_CONFIG_PATH) || {};
 }
 function getSharedDir() {
     const config = readLocalConfig();
@@ -42,14 +42,23 @@ function getSharedDir() {
     return LOCAL_DIR;
 }
 // ── File helpers ──
+/** Read JSON or JSONC file. If exact path not found, tries .json/.jsonc variant. */
 function readJsonc(filePath) {
-    if (!fs.existsSync(filePath))
-        return null;
+    let actual = filePath;
+    if (!fs.existsSync(actual)) {
+        // Try alternate extension
+        if (actual.endsWith(".jsonc"))
+            actual = actual.replace(/\.jsonc$/, ".json");
+        else if (actual.endsWith(".json"))
+            actual = actual.replace(/\.json$/, ".jsonc");
+        if (!fs.existsSync(actual))
+            return null;
+    }
     try {
-        return parseJsonc(fs.readFileSync(filePath, "utf-8"));
+        return parseJsonc(fs.readFileSync(actual, "utf-8"));
     }
     catch (e) {
-        console.error(`Failed to read ${filePath}: ${e.message}`);
+        console.error(`Failed to read ${actual}: ${e.message}`);
         return null;
     }
 }

package/packages/mailx-store/db.d.ts

@@ -44,7 +44,9 @@ export declare class MailxDB {
         bodyPath: string;
     }): number;
     getMessages(query: MessageQuery): PagedResult<MessageEnvelope>;
-    getMessageByUid(accountId: string, uid: number): MessageEnvelope;
+    /** Unified inbox: all inbox folders across accounts, sorted by date, paginated in SQL */
+    getUnifiedInbox(page?: number, pageSize?: number): PagedResult<MessageEnvelope>;
+    getMessageByUid(accountId: string, uid: number, folderId?: number): MessageEnvelope;
     getMessageBodyPath(accountId: string, uid: number): string;
     updateMessageFlags(accountId: string, uid: number, flags: string[]): void;
     getHighestUid(accountId: string, folderId: number): number;
@@ -52,6 +54,8 @@ export declare class MailxDB {
     getUidsForFolder(accountId: string, folderId: number): number[];
     /** Delete a message by account + UID */
     deleteMessage(accountId: string, uid: number): void;
+    /** Recalculate folder total/unread counts from actual messages */
+    recalcFolderCounts(folderId: number): void;
     /** Bulk insert within a transaction for sync performance */
     beginTransaction(): void;
     commitTransaction(): void;
@@ -68,7 +72,7 @@ export declare class MailxDB {
         useCount: number;
     }[];
     /** Full-text search across all messages. Supports qualifiers: from:, to:, subject: */
-    searchMessages(query: string, page?: number, pageSize?: number): PagedResult<MessageEnvelope>;
+    searchMessages(query: string, page?: number, pageSize?: number, accountId?: string, folderId?: number): PagedResult<MessageEnvelope>;
     /** Rebuild FTS index from existing messages */
     rebuildSearchIndex(): number;
     /** Queue a local action for later sync to IMAP */