@bobfrankston/mailx 1.0.1

package/packages/mailx-send/node_modules/undici-types/util.d.ts

@@ -0,0 +1,18 @@
+export namespace util {
+  /**
+   * Retrieves a header name and returns its lowercase value.
+   * @param value Header name
+   */
+  export function headerNameToString(value: string | Buffer): string;
+
+  /**
+   * Receives a header object and returns the parsed value.
+   * @param headers Header object
+   * @param obj Object to specify a proxy object. Used to assign parsed values.
+   * @returns If `obj` is specified, it is equivalent to `obj`.
+   */
+  export function parseHeaders(
+    headers: (Buffer | string | (Buffer | string)[])[],
+    obj?: Record<string, string | string[]>
+  ): Record<string, string | string[]>;
+}

package/packages/mailx-send/node_modules/undici-types/webidl.d.ts

@@ -0,0 +1,228 @@
+// These types are not exported, and are only used internally
+
+/**
+ * Take in an unknown value and return one that is of type T
+ */
+type Converter<T> = (object: unknown) => T
+
+type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
+
+type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
+
+interface ConvertToIntOpts {
+  clamp?: boolean
+  enforceRange?: boolean
+}
+
+interface WebidlErrors {
+  exception (opts: { header: string, message: string }): TypeError
+  /**
+   * @description Throw an error when conversion from one type to another has failed
+   */
+  conversionFailed (opts: {
+    prefix: string
+    argument: string
+    types: string[]
+  }): TypeError
+  /**
+   * @description Throw an error when an invalid argument is provided
+   */
+  invalidArgument (opts: {
+    prefix: string
+    value: string
+    type: string
+  }): TypeError
+}
+
+interface WebidlUtil {
+  /**
+   * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+   */
+  Type (object: unknown):
+    | 'Undefined'
+    | 'Boolean'
+    | 'String'
+    | 'Symbol'
+    | 'Number'
+    | 'BigInt'
+    | 'Null'
+    | 'Object'
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  ConvertToInt (
+    V: unknown,
+    bitLength: number,
+    signedness: 'signed' | 'unsigned',
+    opts?: ConvertToIntOpts
+  ): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  IntegerPart (N: number): number
+
+  /**
+   * Stringifies {@param V}
+   */
+  Stringify (V: any): string
+
+  /**
+   * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
+   */
+  markAsUncloneable (V: any): void
+}
+
+interface WebidlConverters {
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-DOMString
+   */
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
+    legacyNullToEmptyString: boolean
+  }): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-ByteString
+   */
+  ByteString (V: unknown, prefix: string, argument: string): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-USVString
+   */
+  USVString (V: unknown): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-boolean
+   */
+  boolean (V: unknown): boolean
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-any
+   */
+  any <Value>(V: Value): Value
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-long-long
+   */
+  ['long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long-long
+   */
+  ['unsigned long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long
+   */
+  ['unsigned long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-short
+   */
+  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
+   */
+  ArrayBuffer (V: unknown): ArrayBufferLike
+  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike
+  ): NodeJS.TypedArray | ArrayBufferLike
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
+    opts?: { allowShared: false }
+  ): NodeJS.TypedArray | ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#BufferSource
+   */
+  BufferSource (
+    V: unknown,
+    opts?: { allowShared: boolean }
+  ): NodeJS.TypedArray | ArrayBufferLike | DataView
+
+  ['sequence<ByteString>']: SequenceConverter<string>
+  
+  ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
+
+  ['record<ByteString, ByteString>']: RecordConverter<string, string>
+
+  [Key: string]: (...args: any[]) => unknown
+}
+
+export interface Webidl {
+  errors: WebidlErrors
+  util: WebidlUtil
+  converters: WebidlConverters
+
+  /**
+   * @description Performs a brand-check on {@param V} to ensure it is a
+   * {@param cls} object.
+   */
+  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-sequence
+   * @description Convert a value, V, to a WebIDL sequence type.
+   */
+  sequenceConverter <Type>(C: Converter<Type>): SequenceConverter<Type>
+
+  illegalConstructor (): never
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-to-record
+   * @description Convert a value, V, to a WebIDL record type.
+   */
+  recordConverter <K extends string, V>(
+    keyConverter: Converter<K>,
+    valueConverter: Converter<V>
+  ): RecordConverter<K, V>
+
+  /**
+   * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
+   * interfaces are allowed.
+   */
+  interfaceConverter <Interface>(cls: Interface): (
+    V: unknown,
+    opts?: { strict: boolean }
+  ) => asserts V is typeof cls
+
+  // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
+  // from the converters given?
+  /**
+   * Converts a value, V, to a WebIDL dictionary types. Allows limiting which keys are
+   * allowed, values allowed, optional and required keys. Auto converts the value to
+   * a type given a converter.
+   */
+  dictionaryConverter (converters: {
+    key: string,
+    defaultValue?: () => unknown,
+    required?: boolean,
+    converter: (...args: unknown[]) => unknown,
+    allowedValues?: unknown[]
+  }[]): (V: unknown) => Record<string, unknown>
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-nullable-type
+   * @description allows a type, V, to be null
+   */
+  nullableConverter <T>(
+    converter: Converter<T>
+  ): (V: unknown) => ReturnType<typeof converter> | null
+
+  argumentLengthCheck (args: { length: number }, min: number, context: string): void
+}

