@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/index.d.ts

@@ -0,0 +1,12 @@
+export * from './classes.emailsignjob.js';
+export * from './classes.delivery.queue.js';
+export * from './classes.delivery.system.js';
+export { EmailSendJob } from './classes.emailsendjob.js';
+export { DeliveryStatus } from './classes.delivery.system.js';
+export { RateLimiter } from './classes.ratelimiter.js';
+export type { IRateLimitConfig } from './classes.ratelimiter.js';
+export * from './classes.unified.rate.limiter.js';
+export * from './classes.mta.config.js';
+import * as smtpClientMod from './smtpclient/index.js';
+import * as smtpServerMod from './smtpserver/index.js';
+export { smtpClientMod, smtpServerMod };

package/dist_ts/ts/mail/delivery/index.js

@@ -0,0 +1,18 @@
+// Email delivery components
+export * from './classes.emailsignjob.js';
+export * from './classes.delivery.queue.js';
+export * from './classes.delivery.system.js';
+// Handle exports with naming conflicts
+export { EmailSendJob } from './classes.emailsendjob.js';
+export { DeliveryStatus } from './classes.delivery.system.js';
+// Rate limiter exports - fix naming conflict
+export { RateLimiter } from './classes.ratelimiter.js';
+// Unified rate limiter
+export * from './classes.unified.rate.limiter.js';
+// SMTP client and configuration
+export * from './classes.mta.config.js';
+// Import and export SMTP modules as namespaces to avoid conflicts
+import * as smtpClientMod from './smtpclient/index.js';
+import * as smtpServerMod from './smtpserver/index.js';
+export { smtpClientMod, smtpServerMod };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9tYWlsL2RlbGl2ZXJ5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRCQUE0QjtBQUM1QixjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw4QkFBOEIsQ0FBQztBQUU3Qyx1Q0FBdUM7QUFDdkMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUU5RCw2Q0FBNkM7QUFDN0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBR3ZELHVCQUF1QjtBQUN2QixjQUFjLG1DQUFtQyxDQUFDO0FBRWxELGdDQUFnQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBRXhDLGtFQUFrRTtBQUNsRSxPQUFPLEtBQUssYUFBYSxNQUFNLHVCQUF1QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxhQUFhLE1BQU0sdUJBQXVCLENBQUM7QUFFdkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxhQUFhLEVBQUUsQ0FBQyJ9

package/dist_ts/ts/mail/delivery/interfaces.d.ts

