@bobfrankston/mailx 1.0.1

package/packages/mailx-send/mailsend/index.js

@@ -0,0 +1,264 @@
+/**
+ * @bobfrankston/mailsend
+ * Queue-based mail sender. Each account has its own queue directory.
+ * Messages queued as .ltr (RFC 822) files, sent via SMTP with retry.
+ * Supports password and OAuth2 (Gmail) authentication.
+ *
+ * Directory structure:
+ *   {baseDir}/{accountId}/queue/    — pending .ltr files
+ *   {baseDir}/{accountId}/sent/     — sent messages (optional, YYYY/MM/DD)
+ *   {baseDir}/{accountId}/fail/     — failed messages for retry
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createTransport } from "nodemailer";
+// ── File helpers ──
+function generateFilename() {
+    const now = new Date();
+    const pad2 = (n) => String(n).padStart(2, "0");
+    const ts = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
+    const seq = String(Math.floor(Math.random() * 10000)).padStart(4, "0");
+    return `${ts}-${seq}.ltr`;
+}
+function datePath() {
+    const dt = new Date();
+    const pad2 = (n) => String(n).padStart(2, "0");
+    return `${dt.getFullYear()}/${pad2(dt.getMonth() + 1)}/${pad2(dt.getDate())}`;
+}
+function moveToDateDir(filePath, destBase) {
+    const dest = path.join(destBase, datePath());
+    fs.mkdirSync(dest, { recursive: true });
+    fs.renameSync(filePath, path.join(dest, path.basename(filePath)));
+}
+function listLtr(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter(f => f.endsWith(".ltr")).sort();
+}
+function walkLtrCount(dir) {
+    if (!fs.existsSync(dir))
+        return 0;
+    let count = 0;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            count += walkLtrCount(path.join(dir, entry.name));
+        else if (entry.name.endsWith(".ltr"))
+            count++;
+    }
+    return count;
+}
+function walkLtrFiles(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const files = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            files.push(...walkLtrFiles(full));
+        else if (entry.name.endsWith(".ltr"))
+            files.push(full);
+    }
+    return files;
+}
+// ── RFC 822 builder ──
+export function buildRfc822(msg) {
+    const lines = [];
+    lines.push(`From: ${msg.from}`);
+    lines.push(`To: ${msg.to.join(", ")}`);
+    if (msg.cc?.length)
+        lines.push(`Cc: ${msg.cc.join(", ")}`);
+    if (msg.bcc?.length)
+        lines.push(`Bcc: ${msg.bcc.join(", ")}`);
+    lines.push(`Subject: ${msg.subject}`);
+    lines.push(`Date: ${new Date().toUTCString()}`);
+    if (msg.inReplyTo)
+        lines.push(`In-Reply-To: ${msg.inReplyTo}`);
+    if (msg.references)
+        lines.push(`References: ${msg.references}`);
+    if (msg.accountId)
+        lines.push(`X-MailSend-Account: ${msg.accountId}`);
+    lines.push(`MIME-Version: 1.0`);
+    if (msg.html) {
+        lines.push(`Content-Type: text/html; charset=UTF-8`);
+        lines.push(`Content-Transfer-Encoding: 8bit`);
+        lines.push("");
+        lines.push(msg.html);
+    }
+    else {
+        lines.push(`Content-Type: text/plain; charset=UTF-8`);
+        lines.push(`Content-Transfer-Encoding: 8bit`);
+        lines.push("");
+        lines.push(msg.text || "");
+    }
+    return lines.join("\r\n");
+}
+// ── Transport cache ──
+const transports = new Map();
+function getTransport(config) {
+    const key = `${config.host}:${config.port}:${config.user}`;
+    let transport = transports.get(key);
+    if (!transport) {
+        const opts = {
+            host: config.host,
+            port: config.port,
+            secure: config.secure ?? (config.port === 465),
+            tls: { rejectUnauthorized: false },
+        };
+        if (config.auth === "password") {
+            opts.auth = { user: config.user, pass: config.password };
+        }
+        else if (config.auth === "oauth2") {
+            opts.auth = { type: "OAuth2", user: config.user };
+        }
+        transport = createTransport(opts);
+        transports.set(key, transport);
+    }
+    return transport;
+}
+// ── MailSender ──
+let singleton = null;
+export class MailSender {
+    config;
+    processing = false;
+    retryTimer = null;
+    constructor(config) {
+        this.config = config;
+        // Ensure base directory exists
+        fs.mkdirSync(config.baseDir, { recursive: true });
+    }
+    accountDir(accountId) {
+        return path.join(this.config.baseDir, accountId);
+    }
+    queueDir(accountId) {
+        const dir = path.join(this.accountDir(accountId), "queue");
+        fs.mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    sentDir(accountId) {
+        return path.join(this.accountDir(accountId), "sent");
+    }
+    failDir(accountId) {
+        const dir = path.join(this.accountDir(accountId), "fail");
+        fs.mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    /** Queue a message. Returns the filename. */
+    queueMessage(msg) {
+        const accountId = msg.accountId || this.config.defaultAccount;
+        if (!accountId)
+            throw new Error("No accountId and no defaultAccount configured");
+        msg.accountId = accountId;
+        const content = buildRfc822(msg);
+        const filename = generateFilename();
+        fs.writeFileSync(path.join(this.queueDir(accountId), filename), content);
+        // Process immediately (non-blocking)
+        this.processQueue(accountId).catch(e => console.error(`[mailsend] Process error: ${e.message}`));
+        return filename;
+    }
+    /** Process pending messages for one account */
+    async processQueue(accountId) {
+        if (this.processing)
+            return;
+        this.processing = true;
+        try {
+            const smtpConfig = this.config.accounts[accountId];
+            if (!smtpConfig) {
+                console.error(`[mailsend] No SMTP config for: ${accountId}`);
+                return;
+            }
+            const files = listLtr(this.queueDir(accountId));
+            for (const file of files) {
+                await this.sendFile(path.join(this.queueDir(accountId), file), accountId, smtpConfig);
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    /** Process all account queues */
+    async processAllQueues() {
+        for (const accountId of Object.keys(this.config.accounts)) {
+            await this.processQueue(accountId);
+        }
+    }
+    async sendFile(filePath, accountId, smtpConfig) {
+        const content = fs.readFileSync(filePath, "utf-8");
+        try {
+            const transport = getTransport(smtpConfig);
+            if (smtpConfig.auth === "oauth2" && smtpConfig.tokenProvider) {
+                const token = await smtpConfig.tokenProvider();
+                transport.options.auth.accessToken = token;
+            }
+            const result = await transport.sendMail({ raw: content });
+            if (result.rejected?.length > 0) {
+                console.error(`[mailsend] Rejected: ${result.rejected.join(", ")} — ${path.basename(filePath)}`);
+                moveToDateDir(filePath, this.failDir(accountId));
+                return false;
+            }
+            console.log(`[mailsend] Sent: ${path.basename(filePath)} → ${result.accepted?.join(", ")} (${result.messageId})`);
+            if (this.config.logSent) {
+                moveToDateDir(filePath, this.sentDir(accountId));
+            }
+            else {
+                fs.unlinkSync(filePath);
+            }
+            return true;
+        }
+        catch (e) {
+            console.error(`[mailsend] Error: ${path.basename(filePath)}: ${e.message}`);
+            moveToDateDir(filePath, this.failDir(accountId));
+            return false;
+        }
+    }
+    /** Start background worker — retries failed, processes queues */
+    startWorker() {
+        if (this.retryTimer)
+            return;
+        const interval = this.config.retryIntervalMs || 300000;
+        this.retryTimer = setInterval(async () => {
+            for (const accountId of Object.keys(this.config.accounts)) {
+                this.retryFailed(accountId);
+            }
+            await this.processAllQueues();
+        }, interval);
+    }
+    retryFailed(accountId) {
+        const failFiles = walkLtrFiles(this.failDir(accountId));
+        const queueDir = this.queueDir(accountId);
+        for (const file of failFiles) {
+            fs.renameSync(file, path.join(queueDir, path.basename(file)));
+        }
+    }
+    stopWorker() {
+        if (this.retryTimer) {
+            clearInterval(this.retryTimer);
+            this.retryTimer = null;
+        }
+    }
+    /** Get queue status per account */
+    getStatus() {
+        const result = {};
+        for (const accountId of Object.keys(this.config.accounts)) {
+            result[accountId] = {
+                pending: listLtr(this.queueDir(accountId)).length,
+                failed: walkLtrCount(this.failDir(accountId)),
+            };
+        }
+        return result;
+    }
+}
+// ── Singleton API ──
+export function initMailSend(config) {
+    singleton = new MailSender(config);
+    singleton.startWorker();
+    return singleton;
+}
+export function getMailSender() {
+    return singleton;
+}
+export function queueMessage(msg) {
+    if (!singleton)
+        throw new Error("mailsend not initialized — call initMailSend() first");
+    return singleton.queueMessage(msg);
+}
+//# sourceMappingURL=index.js.map

package/packages/mailx-send/mailsend/node_modules/.package-lock.json

@@ -0,0 +1,49 @@
+{
+  "name": "@bobfrankston/mailsend",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "../../projects/oauth/oauthsupport": {},
+    "node_modules/@bobfrankston/oauthsupport": {
+      "resolved": "../../projects/oauth/oauthsupport",
+      "link": true
+    },
+    "node_modules/@types/node": {
+      "version": "22.19.15",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.15.tgz",
+      "integrity": "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/nodemailer": {
+      "version": "6.4.23",
+      "resolved": "https://registry.npmjs.org/@types/nodemailer/-/nodemailer-6.4.23.tgz",
+      "integrity": "sha512-aFV3/NsYFLSx9mbb5gtirBSXJnAlrusoKNuPbxsASWc7vrKLmIrTQRpdcxNcSFL3VW2A2XpeLEavwb2qMi6nlQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/nodemailer": {
+      "version": "7.0.13",
+      "resolved": "https://registry.npmjs.org/nodemailer/-/nodemailer-7.0.13.tgz",
+      "integrity": "sha512-PNDFSJdP+KFgdsG3ZzMXCgquO7I6McjY2vlqILjtJd0hy8wEvtugS9xKRF2NWlPNGxvLCXlTNIae4serI7dinw==",
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/packages/mailx-send/mailsend/node_modules/@types/node/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/packages/mailx-send/mailsend/node_modules/@types/node/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for node (https://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v22.
+
+### Additional Details
+ * Last updated: Fri, 06 Mar 2026 00:57:44 GMT
+ * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [Alberto Schiabel](https://github.com/jkomyno), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [David Junger](https://github.com/touffy), [Mohsen Azimi](https://github.com/mohsen1), [Nikita Galkin](https://github.com/galkin), [Sebastian Silbermann](https://github.com/eps1lon), [Wilco Bakker](https://github.com/WilcoBakker), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), [Matteo Collina](https://github.com/mcollina), [Dmitry Semigradsky](https://github.com/Semigradsky), and [René](https://github.com/Renegade334).

package/packages/mailx-send/mailsend/node_modules/@types/node/assert/strict.d.ts

@@ -0,0 +1,111 @@
+/**
+ * In strict assertion mode, non-strict methods behave like their corresponding
+ * strict methods. For example, `assert.deepEqual()` will behave like
+ * `assert.deepStrictEqual()`.
+ *
+ * In strict assertion mode, error messages for objects display a diff. In legacy
+ * assertion mode, error messages for objects display the objects, often truncated.
+ *
+ * To use strict assertion mode:
+ *
+ * ```js
+ * import { strict as assert } from 'node:assert';
+ * ```
+ *
+ * ```js
+ * import assert from 'node:assert/strict';
+ * ```
+ *
+ * Example error diff:
+ *
+ * ```js
+ * import { strict as assert } from 'node:assert';
+ *
+ * assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
+ * // AssertionError: Expected inputs to be strictly deep-equal:
+ * // + actual - expected ... Lines skipped
+ * //
+ * //   [
+ * //     [
+ * // ...
+ * //       2,
+ * // +     3
+ * // -     '3'
+ * //     ],
+ * // ...
+ * //     5
+ * //   ]
+ * ```
+ *
+ * To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS`
+ * environment variables. This will also deactivate the colors in the REPL. For
+ * more on color support in terminal environments, read the tty
+ * [`getColorDepth()`](https://nodejs.org/docs/latest-v22.x/api/tty.html#writestreamgetcolordepthenv) documentation.
+ * @since v15.0.0
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/assert/strict.js)
+ */
+declare module "assert/strict" {
+    import {
+        Assert,
+        AssertionError,
+        AssertionErrorOptions,
+        AssertOptions,
+        AssertPredicate,
+        AssertStrict,
+        CallTracker,
+        CallTrackerCall,
+        CallTrackerReportInformation,
+        deepStrictEqual,
+        doesNotMatch,
+        doesNotReject,
+        doesNotThrow,
+        fail,
+        ifError,
+        match,
+        notDeepStrictEqual,
+        notStrictEqual,
+        ok,
+        partialDeepStrictEqual,
+        rejects,
+        strictEqual,
+        throws,
+    } from "node:assert";
+    function strict(value: unknown, message?: string | Error): asserts value;
+    namespace strict {
+        export {
+            Assert,
+            AssertionError,
+            AssertionErrorOptions,
+            AssertOptions,
+            AssertPredicate,
+            AssertStrict,
+            CallTracker,
+            CallTrackerCall,
+            CallTrackerReportInformation,
+            deepStrictEqual,
+            deepStrictEqual as deepEqual,
+            doesNotMatch,
+            doesNotReject,
+            doesNotThrow,
+            fail,
+            ifError,
+            match,
+            notDeepStrictEqual,
+            notDeepStrictEqual as notDeepEqual,
+            notStrictEqual,
+            notStrictEqual as notEqual,
+            ok,
+            partialDeepStrictEqual,
+            rejects,
+            strict,
+            strictEqual,
+            strictEqual as equal,
+            throws,
+        };
+    }
+    export = strict;
+}
+declare module "node:assert/strict" {
+    import strict = require("assert/strict");
+    export = strict;
+}