package/packages/mailx-send/node_modules/undici-types/websocket.d.ts

@@ -0,0 +1,150 @@
+/// <reference types="node" />
+
+import type { Blob } from 'buffer'
+import type { MessagePort } from 'worker_threads'
+import {
+  EventInit,
+  EventListenerOptions,
+  AddEventListenerOptions,
+  EventListenerOrEventListenerObject
+} from './patch'
+import Dispatcher from './dispatcher'
+import { HeadersInit } from './fetch'
+
+export type BinaryType = 'blob' | 'arraybuffer'
+
+interface WebSocketEventMap {
+  close: CloseEvent
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+interface WebSocket extends EventTarget {
+  binaryType: BinaryType
+  
+  readonly bufferedAmount: number
+  readonly extensions: string
+
+  onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null
+  onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null
+  onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null
+  onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null
+
+  readonly protocol: string
+  readonly readyState: number
+  readonly url: string
+
+  close(code?: number, reason?: string): void
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
+
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+
+  addEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export declare const WebSocket: {
+  prototype: WebSocket
+  new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+}
+
+interface CloseEventInit extends EventInit {
+  code?: number
+  reason?: string
+  wasClean?: boolean
+}
+
+interface CloseEvent extends Event {
+  readonly code: number
+  readonly reason: string
+  readonly wasClean: boolean
+}
+
+export declare const CloseEvent: {
+  prototype: CloseEvent
+  new (type: string, eventInitDict?: CloseEventInit): CloseEvent
+}
+
+interface MessageEventInit<T = any> extends EventInit {
+  data?: T
+  lastEventId?: string
+  origin?: string
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
+}
+
+interface MessageEvent<T = any> extends Event {
+  readonly data: T
+  readonly lastEventId: string
+  readonly origin: string
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: any,
+    origin?: string,
+    lastEventId?: string,
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
+  ): void;
+}
+
+export declare const MessageEvent: {
+  prototype: MessageEvent
+  new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
+}
+
+interface ErrorEventInit extends EventInit {
+  message?: string
+  filename?: string
+  lineno?: number
+  colno?: number
+  error?: any
+}
+
+interface ErrorEvent extends Event {
+  readonly message: string
+  readonly filename: string
+  readonly lineno: number
+  readonly colno: number
+  readonly error: any
+}
+
+export declare const ErrorEvent: {
+  prototype: ErrorEvent
+  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
+}
+
+interface WebSocketInit {
+  protocols?: string | string[],
+  dispatcher?: Dispatcher,
+  headers?: HeadersInit
+}

package/packages/mailx-send/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bobfrankston/mailx-send",
+  "version": "0.1.0",
+  "description": "Queue-based mail sender with SMTP and OAuth2 support",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "bin": {
+    "mailsend": "cli-send.js",
+    "mailq": "cli-queue.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "release": "npmglobalize"
+  },
+  "keywords": ["email", "smtp", "queue", "oauth2", "gmail"],
+  "author": "Bob Frankston",
+  "license": "MIT",
+  "dependencies": {
+    "nodemailer": "^7.0.0",
+    "@bobfrankston/oauthsupport": "file:../../../../projects/oauth/oauthsupport"
+  },
+  "devDependencies": {
+    "@types/nodemailer": "^6.4.0",
+    "@types/node": "^22.0.0"
+  }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @bobfrankston/mailx-server
+ * Express server: serves client, mounts API, manages WebSocket push.
+ */
+declare const app: import("express-serve-static-core").Express;
+declare function start(): Promise<void>;
+export { app, start };
+//# sourceMappingURL=index.d.ts.map

package/packages/mailx-server/index.js

@@ -0,0 +1,217 @@
+/**
+ * @bobfrankston/mailx-server
+ * Express server: serves client, mounts API, manages WebSocket push.
+ */
+import express from "express";
+import { WebSocketServer, WebSocket } from "ws";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { MailxDB } from "@bobfrankston/mailx-store";
+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";
+const PORT = ports.mailx;
+// ── File logging ──
+const logDir = path.join(import.meta.dirname, "..", "..");
+const logPath = path.join(logDir, "mailx.log");
+const logStream = fs.createWriteStream(logPath, { flags: "a" });
+const origLog = console.log;
+const origErr = console.error;
+function logTs() { return new Date().toLocaleString("se", { hour12: false }); }
+console.log = (...args) => {
+    const msg = `${logTs()} ${args.join(" ")}`;
+    origLog(msg);
+    logStream.write(msg + "\n");
+};
+console.error = (...args) => {
+    const msg = `${logTs()} ERROR ${args.join(" ")}`;
+    origErr(msg);
+    logStream.write(msg + "\n");
+};
+const serverPkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "package.json"), "utf-8"));
+const clientPkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "..", "client", "package.json"), "utf-8"));
+const SERVER_VERSION = serverPkg.version;
+const CLIENT_VERSION = clientPkg.version;
+// ── Initialize ──
+initLocalConfig();
+const settings = loadSettings();
+const dbDir = getConfigDir();
+const db = new MailxDB(dbDir);
+const imapManager = new ImapManager(db);
+// ── Express App ──
+const app = express();
+app.use(express.json());
+// Serve client static files
+const clientDir = path.join(import.meta.dirname, "..", "..", "client");
+const rootDir = path.join(import.meta.dirname, "..", "..");
+app.use(express.static(clientDir, { etag: false, lastModified: false, maxAge: 0 }));
+app.use("/node_modules", express.static(path.join(rootDir, "node_modules"), { etag: false, lastModified: false, maxAge: 0 }));
+// Mount API
+const apiRouter = createApiRouter(db, imapManager);
+app.use("/api", apiRouter);
+app.get("/api/version", (req, res) => res.json({ server: SERVER_VERSION, client: CLIENT_VERSION }));
+app.get("/status", (req, res) => {
+    const accounts = db.getAccounts();
+    const pendingSync = db.getTotalPendingSyncCount();
+    const uptime = process.uptime();
+    const mem = process.memoryUsage();
+    const accountInfo = accounts.map((a) => {
+        const folders = db.getFolders(a.id);
+        const inbox = folders.find((f) => f.specialUse === "inbox");
+        return {
+            id: a.id, name: a.name, folders: folders.length,
+            inboxTotal: inbox?.totalCount || 0,
+            inboxUnread: inbox?.unreadCount || 0,
+            lastSync: a.lastSync ? new Date(a.lastSync).toLocaleString() : "never",
+        };
+    });
+    res.type("html").send(`<!DOCTYPE html>
+<html><head><meta charset="UTF-8"><title>mailx status</title>
+<meta http-equiv="refresh" content="10">
+<style>body{font-family:system-ui;padding:2rem;max-width:600px;color:#cdd6f4;background:#1e1e2e}
+table{border-collapse:collapse;width:100%}td,th{text-align:left;padding:4px 12px;border-bottom:1px solid #333}
+h1{font-size:1.2rem}h2{font-size:1rem;margin-top:1.5rem}.ok{color:#a6e3a1}.warn{color:#f9e2af}
+a{color:#89b4fa}</style></head>
+<body>
+<h1>mailx status</h1>
+<p>Server: v${SERVER_VERSION} | Client: v${CLIENT_VERSION}</p>
+<p>Uptime: ${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m | Memory: ${Math.round(mem.rss / 1048576)} MB</p>
+<p>Pending sync: <span class="${pendingSync > 0 ? "warn" : "ok"}">${pendingSync}</span></p>
+<h2>Accounts</h2>
+<table><tr><th>Account</th><th>Folders</th><th>Inbox</th><th>Unread</th><th>Last Sync</th></tr>
+${accountInfo.map((a) => `<tr><td>${a.name}</td><td>${a.folders}</td><td>${a.inboxTotal}</td><td>${a.inboxUnread}</td><td>${a.lastSync}</td></tr>`).join("")}
+</table>
+<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
+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);
+    }, 500);
+});
+// SPA fallback
+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");
+let server;
+let wss;
+const clients = new Set();
+function wireWebSocket() {
+    wss.on("connection", (ws) => {
+        clients.add(ws);
+        const connected = { type: "connected" };
+        ws.send(JSON.stringify(connected));
+        ws.on("close", () => clients.delete(ws));
+    });
+}
+function broadcast(event) {
+    const data = JSON.stringify(event);
+    for (const ws of clients) {
+        if (ws.readyState === WebSocket.OPEN)
+            ws.send(data);
+    }
+}
+// Wire IMAP events to WebSocket broadcasts
+imapManager.on("syncProgress", (accountId, phase, progress) => {
+    broadcast({ type: "syncProgress", accountId, phase, progress });
+});
+imapManager.on("folderCountsChanged", (accountId, counts) => {
+    broadcast({ type: "folderCountsChanged", accountId, counts });
+});
+// ── Startup ──
+async function start() {
+    console.log("mailx server starting...");
+    // Seed contacts (fast — skips existing)
+    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) {
+            const indexed = db.rebuildSearchIndex();
+            console.log(`  Search index built: ${indexed} messages`);
+        }
+    }
+    catch {
+        // FTS table might not exist yet
+        const indexed = db.rebuildSearchIndex();
+        console.log(`  Search index built: ${indexed} messages`);
+    }
+    // Add configured accounts
+    for (const account of settings.accounts) {
+        if (!account.enabled)
+            continue;
+        try {
+            await imapManager.addAccount(account);
+            console.log(`  Account added: ${account.name} (${account.id})`);
+        }
+        catch (e) {
+            console.error(`  Failed to add account ${account.id}: ${e.message}`);
+        }
+    }
+    // Initial sync, then start IDLE watchers
+    if (settings.accounts.some(a => a.enabled)) {
+        console.log("  Starting initial sync...");
+        imapManager.syncAll().then(async () => {
+            console.log("  Initial sync complete");
+            // Start IDLE watchers for instant new-mail notifications
+            await imapManager.startWatching();
+            // Sync Google Contacts for OAuth accounts
+            imapManager.syncAllContacts().catch(e => console.error(`  Google Contacts sync error: ${e.message}`));
+        }).catch(e => {
+            console.error(`  Initial sync error: ${e.message}`);
+        });
+    }
+    // Periodic sync as fallback (IDLE handles most updates)
+    imapManager.startPeriodicSync(settings.sync.intervalMinutes);
+    // Outbox worker — processes queued outgoing messages
+    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);
+    wss = new WebSocketServer({ server });
+    wireWebSocket();
+    console.log(`mailx server running on port ${PORT} (http+https)`);
+}
+// ── Graceful Shutdown ──
+async function shutdown() {
+    console.log("\nShutting down...");
+    const forceExit = setTimeout(() => { console.log("Force exit"); process.exit(1); }, 3000);
+    imapManager.stopPeriodicSync();
+    try {
+        await imapManager.shutdown();
+    }
+    catch { /* proceed */ }
+    db.close();
+    server?.close();
+    clearTimeout(forceExit);
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("unhandledRejection", (err) => {
+    console.error("Unhandled rejection:", err?.message || err);
+});
+// ── Entry Point ──
+await start();
+export { app, start };
+//# sourceMappingURL=index.js.map

package/packages/mailx-server/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@bobfrankston/mailx-server",
+  "version": "1.0.2",
+  "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-api": "file:../mailx-api",
+    "@bobfrankston/mailx-settings": "file:../mailx-settings",
+    "@bobfrankston/certsupport": "file:../../../../projects/nodejs/certsupport",
+    "express": "^4.21.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/ws": "^8.5.13"
+  }
+}

package/packages/mailx-server/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./index.ts"],"version":"5.9.2"}