@bobfrankston/mailx 1.0.12 → 1.0.13

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;

package/packages/mailx-store/db.js

@@ -241,8 +241,43 @@ export class MailxDB {
         }));
         return { items, total, page, pageSize };
     }
-    getMessageByUid(accountId, uid) {
-        const r = this.db.prepare("SELECT * FROM messages WHERE account_id = ? AND uid = ?").get(accountId, uid);
+    /** Unified inbox: all inbox folders across accounts, sorted by date, paginated in SQL */
+    getUnifiedInbox(page = 1, pageSize = 50) {
+        const offset = (page - 1) * pageSize;
+        // Find all inbox folder IDs
+        const inboxRows = this.db.prepare("SELECT id FROM folders WHERE special_use = 'inbox'").all();
+        if (inboxRows.length === 0)
+            return { items: [], total: 0, page, pageSize };
+        const placeholders = inboxRows.map(() => "?").join(",");
+        const folderIds = inboxRows.map((r) => r.id);
+        const total = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages WHERE folder_id IN (${placeholders})`).get(...folderIds).cnt;
+        const rows = this.db.prepare(`SELECT * FROM messages WHERE folder_id IN (${placeholders}) ORDER BY date DESC LIMIT ? OFFSET ?`).all(...folderIds, pageSize, offset);
+        const items = rows.map(r => ({
+            id: r.id,
+            accountId: r.account_id,
+            folderId: r.folder_id,
+            uid: r.uid,
+            messageId: r.message_id || "",
+            inReplyTo: r.in_reply_to || "",
+            references: JSON.parse(r.refs || "[]"),
+            date: r.date,
+            subject: r.subject,
+            from: { name: r.from_name, address: r.from_address },
+            to: JSON.parse(r.to_json),
+            cc: JSON.parse(r.cc_json),
+            flags: JSON.parse(r.flags_json),
+            size: r.size,
+            hasAttachments: !!r.has_attachments,
+            preview: r.preview
+        }));
+        return { items, total, page, pageSize };
+    }
+    getMessageByUid(accountId, uid, folderId) {
+        const sql = folderId != null
+            ? "SELECT * FROM messages WHERE account_id = ? AND uid = ? AND folder_id = ?"
+            : "SELECT * FROM messages WHERE account_id = ? AND uid = ?";
+        const params = folderId != null ? [accountId, uid, folderId] : [accountId, uid];
+        const r = this.db.prepare(sql).get(...params);
         if (!r)
             return null;
         return {
@@ -282,7 +317,19 @@ export class MailxDB {
     }
     /** Delete a message by account + UID */
     deleteMessage(accountId, uid) {
+        // Get folderId before deleting so we can update counts
+        const msg = this.db.prepare("SELECT folder_id FROM messages WHERE account_id = ? AND uid = ?").get(accountId, uid);
         this.db.prepare("DELETE FROM messages WHERE account_id = ? AND uid = ?").run(accountId, uid);
+        // Refresh folder counts
+        if (msg)
+            this.recalcFolderCounts(msg.folder_id);
+    }
+    /** Recalculate folder total/unread counts from actual messages */
+    recalcFolderCounts(folderId) {
+        const counts = this.db.prepare(`SELECT COUNT(*) as total,
+                    SUM(CASE WHEN flags_json NOT LIKE '%\\\\Seen%' THEN 1 ELSE 0 END) as unread
+             FROM messages WHERE folder_id = ?`).get(folderId);
+        this.updateFolderCounts(folderId, counts?.total || 0, counts?.unread || 0);
     }
     /** Bulk insert within a transaction for sync performance */
     beginTransaction() { this.db.exec("BEGIN"); }
@@ -401,19 +448,24 @@ export class MailxDB {
             subject, from_name, from_address, to_text, cc_text, body_text,
             content=messages, content_rowid=id
         )`);
+        // Use a single transaction + prepared statement for speed (~50x faster than individual inserts)
+        const insert = this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, ?)");
         const rows = this.db.prepare("SELECT id, subject, from_name, from_address, to_json, cc_json, preview FROM messages").all();
         let count = 0;
-        for (const r of rows) {
-            const to = JSON.parse(r.to_json || "[]");
-            const cc = JSON.parse(r.cc_json || "[]");
-            const toText = to.map((a) => `${a.name} ${a.address}`).join(" ");
-            const ccText = cc.map((a) => `${a.name} ${a.address}`).join(" ");
-            try {
-                this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, ?)").run(r.id, r.subject, r.from_name, r.from_address, toText, ccText, r.preview);
-                count++;
+        const batchInsert = this.db.transaction(() => {
+            for (const r of rows) {
+                const to = JSON.parse(r.to_json || "[]");
+                const cc = JSON.parse(r.cc_json || "[]");
+                const toText = to.map((a) => `${a.name} ${a.address}`).join(" ");
+                const ccText = cc.map((a) => `${a.name} ${a.address}`).join(" ");
+                try {
+                    insert.run(r.id, r.subject, r.from_name, r.from_address, toText, ccText, r.preview);
+                    count++;
+                }
+                catch { /* skip duplicates */ }
             }
-            catch { /* skip duplicates */ }
-        }
+        });
+        batchInsert();
         return count;
     }
     // ── Sync Actions ──

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

