@serve.zone/dcrouter 2.12.4

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

@@ -0,0 +1,276 @@
+/**
+ * SMTP Client Command Handler
+ * SMTP command sending and response parsing
+ */
+import { EventEmitter } from 'node:events';
+import { SMTP_COMMANDS, SMTP_CODES, LINE_ENDINGS } from './constants.js';
+import { parseSmtpResponse, parseEhloResponse, formatCommand, isSuccessCode } from './utils/helpers.js';
+import { logCommand, logDebug } from './utils/logging.js';
+export class CommandHandler extends EventEmitter {
+    constructor(options) {
+        super();
+        this.responseBuffer = '';
+        this.pendingCommand = null;
+        this.commandTimeout = null;
+        this.options = options;
+    }
+    /**
+     * Send EHLO command and parse capabilities
+     */
+    async sendEhlo(connection, domain) {
+        const hostname = domain || this.options.domain || 'localhost';
+        const command = `${SMTP_COMMANDS.EHLO} ${hostname}`;
+        const response = await this.sendCommand(connection, command);
+        if (!isSuccessCode(response.code)) {
+            throw new Error(`EHLO failed: ${response.message}`);
+        }
+        const capabilities = parseEhloResponse(response.raw);
+        connection.capabilities = capabilities;
+        logDebug('EHLO capabilities parsed', this.options, { capabilities });
+        return capabilities;
+    }
+    /**
+     * Send MAIL FROM command
+     */
+    async sendMailFrom(connection, fromAddress) {
+        // Handle empty return path for bounce messages
+        const command = fromAddress === ''
+            ? `${SMTP_COMMANDS.MAIL_FROM}:<>`
+            : `${SMTP_COMMANDS.MAIL_FROM}:<${fromAddress}>`;
+        return this.sendCommand(connection, command);
+    }
+    /**
+     * Send RCPT TO command
+     */
+    async sendRcptTo(connection, toAddress) {
+        const command = `${SMTP_COMMANDS.RCPT_TO}:<${toAddress}>`;
+        return this.sendCommand(connection, command);
+    }
+    /**
+     * Send DATA command
+     */
+    async sendData(connection) {
+        return this.sendCommand(connection, SMTP_COMMANDS.DATA);
+    }
+    /**
+     * Send email data content
+     */
+    async sendDataContent(connection, emailData) {
+        // Normalize line endings to CRLF
+        let data = emailData.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n/g, '\r\n');
+        // Ensure email data ends with CRLF
+        if (!data.endsWith(LINE_ENDINGS.CRLF)) {
+            data += LINE_ENDINGS.CRLF;
+        }
+        // Perform dot stuffing (escape lines starting with a dot)
+        data = data.replace(/\r\n\./g, '\r\n..');
+        // Add termination sequence
+        data += '.' + LINE_ENDINGS.CRLF;
+        return this.sendRawData(connection, data);
+    }
+    /**
+     * Send RSET command
+     */
+    async sendRset(connection) {
+        return this.sendCommand(connection, SMTP_COMMANDS.RSET);
+    }
+    /**
+     * Send NOOP command
+     */
+    async sendNoop(connection) {
+        return this.sendCommand(connection, SMTP_COMMANDS.NOOP);
+    }
+    /**
+     * Send QUIT command
+     */
+    async sendQuit(connection) {
+        return this.sendCommand(connection, SMTP_COMMANDS.QUIT);
+    }
+    /**
+     * Send STARTTLS command
+     */
+    async sendStartTls(connection) {
+        return this.sendCommand(connection, SMTP_COMMANDS.STARTTLS);
+    }
+    /**
+     * Send AUTH command
+     */
+    async sendAuth(connection, method, credentials) {
+        const command = credentials ?
+            `${SMTP_COMMANDS.AUTH} ${method} ${credentials}` :
+            `${SMTP_COMMANDS.AUTH} ${method}`;
+        return this.sendCommand(connection, command);
+    }
+    /**
+     * Send a generic SMTP command
+     */
+    async sendCommand(connection, command) {
+        return new Promise((resolve, reject) => {
+            if (this.pendingCommand) {
+                reject(new Error('Another command is already pending'));
+                return;
+            }
+            this.pendingCommand = { resolve, reject, command };
+            // Set command timeout
+            const timeout = 30000; // 30 seconds
+            this.commandTimeout = setTimeout(() => {
+                this.pendingCommand = null;
+                this.commandTimeout = null;
+                reject(new Error(`Command timeout: ${command}`));
+            }, timeout);
+            // Set up data handler
+            const dataHandler = (data) => {
+                this.handleIncomingData(data.toString());
+            };
+            connection.socket.on('data', dataHandler);
+            // Clean up function
+            const cleanup = () => {
+                connection.socket.removeListener('data', dataHandler);
+                if (this.commandTimeout) {
+                    clearTimeout(this.commandTimeout);
+                    this.commandTimeout = null;
+                }
+            };
+            // Send command
+            const formattedCommand = command.endsWith(LINE_ENDINGS.CRLF) ? command : formatCommand(command);
+            logCommand(command, undefined, this.options);
+            logDebug(`Sending command: ${command}`, this.options);
+            connection.socket.write(formattedCommand, (error) => {
+                if (error) {
+                    cleanup();
+                    this.pendingCommand = null;
+                    reject(error);
+                }
+            });
+            // Override resolve/reject to include cleanup
+            const originalResolve = resolve;
+            const originalReject = reject;
+            this.pendingCommand.resolve = (response) => {
+                cleanup();
+                this.pendingCommand = null;
+                logCommand(command, response, this.options);
+                originalResolve(response);
+            };
+            this.pendingCommand.reject = (error) => {
+                cleanup();
+                this.pendingCommand = null;
+                originalReject(error);
+            };
+        });
+    }
+    /**
+     * Send raw data without command formatting
+     */
+    async sendRawData(connection, data) {
+        return new Promise((resolve, reject) => {
+            if (this.pendingCommand) {
+                reject(new Error('Another command is already pending'));
+                return;
+            }
+            this.pendingCommand = { resolve, reject, command: 'DATA_CONTENT' };
+            // Set data timeout
+            const timeout = 60000; // 60 seconds for data
+            this.commandTimeout = setTimeout(() => {
+                this.pendingCommand = null;
+                this.commandTimeout = null;
+                reject(new Error('Data transmission timeout'));
+            }, timeout);
+            // Set up data handler
+            const dataHandler = (chunk) => {
+                this.handleIncomingData(chunk.toString());
+            };
+            connection.socket.on('data', dataHandler);
+            // Clean up function
+            const cleanup = () => {
+                connection.socket.removeListener('data', dataHandler);
+                if (this.commandTimeout) {
+                    clearTimeout(this.commandTimeout);
+                    this.commandTimeout = null;
+                }
+            };
+            // Override resolve/reject to include cleanup
+            const originalResolve = resolve;
+            const originalReject = reject;
+            this.pendingCommand.resolve = (response) => {
+                cleanup();
+                this.pendingCommand = null;
+                originalResolve(response);
+            };
+            this.pendingCommand.reject = (error) => {
+                cleanup();
+                this.pendingCommand = null;
+                originalReject(error);
+            };
+            // Send data
+            connection.socket.write(data, (error) => {
+                if (error) {
+                    cleanup();
+                    this.pendingCommand = null;
+                    reject(error);
+                }
+            });
+        });
+    }
+    /**
+     * Wait for server greeting
+     */
+    async waitForGreeting(connection) {
+        return new Promise((resolve, reject) => {
+            const timeout = 30000; // 30 seconds
+            let timeoutHandler;
+            const dataHandler = (data) => {
+                this.responseBuffer += data.toString();
+                if (this.isCompleteResponse(this.responseBuffer)) {
+                    clearTimeout(timeoutHandler);
+                    connection.socket.removeListener('data', dataHandler);
+                    const response = parseSmtpResponse(this.responseBuffer);
+                    this.responseBuffer = '';
+                    if (isSuccessCode(response.code)) {
+                        resolve(response);
+                    }
+                    else {
+                        reject(new Error(`Server greeting failed: ${response.message}`));
+                    }
+                }
+            };
+            timeoutHandler = setTimeout(() => {
+                connection.socket.removeListener('data', dataHandler);
+                reject(new Error('Greeting timeout'));
+            }, timeout);
+            connection.socket.on('data', dataHandler);
+        });
+    }
+    handleIncomingData(data) {
+        if (!this.pendingCommand) {
+            return;
+        }
+        this.responseBuffer += data;
+        if (this.isCompleteResponse(this.responseBuffer)) {
+            const response = parseSmtpResponse(this.responseBuffer);
+            this.responseBuffer = '';
+            if (isSuccessCode(response.code) || (response.code >= 300 && response.code < 400) || response.code >= 400) {
+                this.pendingCommand.resolve(response);
+            }
+            else {
+                this.pendingCommand.reject(new Error(`Command failed: ${response.message}`));
+            }
+        }
+    }
+    isCompleteResponse(buffer) {
+        // Check if we have a complete response
+        const lines = buffer.split(/\r?\n/);
+        if (lines.length < 1) {
+            return false;
+        }
+        // Check the last non-empty line
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (line.length > 0) {
+                // Response is complete if line starts with "XXX " (space after code)
+                return /^\d{3} /.test(line);
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command-handler.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpclient/command-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/mail/delivery/smtpclient/connection-manager.d.ts

@@ -0,0 +1,48 @@
+/**
+ * SMTP Client Connection Manager
+ * Connection pooling and lifecycle management
+ */
+import { EventEmitter } from 'node:events';
+import type { ISmtpClientOptions, ISmtpConnection, IConnectionPoolStatus } from './interfaces.js';
+export declare class ConnectionManager extends EventEmitter {
+    private options;
+    private connections;
+    private pendingConnections;
+    private idleTimeout;
+    constructor(options: ISmtpClientOptions);
+    /**
+     * Get or create a connection
+     */
+    getConnection(): Promise<ISmtpConnection>;
+    /**
+     * Create a new connection
+     */
+    createConnection(): Promise<ISmtpConnection>;
+    /**
+     * Release a connection back to the pool or close it
+     */
+    releaseConnection(connection: ISmtpConnection): void;
+    /**
+     * Close a specific connection
+     */
+    closeConnection(connection: ISmtpConnection): void;
+    /**
+     * Close all connections
+     */
+    closeAllConnections(): void;
+    /**
+     * Get connection pool status
+     */
+    getPoolStatus(): IConnectionPoolStatus;
+    /**
+     * Update connection activity timestamp
+     */
+    updateActivity(connection: ISmtpConnection): void;
+    private establishSocket;
+    private setupSocketHandlers;
+    private findIdleConnection;
+    private shouldReuseConnection;
+    private getActiveConnectionCount;
+    private getConnectionId;
+    private setupIdleCleanup;
+}

package/dist_ts/ts/mail/delivery/smtpclient/connection-manager.js

@@ -0,0 +1,238 @@
+/**
+ * SMTP Client Connection Manager
+ * Connection pooling and lifecycle management
+ */
+import * as net from 'node:net';
+import * as tls from 'node:tls';
+import { EventEmitter } from 'node:events';
+import { DEFAULTS, CONNECTION_STATES } from './constants.js';
+import { logConnection, logDebug } from './utils/logging.js';
+import { generateConnectionId } from './utils/helpers.js';
+export class ConnectionManager extends EventEmitter {
+    constructor(options) {
+        super();
+        this.connections = new Map();
+        this.pendingConnections = new Set();
+        this.idleTimeout = null;
+        this.options = options;
+        this.setupIdleCleanup();
+    }
+    /**
+     * Get or create a connection
+     */
+    async getConnection() {
+        // Try to reuse an idle connection if pooling is enabled
+        if (this.options.pool) {
+            const idleConnection = this.findIdleConnection();
+            if (idleConnection) {
+                const connectionId = this.getConnectionId(idleConnection) || 'unknown';
+                logDebug('Reusing idle connection', this.options, { connectionId });
+                return idleConnection;
+            }
+            // Check if we can create a new connection
+            if (this.getActiveConnectionCount() >= (this.options.maxConnections || DEFAULTS.MAX_CONNECTIONS)) {
+                throw new Error('Maximum number of connections reached');
+            }
+        }
+        return this.createConnection();
+    }
+    /**
+     * Create a new connection
+     */
+    async createConnection() {
+        const connectionId = generateConnectionId();
+        try {
+            this.pendingConnections.add(connectionId);
+            logConnection('connecting', this.options, { connectionId });
+            const socket = await this.establishSocket();
+            const connection = {
+                socket,
+                state: CONNECTION_STATES.CONNECTED,
+                options: this.options,
+                secure: this.options.secure || false,
+                createdAt: new Date(),
+                lastActivity: new Date(),
+                messageCount: 0
+            };
+            this.setupSocketHandlers(socket, connectionId);
+            this.connections.set(connectionId, connection);
+            this.pendingConnections.delete(connectionId);
+            logConnection('connected', this.options, { connectionId });
+            this.emit('connection', connection);
+            return connection;
+        }
+        catch (error) {
+            this.pendingConnections.delete(connectionId);
+            logConnection('error', this.options, { connectionId, error });
+            throw error;
+        }
+    }
+    /**
+     * Release a connection back to the pool or close it
+     */
+    releaseConnection(connection) {
+        const connectionId = this.getConnectionId(connection);
+        if (!connectionId || !this.connections.has(connectionId)) {
+            return;
+        }
+        if (this.options.pool && this.shouldReuseConnection(connection)) {
+            // Return to pool
+            connection.state = CONNECTION_STATES.READY;
+            connection.lastActivity = new Date();
+            logDebug('Connection returned to pool', this.options, { connectionId });
+        }
+        else {
+            // Close connection
+            this.closeConnection(connection);
+        }
+    }
+    /**
+     * Close a specific connection
+     */
+    closeConnection(connection) {
+        const connectionId = this.getConnectionId(connection);
+        if (connectionId) {
+            this.connections.delete(connectionId);
+        }
+        connection.state = CONNECTION_STATES.CLOSING;
+        try {
+            if (!connection.socket.destroyed) {
+                connection.socket.destroy();
+            }
+        }
+        catch (error) {
+            logDebug('Error closing connection', this.options, { error });
+        }
+        logConnection('disconnected', this.options, { connectionId });
+        this.emit('disconnect', connection);
+    }
+    /**
+     * Close all connections
+     */
+    closeAllConnections() {
+        logDebug('Closing all connections', this.options);
+        for (const connection of this.connections.values()) {
+            this.closeConnection(connection);
+        }
+        this.connections.clear();
+        this.pendingConnections.clear();
+        if (this.idleTimeout) {
+            clearInterval(this.idleTimeout);
+            this.idleTimeout = null;
+        }
+    }
+    /**
+     * Get connection pool status
+     */
+    getPoolStatus() {
+        const total = this.connections.size;
+        const active = Array.from(this.connections.values())
+            .filter(conn => conn.state === CONNECTION_STATES.BUSY).length;
+        const idle = total - active;
+        const pending = this.pendingConnections.size;
+        return { total, active, idle, pending };
+    }
+    /**
+     * Update connection activity timestamp
+     */
+    updateActivity(connection) {
+        connection.lastActivity = new Date();
+    }
+    async establishSocket() {
+        return new Promise((resolve, reject) => {
+            const timeout = this.options.connectionTimeout || DEFAULTS.CONNECTION_TIMEOUT;
+            let socket;
+            if (this.options.secure) {
+                // Direct TLS connection
+                socket = tls.connect({
+                    host: this.options.host,
+                    port: this.options.port,
+                    ...this.options.tls
+                });
+            }
+            else {
+                // Plain connection
+                socket = new net.Socket();
+                socket.connect(this.options.port, this.options.host);
+            }
+            const timeoutHandler = setTimeout(() => {
+                socket.destroy();
+                reject(new Error(`Connection timeout after ${timeout}ms`));
+            }, timeout);
+            // For TLS connections, we need to wait for 'secureConnect' instead of 'connect'
+            const successEvent = this.options.secure ? 'secureConnect' : 'connect';
+            socket.once(successEvent, () => {
+                clearTimeout(timeoutHandler);
+                resolve(socket);
+            });
+            socket.once('error', (error) => {
+                clearTimeout(timeoutHandler);
+                reject(error);
+            });
+        });
+    }
+    setupSocketHandlers(socket, connectionId) {
+        const socketTimeout = this.options.socketTimeout || DEFAULTS.SOCKET_TIMEOUT;
+        socket.setTimeout(socketTimeout);
+        socket.on('timeout', () => {
+            logDebug('Socket timeout', this.options, { connectionId });
+            socket.destroy();
+        });
+        socket.on('error', (error) => {
+            logConnection('error', this.options, { connectionId, error });
+            this.connections.delete(connectionId);
+        });
+        socket.on('close', () => {
+            this.connections.delete(connectionId);
+            logDebug('Socket closed', this.options, { connectionId });
+        });
+    }
+    findIdleConnection() {
+        for (const connection of this.connections.values()) {
+            if (connection.state === CONNECTION_STATES.READY) {
+                return connection;
+            }
+        }
+        return null;
+    }
+    shouldReuseConnection(connection) {
+        const maxMessages = this.options.maxMessages || DEFAULTS.MAX_MESSAGES;
+        const maxAge = 300000; // 5 minutes
+        const age = Date.now() - connection.createdAt.getTime();
+        return connection.messageCount < maxMessages &&
+            age < maxAge &&
+            !connection.socket.destroyed;
+    }
+    getActiveConnectionCount() {
+        return this.connections.size + this.pendingConnections.size;
+    }
+    getConnectionId(connection) {
+        for (const [id, conn] of this.connections.entries()) {
+            if (conn === connection) {
+                return id;
+            }
+        }
+        return null;
+    }
+    setupIdleCleanup() {
+        if (!this.options.pool) {
+            return;
+        }
+        const cleanupInterval = DEFAULTS.POOL_IDLE_TIMEOUT;
+        this.idleTimeout = setInterval(() => {
+            const now = Date.now();
+            const connectionsToClose = [];
+            for (const connection of this.connections.values()) {
+                const idleTime = now - connection.lastActivity.getTime();
+                if (connection.state === CONNECTION_STATES.READY && idleTime > cleanupInterval) {
+                    connectionsToClose.push(connection);
+                }
+            }
+            for (const connection of connectionsToClose) {
+                logDebug('Closing idle connection', this.options);
+                this.closeConnection(connection);
+            }
+        }, cleanupInterval);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection-manager.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpclient/connection-manager.ts"],"names":[],"mappings":"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"}