@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/delivery/classes.smtp.client.legacy.js

@@ -0,0 +1,973 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
+import { MtaConnectionError, MtaAuthenticationError, MtaDeliveryError, MtaConfigurationError, MtaTimeoutError, MtaProtocolError } from '../../errors/index.js';
+import { Email } from '../core/classes.email.js';
+/**
+ * SMTP client for sending emails to remote mail servers
+ */
+export class SmtpClient {
+    /**
+     * Create a new SMTP client instance
+     * @param options SMTP client connection options
+     */
+    constructor(options) {
+        this.connected = false;
+        this.supportedExtensions = new Set();
+        /**
+         * Send SMTP command and wait for response
+         * @param command SMTP command to send
+         */
+        // Queue for command pipelining
+        this.commandQueue = [];
+        // Flag to indicate if we're currently processing commands
+        this.processingCommands = false;
+        // Flag to indicate if server supports pipelining
+        this.supportsPipelining = false;
+        // Set default options
+        this.options = {
+            ...options,
+            connectionTimeout: options.connectionTimeout || 30000, // 30 seconds
+            socketTimeout: options.socketTimeout || 60000, // 60 seconds
+            commandTimeout: options.commandTimeout || 30000, // 30 seconds
+            secure: options.secure || false,
+            domain: options.domain || 'localhost',
+            tls: {
+                rejectUnauthorized: options.tls?.rejectUnauthorized !== false, // Default to true
+                minVersion: options.tls?.minVersion || 'TLSv1.2'
+            }
+        };
+    }
+    /**
+     * Connect to the SMTP server
+     */
+    async connect() {
+        if (this.connected && this.socket) {
+            return;
+        }
+        try {
+            logger.log('info', `Connecting to SMTP server ${this.options.host}:${this.options.port}`);
+            // Create socket
+            const socket = new plugins.net.Socket();
+            // Set timeouts
+            socket.setTimeout(this.options.socketTimeout);
+            // Connect to the server
+            await new Promise((resolve, reject) => {
+                // Handle connection events
+                socket.once('connect', () => {
+                    logger.log('debug', `Connected to ${this.options.host}:${this.options.port}`);
+                    resolve();
+                });
+                socket.once('timeout', () => {
+                    reject(MtaConnectionError.timeout(this.options.host, this.options.port, this.options.connectionTimeout));
+                });
+                socket.once('error', (err) => {
+                    if (err.code === 'ECONNREFUSED') {
+                        reject(MtaConnectionError.refused(this.options.host, this.options.port));
+                    }
+                    else if (err.code === 'ENOTFOUND') {
+                        reject(MtaConnectionError.dnsError(this.options.host, err));
+                    }
+                    else {
+                        reject(new MtaConnectionError(`Connection error to ${this.options.host}:${this.options.port}: ${err.message}`, {
+                            data: {
+                                host: this.options.host,
+                                port: this.options.port,
+                                error: err.message,
+                                code: err.code
+                            }
+                        }));
+                    }
+                });
+                // Connect to the server
+                const connectOptions = {
+                    host: this.options.host,
+                    port: this.options.port
+                };
+                // For direct TLS connections
+                if (this.options.secure) {
+                    const tlsSocket = plugins.tls.connect({
+                        ...connectOptions,
+                        rejectUnauthorized: this.options.tls.rejectUnauthorized,
+                        minVersion: this.options.tls.minVersion,
+                        ca: this.options.tls.ca ? [this.options.tls.ca] : undefined
+                    });
+                    tlsSocket.once('secureConnect', () => {
+                        logger.log('debug', `Secure connection established to ${this.options.host}:${this.options.port}`);
+                        this.socket = tlsSocket;
+                        resolve();
+                    });
+                    tlsSocket.once('error', (err) => {
+                        reject(new MtaConnectionError(`TLS connection error to ${this.options.host}:${this.options.port}: ${err.message}`, {
+                            data: {
+                                host: this.options.host,
+                                port: this.options.port,
+                                error: err.message,
+                                code: err.code
+                            }
+                        }));
+                    });
+                    tlsSocket.setTimeout(this.options.socketTimeout);
+                    tlsSocket.once('timeout', () => {
+                        reject(MtaConnectionError.timeout(this.options.host, this.options.port, this.options.connectionTimeout));
+                    });
+                }
+                else {
+                    socket.connect(connectOptions);
+                    this.socket = socket;
+                }
+            });
+            // Wait for server greeting
+            const greeting = await this.readResponse();
+            if (!greeting.startsWith('220')) {
+                throw new MtaConnectionError(`Unexpected greeting from server: ${greeting}`, {
+                    data: {
+                        host: this.options.host,
+                        port: this.options.port,
+                        greeting
+                    }
+                });
+            }
+            // Send EHLO
+            await this.sendEhlo();
+            // Start TLS if not secure and supported
+            if (!this.options.secure && this.supportedExtensions.has('STARTTLS')) {
+                await this.startTls();
+                // Send EHLO again after STARTTLS
+                await this.sendEhlo();
+            }
+            // Authenticate if credentials provided
+            if (this.options.auth) {
+                await this.authenticate();
+            }
+            this.connected = true;
+            logger.log('info', `Successfully connected to SMTP server ${this.options.host}:${this.options.port}`);
+            // Set up error handling for the socket
+            this.socket.on('error', (err) => {
+                logger.log('error', `Socket error: ${err.message}`);
+                this.connected = false;
+                this.socket = undefined;
+            });
+            this.socket.on('close', () => {
+                logger.log('debug', 'Socket closed');
+                this.connected = false;
+                this.socket = undefined;
+            });
+            this.socket.on('timeout', () => {
+                logger.log('error', 'Socket timeout');
+                this.connected = false;
+                if (this.socket) {
+                    this.socket.destroy();
+                    this.socket = undefined;
+                }
+            });
+        }
+        catch (error) {
+            // Clean up socket if connection failed
+            if (this.socket) {
+                this.socket.destroy();
+                this.socket = undefined;
+            }
+            logger.log('error', `Failed to connect to SMTP server: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Send EHLO command to the server
+     */
+    async sendEhlo() {
+        // Clear previous extensions
+        this.supportedExtensions.clear();
+        // Send EHLO - don't allow pipelining for this command
+        const response = await this.sendCommand(`EHLO ${this.options.domain}`, false);
+        // Parse supported extensions
+        const lines = response.split('\r\n');
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.startsWith('250-') || line.startsWith('250 ')) {
+                const extension = line.substring(4).split(' ')[0];
+                this.supportedExtensions.add(extension);
+            }
+        }
+        // Check if server supports pipelining
+        this.supportsPipelining = this.supportedExtensions.has('PIPELINING');
+        logger.log('debug', `Server supports extensions: ${Array.from(this.supportedExtensions).join(', ')}`);
+        if (this.supportsPipelining) {
+            logger.log('info', 'Server supports PIPELINING - will use for improved performance');
+        }
+    }
+    /**
+     * Start TLS negotiation
+     */
+    async startTls() {
+        logger.log('debug', 'Starting TLS negotiation');
+        // Send STARTTLS command
+        const response = await this.sendCommand('STARTTLS');
+        if (!response.startsWith('220')) {
+            throw new MtaConnectionError(`Failed to start TLS: ${response}`, {
+                data: {
+                    host: this.options.host,
+                    port: this.options.port,
+                    response
+                }
+            });
+        }
+        if (!this.socket) {
+            throw new MtaConnectionError('No socket available for TLS upgrade', {
+                data: {
+                    host: this.options.host,
+                    port: this.options.port
+                }
+            });
+        }
+        // Upgrade socket to TLS
+        const currentSocket = this.socket;
+        this.socket = await this.upgradeTls(currentSocket);
+    }
+    /**
+     * Upgrade socket to TLS
+     * @param socket Original socket
+     */
+    async upgradeTls(socket) {
+        return new Promise((resolve, reject) => {
+            const tlsOptions = {
+                socket,
+                servername: this.options.host,
+                rejectUnauthorized: this.options.tls.rejectUnauthorized,
+                minVersion: this.options.tls.minVersion,
+                ca: this.options.tls.ca ? [this.options.tls.ca] : undefined
+            };
+            const tlsSocket = plugins.tls.connect(tlsOptions);
+            tlsSocket.once('secureConnect', () => {
+                logger.log('debug', 'TLS negotiation successful');
+                resolve(tlsSocket);
+            });
+            tlsSocket.once('error', (err) => {
+                reject(new MtaConnectionError(`TLS error: ${err.message}`, {
+                    data: {
+                        host: this.options.host,
+                        port: this.options.port,
+                        error: err.message,
+                        code: err.code
+                    }
+                }));
+            });
+            tlsSocket.setTimeout(this.options.socketTimeout);
+            tlsSocket.once('timeout', () => {
+                reject(MtaTimeoutError.commandTimeout('STARTTLS', this.options.host, this.options.socketTimeout));
+            });
+        });
+    }
+    /**
+     * Authenticate with the server
+     */
+    async authenticate() {
+        if (!this.options.auth) {
+            return;
+        }
+        const { user, pass, method = 'LOGIN' } = this.options.auth;
+        logger.log('debug', `Authenticating as ${user} using ${method}`);
+        try {
+            switch (method) {
+                case 'PLAIN':
+                    await this.authPlain(user, pass);
+                    break;
+                case 'LOGIN':
+                    await this.authLogin(user, pass);
+                    break;
+                case 'OAUTH2':
+                    await this.authOAuth2(user, pass);
+                    break;
+                default:
+                    throw new MtaAuthenticationError(`Authentication method ${method} not supported by client`, {
+                        data: {
+                            method
+                        }
+                    });
+            }
+            logger.log('info', `Successfully authenticated as ${user}`);
+        }
+        catch (error) {
+            logger.log('error', `Authentication failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Authenticate using PLAIN method
+     * @param user Username
+     * @param pass Password
+     */
+    async authPlain(user, pass) {
+        // PLAIN authentication format: \0username\0password
+        const authString = Buffer.from(`\0${user}\0${pass}`).toString('base64');
+        const response = await this.sendCommand(`AUTH PLAIN ${authString}`);
+        if (!response.startsWith('235')) {
+            throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
+        }
+    }
+    /**
+     * Authenticate using LOGIN method
+     * @param user Username
+     * @param pass Password
+     */
+    async authLogin(user, pass) {
+        // Start LOGIN authentication
+        const response = await this.sendCommand('AUTH LOGIN');
+        if (!response.startsWith('334')) {
+            throw new MtaAuthenticationError(`Server did not accept AUTH LOGIN: ${response}`, {
+                data: {
+                    host: this.options.host,
+                    response
+                }
+            });
+        }
+        // Send username (base64)
+        const userResponse = await this.sendCommand(Buffer.from(user).toString('base64'));
+        if (!userResponse.startsWith('334')) {
+            throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
+        }
+        // Send password (base64)
+        const passResponse = await this.sendCommand(Buffer.from(pass).toString('base64'));
+        if (!passResponse.startsWith('235')) {
+            throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
+        }
+    }
+    /**
+     * Authenticate using OAuth2 method
+     * @param user Username
+     * @param token OAuth2 token
+     */
+    async authOAuth2(user, token) {
+        // XOAUTH2 format
+        const authString = `user=${user}\x01auth=Bearer ${token}\x01\x01`;
+        const response = await this.sendCommand(`AUTH XOAUTH2 ${Buffer.from(authString).toString('base64')}`);
+        if (!response.startsWith('235')) {
+            throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
+        }
+    }
+    /**
+     * Send an email through the SMTP client
+     * @param email Email to send
+     * @param processingMode Optional processing mode
+     */
+    async sendMail(email, processingMode) {
+        // Ensure we're connected
+        if (!this.connected || !this.socket) {
+            await this.connect();
+        }
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            acceptedRecipients: [],
+            rejectedRecipients: [],
+            timestamp: startTime,
+            secure: this.options.secure || this.socket instanceof plugins.tls.TLSSocket,
+            authenticated: !!this.options.auth
+        };
+        try {
+            logger.log('info', `Sending email to ${email.getAllRecipients().join(', ')}`);
+            // Apply DKIM signing if configured
+            if (this.options.dkim?.enabled) {
+                await this.applyDkimSignature(email);
+                result.dkimSigned = true;
+            }
+            // Get envelope and recipients
+            const envelope_from = email.getEnvelopeFrom() || email.from;
+            const recipients = email.getAllRecipients();
+            // Check if we can use pipelining for MAIL FROM and RCPT TO commands
+            if (this.supportsPipelining && recipients.length > 0) {
+                logger.log('debug', 'Using SMTP pipelining for sending');
+                // Send MAIL FROM command first (always needed)
+                const mailFromCmd = `MAIL FROM:<${envelope_from}> SIZE=${this.getEmailSize(email)}`;
+                let mailFromResponse;
+                try {
+                    mailFromResponse = await this.sendCommand(mailFromCmd);
+                    if (!mailFromResponse.startsWith('250')) {
+                        throw new MtaDeliveryError(`MAIL FROM command failed: ${mailFromResponse}`, {
+                            data: {
+                                command: mailFromCmd,
+                                response: mailFromResponse
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    logger.log('error', `MAIL FROM failed: ${error.message}`);
+                    throw error;
+                }
+                // Pipeline all RCPT TO commands
+                const rcptPromises = recipients.map(recipient => {
+                    return this.sendCommand(`RCPT TO:<${recipient}>`)
+                        .then(response => {
+                        if (response.startsWith('250')) {
+                            result.acceptedRecipients.push(recipient);
+                            return { recipient, accepted: true, response };
+                        }
+                        else {
+                            result.rejectedRecipients.push(recipient);
+                            logger.log('warn', `Recipient ${recipient} rejected: ${response}`);
+                            return { recipient, accepted: false, response };
+                        }
+                    })
+                        .catch(error => {
+                        result.rejectedRecipients.push(recipient);
+                        logger.log('warn', `Recipient ${recipient} rejected with error: ${error.message}`);
+                        return { recipient, accepted: false, error: error.message };
+                    });
+                });
+                // Wait for all RCPT TO commands to complete
+                await Promise.all(rcptPromises);
+            }
+            else {
+                // Fall back to sequential commands if pipelining not supported
+                logger.log('debug', 'Using sequential SMTP commands for sending');
+                // Send MAIL FROM
+                await this.sendCommand(`MAIL FROM:<${envelope_from}> SIZE=${this.getEmailSize(email)}`);
+                // Send RCPT TO for each recipient
+                for (const recipient of recipients) {
+                    try {
+                        await this.sendCommand(`RCPT TO:<${recipient}>`);
+                        result.acceptedRecipients.push(recipient);
+                    }
+                    catch (error) {
+                        logger.log('warn', `Recipient ${recipient} rejected: ${error.message}`);
+                        result.rejectedRecipients.push(recipient);
+                    }
+                }
+            }
+            // Check if at least one recipient was accepted
+            if (result.acceptedRecipients.length === 0) {
+                throw new MtaDeliveryError('All recipients were rejected', {
+                    data: {
+                        recipients,
+                        rejectedRecipients: result.rejectedRecipients
+                    }
+                });
+            }
+            // Send DATA
+            const dataResponse = await this.sendCommand('DATA');
+            if (!dataResponse.startsWith('354')) {
+                throw new MtaProtocolError(`Failed to start DATA phase: ${dataResponse}`, {
+                    data: {
+                        response: dataResponse
+                    }
+                });
+            }
+            // Format email content efficiently
+            const emailContent = await this.getFormattedEmail(email);
+            // Send email content
+            const finalResponse = await this.sendCommand(emailContent + '\r\n.');
+            // Extract message ID if available
+            const messageIdMatch = finalResponse.match(/\[(.*?)\]/);
+            if (messageIdMatch) {
+                result.messageId = messageIdMatch[1];
+            }
+            result.success = true;
+            result.response = finalResponse;
+            logger.log('info', `Email sent successfully to ${result.acceptedRecipients.join(', ')}`);
+            // Log security event
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_DELIVERY,
+                message: 'Email sent successfully',
+                details: {
+                    recipients: result.acceptedRecipients,
+                    rejectedRecipients: result.rejectedRecipients,
+                    messageId: result.messageId,
+                    secure: result.secure,
+                    authenticated: result.authenticated,
+                    server: `${this.options.host}:${this.options.port}`,
+                    dkimSigned: result.dkimSigned
+                },
+                success: true
+            });
+            return result;
+        }
+        catch (error) {
+            logger.log('error', `Failed to send email: ${error.message}`);
+            // Format error for result
+            result.error = error.message;
+            // Extract SMTP code if available
+            if (error.context?.data?.statusCode) {
+                result.responseCode = error.context.data.statusCode;
+            }
+            // Log security event
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_DELIVERY,
+                message: 'Email delivery failed',
+                details: {
+                    error: error.message,
+                    server: `${this.options.host}:${this.options.port}`,
+                    recipients: email.getAllRecipients(),
+                    acceptedRecipients: result.acceptedRecipients,
+                    rejectedRecipients: result.rejectedRecipients,
+                    secure: result.secure,
+                    authenticated: result.authenticated
+                },
+                success: false
+            });
+            return result;
+        }
+    }
+    /**
+     * Apply DKIM signature to email
+     * @param email Email to sign
+     */
+    async applyDkimSignature(email) {
+        if (!this.options.dkim?.enabled || !this.options.dkim?.privateKey) {
+            return;
+        }
+        try {
+            logger.log('debug', `Signing email with DKIM for domain ${this.options.dkim.domain}`);
+            // Format email for DKIM signing
+            const { dkimSign } = plugins;
+            const emailContent = await this.getFormattedEmail(email);
+            // Sign email
+            const signOptions = {
+                domainName: this.options.dkim.domain,
+                keySelector: this.options.dkim.selector,
+                privateKey: this.options.dkim.privateKey,
+                headerFieldNames: this.options.dkim.headers || [
+                    'from', 'to', 'subject', 'date', 'message-id'
+                ]
+            };
+            const signedEmail = await dkimSign(emailContent, signOptions);
+            // Replace headers in original email
+            const dkimHeader = signedEmail.substring(0, signedEmail.indexOf('\r\n\r\n')).split('\r\n')
+                .find(line => line.startsWith('DKIM-Signature: '));
+            if (dkimHeader) {
+                email.addHeader('DKIM-Signature', dkimHeader.substring('DKIM-Signature: '.length));
+            }
+            logger.log('debug', 'DKIM signature applied successfully');
+        }
+        catch (error) {
+            logger.log('error', `Failed to apply DKIM signature: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Format email for SMTP transmission
+     * @param email Email to format
+     */
+    async getFormattedEmail(email) {
+        // This is a simplified implementation
+        // In a full implementation, this would use proper MIME formatting
+        let content = '';
+        // Add headers
+        content += `From: ${email.from}\r\n`;
+        content += `To: ${email.to.join(', ')}\r\n`;
+        content += `Subject: ${email.subject}\r\n`;
+        content += `Date: ${new Date().toUTCString()}\r\n`;
+        content += `Message-ID: <${plugins.uuid.v4()}@${this.options.domain}>\r\n`;
+        // Add additional headers
+        for (const [name, value] of Object.entries(email.headers || {})) {
+            content += `${name}: ${value}\r\n`;
+        }
+        // Add content type for multipart
+        if (email.attachments && email.attachments.length > 0) {
+            const boundary = `----_=_NextPart_${Math.random().toString(36).substr(2)}`;
+            content += `MIME-Version: 1.0\r\n`;
+            content += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n`;
+            content += `\r\n`;
+            // Add text part
+            content += `--${boundary}\r\n`;
+            content += `Content-Type: text/plain; charset="UTF-8"\r\n`;
+            content += `\r\n`;
+            content += `${email.text}\r\n`;
+            // Add HTML part if present
+            if (email.html) {
+                content += `--${boundary}\r\n`;
+                content += `Content-Type: text/html; charset="UTF-8"\r\n`;
+                content += `\r\n`;
+                content += `${email.html}\r\n`;
+            }
+            // Add attachments
+            for (const attachment of email.attachments) {
+                content += `--${boundary}\r\n`;
+                content += `Content-Type: ${attachment.contentType || 'application/octet-stream'}; name="${attachment.filename}"\r\n`;
+                content += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
+                content += `Content-Transfer-Encoding: base64\r\n`;
+                content += `\r\n`;
+                // Add base64 encoded content
+                const base64Content = attachment.content.toString('base64');
+                // Split into lines of 76 characters
+                for (let i = 0; i < base64Content.length; i += 76) {
+                    content += base64Content.substring(i, i + 76) + '\r\n';
+                }
+            }
+            // End boundary
+            content += `--${boundary}--\r\n`;
+        }
+        else {
+            // Simple email with just text
+            content += `Content-Type: text/plain; charset="UTF-8"\r\n`;
+            content += `\r\n`;
+            content += `${email.text}\r\n`;
+        }
+        return content;
+    }
+    /**
+     * Get size of email in bytes
+     * @param email Email to measure
+     */
+    getEmailSize(email) {
+        // Simplified size estimation
+        let size = 0;
+        // Headers
+        size += `From: ${email.from}\r\n`.length;
+        size += `To: ${email.to.join(', ')}\r\n`.length;
+        size += `Subject: ${email.subject}\r\n`.length;
+        // Body
+        size += (email.text?.length || 0) + 2; // +2 for CRLF
+        // HTML part if present
+        if (email.html) {
+            size += email.html.length + 2;
+        }
+        // Attachments
+        for (const attachment of email.attachments || []) {
+            size += attachment.content.length;
+        }
+        // Add overhead for MIME boundaries and headers
+        const overhead = email.attachments?.length ? 1000 + (email.attachments.length * 200) : 200;
+        return size + overhead;
+    }
+    /**
+     * Send an SMTP command and wait for response
+     * @param command SMTP command to send
+     * @param allowPipelining Whether this command can be pipelined
+     */
+    async sendCommand(command, allowPipelining = true) {
+        if (!this.socket) {
+            throw new MtaConnectionError('Not connected to server', {
+                data: {
+                    host: this.options.host,
+                    port: this.options.port
+                }
+            });
+        }
+        // Log command if not sensitive
+        if (!command.startsWith('AUTH')) {
+            logger.log('debug', `> ${command}`);
+        }
+        else {
+            logger.log('debug', '> AUTH ***');
+        }
+        return new Promise((resolve, reject) => {
+            // Set up timeout for command
+            const timeout = setTimeout(() => {
+                // Remove this command from the queue if it times out
+                const index = this.commandQueue.findIndex(item => item.command === command);
+                if (index !== -1) {
+                    this.commandQueue.splice(index, 1);
+                }
+                reject(MtaTimeoutError.commandTimeout(command.split(' ')[0], this.options.host, this.options.commandTimeout));
+            }, this.options.commandTimeout);
+            // Add command to the queue
+            this.commandQueue.push({
+                command,
+                resolve,
+                reject,
+                timeout
+            });
+            // Process command queue if we can pipeline or if not currently processing commands
+            if ((this.supportsPipelining && allowPipelining) || !this.processingCommands) {
+                this.processCommandQueue();
+            }
+        });
+    }
+    /**
+     * Process the command queue - either one by one or pipelined if supported
+     */
+    processCommandQueue() {
+        if (this.processingCommands || this.commandQueue.length === 0 || !this.socket) {
+            return;
+        }
+        this.processingCommands = true;
+        try {
+            // If pipelining is supported, send all commands at once
+            if (this.supportsPipelining) {
+                // Send all commands in queue at once
+                const commands = this.commandQueue.map(item => item.command).join('\r\n') + '\r\n';
+                this.socket.write(commands, (err) => {
+                    if (err) {
+                        // Handle write error for all commands
+                        const error = new MtaConnectionError(`Failed to send commands: ${err.message}`, {
+                            data: {
+                                error: err.message
+                            }
+                        });
+                        // Fail all pending commands
+                        while (this.commandQueue.length > 0) {
+                            const item = this.commandQueue.shift();
+                            clearTimeout(item.timeout);
+                            item.reject(error);
+                        }
+                        this.processingCommands = false;
+                    }
+                });
+                // Process responses one by one in order
+                this.processResponses();
+            }
+            else {
+                // Process commands one by one if pipelining not supported
+                this.processNextCommand();
+            }
+        }
+        catch (error) {
+            logger.log('error', `Error processing command queue: ${error.message}`);
+            this.processingCommands = false;
+        }
+    }
+    /**
+     * Process the next command in the queue (non-pipelined mode)
+     */
+    processNextCommand() {
+        if (this.commandQueue.length === 0 || !this.socket) {
+            this.processingCommands = false;
+            return;
+        }
+        const currentCommand = this.commandQueue[0];
+        this.socket.write(currentCommand.command + '\r\n', (err) => {
+            if (err) {
+                // Handle write error
+                const error = new MtaConnectionError(`Failed to send command: ${err.message}`, {
+                    data: {
+                        command: currentCommand.command.split(' ')[0],
+                        error: err.message
+                    }
+                });
+                // Remove from queue
+                this.commandQueue.shift();
+                clearTimeout(currentCommand.timeout);
+                currentCommand.reject(error);
+                // Continue with next command
+                this.processNextCommand();
+                return;
+            }
+            // Read response
+            this.readResponse()
+                .then((response) => {
+                // Remove from queue and resolve
+                this.commandQueue.shift();
+                clearTimeout(currentCommand.timeout);
+                currentCommand.resolve(response);
+                // Process next command
+                this.processNextCommand();
+            })
+                .catch((err) => {
+                // Remove from queue and reject
+                this.commandQueue.shift();
+                clearTimeout(currentCommand.timeout);
+                currentCommand.reject(err);
+                // Process next command
+                this.processNextCommand();
+            });
+        });
+    }
+    /**
+     * Process responses for pipelined commands
+     */
+    async processResponses() {
+        try {
+            // Process responses for each command in order
+            while (this.commandQueue.length > 0) {
+                const currentCommand = this.commandQueue[0];
+                try {
+                    // Wait for response
+                    const response = await this.readResponse();
+                    // Remove from queue and resolve
+                    this.commandQueue.shift();
+                    clearTimeout(currentCommand.timeout);
+                    currentCommand.resolve(response);
+                }
+                catch (error) {
+                    // Remove from queue and reject
+                    this.commandQueue.shift();
+                    clearTimeout(currentCommand.timeout);
+                    currentCommand.reject(error);
+                    // Stop processing if this is a critical error
+                    if (error instanceof MtaConnectionError &&
+                        (error.message.includes('Connection closed') || error.message.includes('Not connected'))) {
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.log('error', `Error processing responses: ${error.message}`);
+        }
+        finally {
+            this.processingCommands = false;
+        }
+    }
+    /**
+     * Read response from the server
+     */
+    async readResponse() {
+        if (!this.socket) {
+            throw new MtaConnectionError('Not connected to server', {
+                data: {
+                    host: this.options.host,
+                    port: this.options.port
+                }
+            });
+        }
+        return new Promise((resolve, reject) => {
+            // Use an array to collect response chunks instead of string concatenation
+            const responseChunks = [];
+            // Single function to clean up all listeners
+            const cleanupListeners = () => {
+                if (!this.socket)
+                    return;
+                this.socket.removeListener('data', onData);
+                this.socket.removeListener('error', onError);
+                this.socket.removeListener('close', onClose);
+                this.socket.removeListener('end', onEnd);
+            };
+            const onData = (data) => {
+                // Store buffer directly, avoiding unnecessary string conversion
+                responseChunks.push(data);
+                // Convert to string only for response checking
+                const responseData = Buffer.concat(responseChunks).toString();
+                // Check if this is a complete response
+                if (this.isCompleteResponse(responseData)) {
+                    // Clean up listeners
+                    cleanupListeners();
+                    const trimmedResponse = responseData.trim();
+                    logger.log('debug', `< ${trimmedResponse}`);
+                    // Check if this is an error response
+                    if (this.isErrorResponse(responseData)) {
+                        const code = responseData.substring(0, 3);
+                        reject(this.createErrorFromResponse(trimmedResponse, code));
+                    }
+                    else {
+                        resolve(trimmedResponse);
+                    }
+                }
+            };
+            const onError = (err) => {
+                cleanupListeners();
+                reject(new MtaConnectionError(`Socket error while waiting for response: ${err.message}`, {
+                    data: {
+                        error: err.message
+                    }
+                }));
+            };
+            const onClose = () => {
+                cleanupListeners();
+                const responseData = Buffer.concat(responseChunks).toString();
+                reject(new MtaConnectionError('Connection closed while waiting for response', {
+                    data: {
+                        partialResponse: responseData
+                    }
+                }));
+            };
+            const onEnd = () => {
+                cleanupListeners();
+                const responseData = Buffer.concat(responseChunks).toString();
+                reject(new MtaConnectionError('Connection ended while waiting for response', {
+                    data: {
+                        partialResponse: responseData
+                    }
+                }));
+            };
+            // Set up listeners
+            this.socket.on('data', onData);
+            this.socket.once('error', onError);
+            this.socket.once('close', onClose);
+            this.socket.once('end', onEnd);
+        });
+    }
+    /**
+     * Check if the response is complete
+     * @param response Response to check
+     */
+    isCompleteResponse(response) {
+        // Check if it's a multi-line response
+        const lines = response.split('\r\n');
+        const lastLine = lines[lines.length - 2]; // Second to last because of the trailing CRLF
+        // Check if the last line starts with a code followed by a space
+        // If it does, this is a complete response
+        if (lastLine && /^\d{3} /.test(lastLine)) {
+            return true;
+        }
+        // For single line responses
+        if (lines.length === 2 && lines[0].length >= 3 && /^\d{3} /.test(lines[0])) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if the response is an error
+     * @param response Response to check
+     */
+    isErrorResponse(response) {
+        // Get the status code (first 3 characters)
+        const code = response.substring(0, 3);
+        // 4xx and 5xx are error codes
+        return code.startsWith('4') || code.startsWith('5');
+    }
+    /**
+     * Create appropriate error from response
+     * @param response Error response
+     * @param code SMTP status code
+     */
+    createErrorFromResponse(response, code) {
+        // Extract message part
+        const message = response.substring(4).trim();
+        switch (code.charAt(0)) {
+            case '4': // Temporary errors
+                return MtaDeliveryError.temporary(message, 'recipient', code, response);
+            case '5': // Permanent errors
+                return MtaDeliveryError.permanent(message, 'recipient', code, response);
+            default:
+                return new MtaDeliveryError(`Unexpected error response: ${response}`, {
+                    data: {
+                        response,
+                        code
+                    }
+                });
+        }
+    }
+    /**
+     * Close the connection to the server
+     */
+    async close() {
+        if (!this.connected || !this.socket) {
+            return;
+        }
+        try {
+            // Send QUIT
+            await this.sendCommand('QUIT');
+        }
+        catch (error) {
+            logger.log('warn', `Error sending QUIT command: ${error.message}`);
+        }
+        finally {
+            // Close socket
+            this.socket.destroy();
+            this.socket = undefined;
+            this.connected = false;
+            logger.log('info', 'SMTP connection closed');
+        }
+    }
+    /**
+     * Checks if the connection is active
+     */
+    isConnected() {
+        return this.connected && !!this.socket;
+    }
+    /**
+     * Update SMTP client options
+     * @param options New options
+     */
+    updateOptions(options) {
+        this.options = {
+            ...this.options,
+            ...options
+        };
+        logger.log('info', 'SMTP client options updated');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smtp.client.legacy.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.smtp.client.legacy.ts"],"names":[],"mappings":"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"}