@@ -1,19 +1,13 @@
 /**
  * File-per-message body storage backend.
- * Messages stored as: {basePath}/{accountId}/{folderName}/{uid}.eml
- * Legacy: also checks {basePath}/{accountId}/{folderId}/{uid}.eml
+ * Messages stored as: {basePath}/{accountId}/{folderId}/{uid}.eml
+ * Folder IDs are numeric (from SQLite), not names.
  */
 import type { MessageStore } from "@bobfrankston/mailx-types";
 export declare class FileMessageStore implements MessageStore {
     private basePath;
-    private folderNames;
     constructor(basePath: string);
-    /** Register folder ID → path mapping for human-readable directory names */
-    registerFolder(folderId: number, folderPath: string): void;
-    private folderDir;
     private messagePath;
-    /** Check legacy path (numeric folder ID) */
-    private legacyPath;
     putMessage(accountId: string, folderId: number, uid: number, raw: Buffer): Promise<string>;
     getMessage(accountId: string, folderId: number, uid: number): Promise<Buffer>;
     deleteMessage(accountId: string, folderId: number, uid: number): Promise<void>;

package/packages/mailx-store/file-store.js

@@ -1,34 +1,17 @@
 /**
  * File-per-message body storage backend.
- * Messages stored as: {basePath}/{accountId}/{folderName}/{uid}.eml
- * Legacy: also checks {basePath}/{accountId}/{folderId}/{uid}.eml
+ * Messages stored as: {basePath}/{accountId}/{folderId}/{uid}.eml
+ * Folder IDs are numeric (from SQLite), not names.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-/** Sanitize folder path for use as directory name — replace delimiters with _ */
-function sanitizeFolderName(folderPath) {
-    return folderPath.replace(/[\/\\.:]/g, "_");
-}
 export class FileMessageStore {
     basePath;
-    folderNames = new Map();
     constructor(basePath) {
         this.basePath = basePath;
         fs.mkdirSync(basePath, { recursive: true });
     }
-    /** Register folder ID → path mapping for human-readable directory names */
-    registerFolder(folderId, folderPath) {
-        this.folderNames.set(folderId, sanitizeFolderName(folderPath));
-    }
-    folderDir(accountId, folderId) {
-        const name = this.folderNames.get(folderId) || String(folderId);
-        return path.join(this.basePath, accountId, name);
-    }
     messagePath(accountId, folderId, uid) {
-        return path.join(this.folderDir(accountId, folderId), `${uid}.eml`);
-    }
-    /** Check legacy path (numeric folder ID) */
-    legacyPath(accountId, folderId, uid) {
         return path.join(this.basePath, accountId, String(folderId), `${uid}.eml`);
     }
     async putMessage(accountId, folderId, uid, raw) {
@@ -38,22 +21,15 @@ export class FileMessageStore {
         return filePath;
     }
     async getMessage(accountId, folderId, uid) {
-        const filePath = this.messagePath(accountId, folderId, uid);
-        if (fs.existsSync(filePath))
-            return fs.readFileSync(filePath);
-        // Fallback to legacy path
-        const legacy = this.legacyPath(accountId, folderId, uid);
-        return fs.readFileSync(legacy);
+        return fs.readFileSync(this.messagePath(accountId, folderId, uid));
     }
     async deleteMessage(accountId, folderId, uid) {
-        for (const p of [this.messagePath(accountId, folderId, uid), this.legacyPath(accountId, folderId, uid)]) {
-            if (fs.existsSync(p))
-                fs.unlinkSync(p);
-        }
+        const filePath = this.messagePath(accountId, folderId, uid);
+        if (fs.existsSync(filePath))
+            fs.unlinkSync(filePath);
     }
     async hasMessage(accountId, folderId, uid) {
-        return fs.existsSync(this.messagePath(accountId, folderId, uid)) ||
-            fs.existsSync(this.legacyPath(accountId, folderId, uid));
+        return fs.existsSync(this.messagePath(accountId, folderId, uid));
     }
 }
 //# sourceMappingURL=file-store.js.map

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

@@ -8,7 +8,8 @@ export type AuthMethod = "password" | "oauth2";
 /** Mail account configuration */
 export interface AccountConfig {
     id: string; /** Unique account identifier (e.g., "iecc", "gmail-bob") */
-    name: string; /** Display name */
+    name: string; /** Sender name for From header (e.g., "Bob Frankston") */
+    label?: string; /** UI label for account list (e.g., "Gmail"). Falls back to name if not set */
     email: string; /** Email address */
     imap: {
         host: string;
@@ -28,6 +29,7 @@ export interface AccountConfig {
         password?: string;
     };
     enabled: boolean;
+    defaultSend?: boolean; /** Use this account's SMTP when From doesn't match any account */
 }
 /** Standard IMAP special-use folder types */
 export type SpecialUse = "inbox" | "sent" | "drafts" | "trash" | "junk" | "archive" | "all";