@@ -0,0 +1,243 @@
+/**
+ * SMTP and email delivery interface definitions
+ */
+import type { Email } from '../core/classes.email.js';
+/**
+ * SMTP session state enumeration
+ */
+export declare enum SmtpState {
+    GREETING = "GREETING",
+    AFTER_EHLO = "AFTER_EHLO",
+    MAIL_FROM = "MAIL_FROM",
+    RCPT_TO = "RCPT_TO",
+    DATA = "DATA",
+    DATA_RECEIVING = "DATA_RECEIVING",
+    FINISHED = "FINISHED"
+}
+/**
+ * Email processing mode type
+ */
+export type EmailProcessingMode = 'forward' | 'mta' | 'process';
+/**
+ * Envelope recipient information
+ */
+export interface IEnvelopeRecipient {
+    /**
+     * Email address of the recipient
+     */
+    address: string;
+    /**
+     * Additional SMTP command arguments
+     */
+    args: Record<string, string>;
+}
+/**
+ * SMTP session envelope information
+ */
+export interface ISmtpEnvelope {
+    /**
+     * Envelope sender (MAIL FROM) information
+     */
+    mailFrom: {
+        /**
+         * Email address of the sender
+         */
+        address: string;
+        /**
+         * Additional SMTP command arguments
+         */
+        args: Record<string, string>;
+    };
+    /**
+     * Envelope recipients (RCPT TO) information
+     */
+    rcptTo: IEnvelopeRecipient[];
+}
+/**
+ * SMTP Session interface - represents an active SMTP connection
+ */
+export interface ISmtpSession {
+    /**
+     * Unique session identifier
+     */
+    id: string;
+    /**
+     * Current session state in the SMTP conversation
+     */
+    state: SmtpState;
+    /**
+     * Hostname provided by the client in EHLO/HELO command
+     */
+    clientHostname: string;
+    /**
+     * MAIL FROM email address (legacy format)
+     */
+    mailFrom: string;
+    /**
+     * RCPT TO email addresses (legacy format)
+     */
+    rcptTo: string[];
+    /**
+     * Raw email data being received
+     */
+    emailData: string;
+    /**
+     * Chunks of email data for more efficient buffer management
+     */
+    emailDataChunks?: string[];
+    /**
+     * Whether the connection is using TLS
+     */
+    useTLS: boolean;
+    /**
+     * Whether the connection has ended
+     */
+    connectionEnded: boolean;
+    /**
+     * Remote IP address of the client
+     */
+    remoteAddress: string;
+    /**
+     * Whether the connection is secure (TLS)
+     */
+    secure: boolean;
+    /**
+     * Whether the client has been authenticated
+     */
+    authenticated: boolean;
+    /**
+     * SMTP envelope information (structured format)
+     */
+    envelope: ISmtpEnvelope;
+    /**
+     * Email processing mode to use for this session
+     */
+    processingMode?: EmailProcessingMode;
+    /**
+     * Timestamp of last activity for session timeout tracking
+     */
+    lastActivity?: number;
+    /**
+     * Timeout ID for DATA command timeout
+     */
+    dataTimeoutId?: NodeJS.Timeout;
+}
+/**
+ * SMTP authentication data
+ */
+export interface ISmtpAuth {
+    /**
+     * Authentication method used
+     */
+    method: 'PLAIN' | 'LOGIN' | 'OAUTH2' | string;
+    /**
+     * Username for authentication
+     */
+    username: string;
+    /**
+     * Password or token for authentication
+     */
+    password: string;
+}
+/**
+ * SMTP server options
+ */
+export interface ISmtpServerOptions {
+    /**
+     * Port to listen on
+     */
+    port: number;
+    /**
+     * TLS private key (PEM format)
+     */
+    key: string;
+    /**
+     * TLS certificate (PEM format)
+     */
+    cert: string;
+    /**
+     * Server hostname for SMTP banner
+     */
+    hostname?: string;
+    /**
+     * Host address to bind to (defaults to all interfaces)
+     */
+    host?: string;
+    /**
+     * Secure port for dedicated TLS connections
+     */
+    securePort?: number;
+    /**
+     * CA certificates for TLS (PEM format)
+     */
+    ca?: string;
+    /**
+     * Maximum size of messages in bytes
+     */
+    maxSize?: number;
+    /**
+     * Maximum number of concurrent connections
+     */
+    maxConnections?: number;
+    /**
+     * Authentication options
+     */
+    auth?: {
+        /**
+         * Whether authentication is required
+         */
+        required: boolean;
+        /**
+         * Allowed authentication methods
+         */
+        methods: ('PLAIN' | 'LOGIN' | 'OAUTH2')[];
+    };
+    /**
+     * Socket timeout in milliseconds (default: 5 minutes / 300000ms)
+     */
+    socketTimeout?: number;
+    /**
+     * Initial connection timeout in milliseconds (default: 30 seconds / 30000ms)
+     */
+    connectionTimeout?: number;
+    /**
+     * Interval for checking idle sessions in milliseconds (default: 5 seconds / 5000ms)
+     * For testing, can be set lower (e.g. 1000ms) to detect timeouts more quickly
+     */
+    cleanupInterval?: number;
+    /**
+     * Maximum number of recipients allowed per message (default: 100)
+     */
+    maxRecipients?: number;
+    /**
+     * Maximum message size in bytes (default: 10MB / 10485760 bytes)
+     * This is advertised in the EHLO SIZE extension
+     */
+    size?: number;
+    /**
+     * Timeout for the DATA command in milliseconds (default: 60000ms / 1 minute)
+     * This controls how long to wait for the complete email data
+     */
+    dataTimeout?: number;
+}
+/**
+ * Result of SMTP transaction
+ */
+export interface ISmtpTransactionResult {
+    /**
+     * Whether the transaction was successful
+     */
+    success: boolean;
+    /**
+     * Error message if failed
+     */
+    error?: string;
+    /**
+     * Message ID if successful
+     */
+    messageId?: string;
+    /**
+     * Resulting email if successful
+     */
+    email?: Email;
+}

package/dist_ts/ts/mail/delivery/interfaces.js

@@ -0,0 +1,17 @@
+/**
+ * SMTP and email delivery interface definitions
+ */
+/**
+ * SMTP session state enumeration
+ */
+export var SmtpState;
+(function (SmtpState) {
+    SmtpState["GREETING"] = "GREETING";
+    SmtpState["AFTER_EHLO"] = "AFTER_EHLO";
+    SmtpState["MAIL_FROM"] = "MAIL_FROM";
+    SmtpState["RCPT_TO"] = "RCPT_TO";
+    SmtpState["DATA"] = "DATA";
+    SmtpState["DATA_RECEIVING"] = "DATA_RECEIVING";
+    SmtpState["FINISHED"] = "FINISHED";
+})(SmtpState || (SmtpState = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL21haWwvZGVsaXZlcnkvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUlIOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksU0FRWDtBQVJELFdBQVksU0FBUztJQUNuQixrQ0FBcUIsQ0FBQTtJQUNyQixzQ0FBeUIsQ0FBQTtJQUN6QixvQ0FBdUIsQ0FBQTtJQUN2QixnQ0FBbUIsQ0FBQTtJQUNuQiwwQkFBYSxDQUFBO0lBQ2IsOENBQWlDLENBQUE7SUFDakMsa0NBQXFCLENBQUE7QUFDdkIsQ0FBQyxFQVJXLFNBQVMsS0FBVCxTQUFTLFFBUXBCIn0=

package/dist_ts/ts/mail/delivery/smtpclient/auth-handler.d.ts

@@ -0,0 +1,43 @@
+/**
+ * SMTP Client Authentication Handler
+ * Authentication mechanisms implementation
+ */
+import type { ISmtpConnection, ISmtpAuthOptions, ISmtpClientOptions } from './interfaces.js';
+import type { CommandHandler } from './command-handler.js';
+export declare class AuthHandler {
+    private options;
+    private commandHandler;
+    constructor(options: ISmtpClientOptions, commandHandler: CommandHandler);
+    /**
+     * Authenticate using the configured method
+     */
+    authenticate(connection: ISmtpConnection): Promise<void>;
+    /**
+     * Authenticate using AUTH PLAIN
+     */
+    private authenticatePlain;
+    /**
+     * Authenticate using AUTH LOGIN
+     */
+    private authenticateLogin;
+    /**
+     * Authenticate using OAuth2
+     */
+    private authenticateOAuth2;
+    /**
+     * Select appropriate authentication method
+     */
+    private selectAuthMethod;
+    /**
+     * Check if OAuth2 token is expired
+     */
+    private isTokenExpired;
+    /**
+     * Refresh OAuth2 access token
+     */
+    private refreshOAuth2Token;
+    /**
+     * Validate authentication configuration
+     */
+    validateAuthConfig(auth: ISmtpAuthOptions): string[];
+}

package/dist_ts/ts/mail/delivery/smtpclient/auth-handler.js

@@ -0,0 +1,188 @@
+/**
+ * SMTP Client Authentication Handler
+ * Authentication mechanisms implementation
+ */
+import { AUTH_METHODS } from './constants.js';
+import { encodeAuthPlain, encodeAuthLogin, generateOAuth2String, isSuccessCode } from './utils/helpers.js';
+import { logAuthentication, logDebug } from './utils/logging.js';
+export class AuthHandler {
+    constructor(options, commandHandler) {
+        this.options = options;
+        this.commandHandler = commandHandler;
+    }
+    /**
+     * Authenticate using the configured method
+     */
+    async authenticate(connection) {
+        if (!this.options.auth) {
+            logDebug('No authentication configured', this.options);
+            return;
+        }
+        const authOptions = this.options.auth;
+        const capabilities = connection.capabilities;
+        if (!capabilities || capabilities.authMethods.size === 0) {
+            throw new Error('Server does not support authentication');
+        }
+        // Determine authentication method
+        const method = this.selectAuthMethod(authOptions, capabilities.authMethods);
+        logAuthentication('start', method, this.options);
+        try {
+            switch (method) {
+                case AUTH_METHODS.PLAIN:
+                    await this.authenticatePlain(connection, authOptions);
+                    break;
+                case AUTH_METHODS.LOGIN:
+                    await this.authenticateLogin(connection, authOptions);
+                    break;
+                case AUTH_METHODS.OAUTH2:
+                    await this.authenticateOAuth2(connection, authOptions);
+                    break;
+                default:
+                    throw new Error(`Unsupported authentication method: ${method}`);
+            }
+            logAuthentication('success', method, this.options);
+        }
+        catch (error) {
+            logAuthentication('failure', method, this.options, { error });
+            throw error;
+        }
+    }
+    /**
+     * Authenticate using AUTH PLAIN
+     */
+    async authenticatePlain(connection, auth) {
+        if (!auth.user || !auth.pass) {
+            throw new Error('Username and password required for PLAIN authentication');
+        }
+        const credentials = encodeAuthPlain(auth.user, auth.pass);
+        const response = await this.commandHandler.sendAuth(connection, AUTH_METHODS.PLAIN, credentials);
+        if (!isSuccessCode(response.code)) {
+            throw new Error(`PLAIN authentication failed: ${response.message}`);
+        }
+    }
+    /**
+     * Authenticate using AUTH LOGIN
+     */
+    async authenticateLogin(connection, auth) {
+        if (!auth.user || !auth.pass) {
+            throw new Error('Username and password required for LOGIN authentication');
+        }
+        // Step 1: Send AUTH LOGIN
+        let response = await this.commandHandler.sendAuth(connection, AUTH_METHODS.LOGIN);
+        if (response.code !== 334) {
+            throw new Error(`LOGIN authentication initiation failed: ${response.message}`);
+        }
+        // Step 2: Send username
+        const encodedUser = encodeAuthLogin(auth.user);
+        response = await this.commandHandler.sendCommand(connection, encodedUser);
+        if (response.code !== 334) {
+            throw new Error(`LOGIN username failed: ${response.message}`);
+        }
+        // Step 3: Send password
+        const encodedPass = encodeAuthLogin(auth.pass);
+        response = await this.commandHandler.sendCommand(connection, encodedPass);
+        if (!isSuccessCode(response.code)) {
+            throw new Error(`LOGIN password failed: ${response.message}`);
+        }
+    }
+    /**
+     * Authenticate using OAuth2
+     */
+    async authenticateOAuth2(connection, auth) {
+        if (!auth.oauth2) {
+            throw new Error('OAuth2 configuration required for OAUTH2 authentication');
+        }
+        let accessToken = auth.oauth2.accessToken;
+        // Refresh token if needed
+        if (!accessToken || this.isTokenExpired(auth.oauth2)) {
+            accessToken = await this.refreshOAuth2Token(auth.oauth2);
+        }
+        const authString = generateOAuth2String(auth.oauth2.user, accessToken);
+        const response = await this.commandHandler.sendAuth(connection, AUTH_METHODS.OAUTH2, authString);
+        if (!isSuccessCode(response.code)) {
+            throw new Error(`OAUTH2 authentication failed: ${response.message}`);
+        }
+    }
+    /**
+     * Select appropriate authentication method
+     */
+    selectAuthMethod(auth, serverMethods) {
+        // If method is explicitly specified, use it
+        if (auth.method && auth.method !== 'AUTO') {
+            const method = auth.method === 'OAUTH2' ? AUTH_METHODS.OAUTH2 : auth.method;
+            if (serverMethods.has(method)) {
+                return method;
+            }
+            throw new Error(`Requested authentication method ${auth.method} not supported by server`);
+        }
+        // Auto-select based on available credentials and server support
+        if (auth.oauth2 && serverMethods.has(AUTH_METHODS.OAUTH2)) {
+            return AUTH_METHODS.OAUTH2;
+        }
+        if (auth.user && auth.pass) {
+            // Prefer PLAIN over LOGIN for simplicity
+            if (serverMethods.has(AUTH_METHODS.PLAIN)) {
+                return AUTH_METHODS.PLAIN;
+            }
+            if (serverMethods.has(AUTH_METHODS.LOGIN)) {
+                return AUTH_METHODS.LOGIN;
+            }
+        }
+        throw new Error('No compatible authentication method found');
+    }
+    /**
+     * Check if OAuth2 token is expired
+     */
+    isTokenExpired(oauth2) {
+        if (!oauth2.expires) {
+            return false; // No expiry information, assume valid
+        }
+        const now = Date.now();
+        const buffer = 300000; // 5 minutes buffer
+        return oauth2.expires < (now + buffer);
+    }
+    /**
+     * Refresh OAuth2 access token
+     */
+    async refreshOAuth2Token(oauth2) {
+        // This is a simplified implementation
+        // In a real implementation, you would make an HTTP request to the OAuth2 provider
+        logDebug('OAuth2 token refresh required', this.options);
+        if (!oauth2.refreshToken) {
+            throw new Error('Refresh token required for OAuth2 token refresh');
+        }
+        // TODO: Implement actual OAuth2 token refresh
+        // For now, throw an error to indicate this needs to be implemented
+        throw new Error('OAuth2 token refresh not implemented. Please provide a valid access token.');
+    }
+    /**
+     * Validate authentication configuration
+     */
+    validateAuthConfig(auth) {
+        const errors = [];
+        if (auth.method === 'OAUTH2' || auth.oauth2) {
+            if (!auth.oauth2) {
+                errors.push('OAuth2 configuration required when using OAUTH2 method');
+            }
+            else {
+                if (!auth.oauth2.user)
+                    errors.push('OAuth2 user required');
+                if (!auth.oauth2.clientId)
+                    errors.push('OAuth2 clientId required');
+                if (!auth.oauth2.clientSecret)
+                    errors.push('OAuth2 clientSecret required');
+                if (!auth.oauth2.refreshToken && !auth.oauth2.accessToken) {
+                    errors.push('OAuth2 refreshToken or accessToken required');
+                }
+            }
+        }
+        else if (auth.method === 'PLAIN' || auth.method === 'LOGIN' || (!auth.method && (auth.user || auth.pass))) {
+            if (!auth.user)
+                errors.push('Username required for basic authentication');
+            if (!auth.pass)
+                errors.push('Password required for basic authentication');
+        }
+        return errors;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-handler.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpclient/auth-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/mail/delivery/smtpclient/command-handler.d.ts

@@ -0,0 +1,67 @@
+/**
+ * SMTP Client Command Handler
+ * SMTP command sending and response parsing
+ */
+import { EventEmitter } from 'node:events';
+import type { ISmtpConnection, ISmtpResponse, ISmtpClientOptions, ISmtpCapabilities } from './interfaces.js';
+export declare class CommandHandler extends EventEmitter {
+    private options;
+    private responseBuffer;
+    private pendingCommand;
+    private commandTimeout;
+    constructor(options: ISmtpClientOptions);
+    /**
+     * Send EHLO command and parse capabilities
+     */
+    sendEhlo(connection: ISmtpConnection, domain?: string): Promise<ISmtpCapabilities>;
+    /**
+     * Send MAIL FROM command
+     */
+    sendMailFrom(connection: ISmtpConnection, fromAddress: string): Promise<ISmtpResponse>;
+    /**
+     * Send RCPT TO command
+     */
+    sendRcptTo(connection: ISmtpConnection, toAddress: string): Promise<ISmtpResponse>;
+    /**
+     * Send DATA command
+     */
+    sendData(connection: ISmtpConnection): Promise<ISmtpResponse>;
+    /**
+     * Send email data content
+     */
+    sendDataContent(connection: ISmtpConnection, emailData: string): Promise<ISmtpResponse>;
+    /**
+     * Send RSET command
+     */
+    sendRset(connection: ISmtpConnection): Promise<ISmtpResponse>;
+    /**
+     * Send NOOP command
+     */
+    sendNoop(connection: ISmtpConnection): Promise<ISmtpResponse>;
+    /**
+     * Send QUIT command
+     */
+    sendQuit(connection: ISmtpConnection): Promise<ISmtpResponse>;
+    /**
+     * Send STARTTLS command
+     */
+    sendStartTls(connection: ISmtpConnection): Promise<ISmtpResponse>;
+    /**
+     * Send AUTH command
+     */
+    sendAuth(connection: ISmtpConnection, method: string, credentials?: string): Promise<ISmtpResponse>;
+    /**
+     * Send a generic SMTP command
+     */
+    sendCommand(connection: ISmtpConnection, command: string): Promise<ISmtpResponse>;
+    /**
+     * Send raw data without command formatting
+     */
+    sendRawData(connection: ISmtpConnection, data: string): Promise<ISmtpResponse>;
+    /**
+     * Wait for server greeting
+     */
+    waitForGreeting(connection: ISmtpConnection): Promise<ISmtpResponse>;
+    private handleIncomingData;
+    private isCompleteResponse;
+}