BREAKING CHANGE(smtp-client): Replace the legacy TypeScript SMTP client with a new Rust-based SMTP client and IPC bridge for outbound delivery
This commit is contained in:
@@ -3,6 +3,6 @@
|
||||
*/
|
||||
export const commitinfo = {
|
||||
name: '@push.rocks/smartmta',
|
||||
version: '3.0.0',
|
||||
version: '4.0.0',
|
||||
description: 'A high-performance, enterprise-grade Mail Transfer Agent (MTA) built from scratch in TypeScript with Rust acceleration.'
|
||||
}
|
||||
|
||||
@@ -1,17 +1,14 @@
|
||||
import * as plugins from '../../plugins.js';
|
||||
import { EventEmitter } from 'node:events';
|
||||
import * as net from 'node:net';
|
||||
import * as tls from 'node:tls';
|
||||
import { logger } from '../../logger.js';
|
||||
import {
|
||||
SecurityLogger,
|
||||
SecurityLogLevel,
|
||||
SecurityEventType
|
||||
import {
|
||||
SecurityLogger,
|
||||
SecurityLogLevel,
|
||||
SecurityEventType
|
||||
} from '../../security/index.js';
|
||||
import { UnifiedDeliveryQueue, type IQueueItem } from './classes.delivery.queue.js';
|
||||
import type { Email } from '../core/classes.email.js';
|
||||
import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
|
||||
import type { SmtpClient } from './smtpclient/smtp-client.js';
|
||||
import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
|
||||
|
||||
/**
|
||||
@@ -117,7 +114,7 @@ export class MultiModeDeliverySystem extends EventEmitter {
|
||||
* Create a new multi-mode delivery system
|
||||
* @param queue Unified delivery queue
|
||||
* @param options Delivery options
|
||||
* @param emailServer Optional reference to unified email server for SmtpClient access
|
||||
* @param emailServer Optional reference to unified email server for outbound delivery
|
||||
*/
|
||||
constructor(queue: UnifiedDeliveryQueue, options: IMultiModeDeliveryOptions, emailServer?: UnifiedEmailServer) {
|
||||
super();
|
||||
@@ -433,191 +430,52 @@ export class MultiModeDeliverySystem extends EventEmitter {
|
||||
*/
|
||||
private async handleForwardDelivery(item: IQueueItem): Promise<any> {
|
||||
logger.log('info', `Forward delivery for item ${item.id}`);
|
||||
|
||||
|
||||
const email = item.processingResult as Email;
|
||||
const route = item.route;
|
||||
|
||||
|
||||
// Get target server information
|
||||
const targetServer = route?.action.forward?.host;
|
||||
const targetPort = route?.action.forward?.port || 25;
|
||||
const useTls = false; // TLS configuration can be enhanced later
|
||||
|
||||
|
||||
if (!targetServer) {
|
||||
throw new Error('No target server configured for forward mode');
|
||||
}
|
||||
|
||||
logger.log('info', `Forwarding email to ${targetServer}:${targetPort}, TLS: ${useTls}`);
|
||||
|
||||
|
||||
logger.log('info', `Forwarding email to ${targetServer}:${targetPort}`);
|
||||
|
||||
try {
|
||||
// Get SMTP client from email server if available
|
||||
if (!this.emailServer) {
|
||||
// Fall back to raw socket implementation if no email server
|
||||
logger.log('warn', 'No email server available, falling back to raw socket implementation');
|
||||
return this.handleForwardDeliveryLegacy(item);
|
||||
throw new Error('No email server available for forward delivery');
|
||||
}
|
||||
|
||||
// Get SMTP client from UnifiedEmailServer
|
||||
const smtpClient = this.emailServer.getSmtpClient(targetServer, targetPort);
|
||||
|
||||
// Apply DKIM signing if configured in the route
|
||||
if (item.route?.action.options?.mtaOptions?.dkimSign) {
|
||||
await this.applyDkimSigning(email, item.route.action.options.mtaOptions);
|
||||
}
|
||||
|
||||
// Send the email using SmtpClient
|
||||
const result = await smtpClient.sendMail(email);
|
||||
|
||||
if (result.success) {
|
||||
logger.log('info', `Email forwarded successfully to ${targetServer}:${targetPort}`);
|
||||
|
||||
return {
|
||||
targetServer: targetServer,
|
||||
targetPort: targetPort,
|
||||
recipients: result.acceptedRecipients.length,
|
||||
messageId: result.messageId,
|
||||
rejectedRecipients: result.rejectedRecipients
|
||||
};
|
||||
} else {
|
||||
throw new Error(result.error?.message || 'Failed to forward email');
|
||||
}
|
||||
} catch (error: any) {
|
||||
logger.log('error', `Failed to forward email: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Legacy forward delivery using raw sockets (fallback)
|
||||
* @param item Queue item
|
||||
*/
|
||||
private async handleForwardDeliveryLegacy(item: IQueueItem): Promise<any> {
|
||||
const email = item.processingResult as Email;
|
||||
const route = item.route;
|
||||
|
||||
// Get target server information
|
||||
const targetServer = route?.action.forward?.host;
|
||||
const targetPort = route?.action.forward?.port || 25;
|
||||
const useTls = false; // TLS configuration can be enhanced later
|
||||
|
||||
if (!targetServer) {
|
||||
throw new Error('No target server configured for forward mode');
|
||||
}
|
||||
|
||||
// Create a socket connection to the target server
|
||||
const socket = new net.Socket();
|
||||
|
||||
// Set timeout
|
||||
socket.setTimeout(this.options.socketTimeout);
|
||||
|
||||
try {
|
||||
// Connect to the target server
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
// Handle connection events
|
||||
socket.on('connect', () => {
|
||||
logger.log('debug', `Connected to ${targetServer}:${targetPort}`);
|
||||
resolve();
|
||||
});
|
||||
|
||||
socket.on('timeout', () => {
|
||||
reject(new Error(`Connection timeout to ${targetServer}:${targetPort}`));
|
||||
});
|
||||
|
||||
socket.on('error', (err) => {
|
||||
reject(new Error(`Connection error to ${targetServer}:${targetPort}: ${err.message}`));
|
||||
});
|
||||
|
||||
// Connect to the server
|
||||
socket.connect({
|
||||
host: targetServer,
|
||||
port: targetPort
|
||||
});
|
||||
|
||||
// Build DKIM options from route config
|
||||
const dkimDomain = item.route?.action.options?.mtaOptions?.dkimSign
|
||||
? (item.route.action.options.mtaOptions.dkimOptions?.domainName || email.from.split('@')[1])
|
||||
: undefined;
|
||||
const dkimSelector = item.route?.action.options?.mtaOptions?.dkimOptions?.keySelector || 'default';
|
||||
|
||||
// Build auth options from route forward config
|
||||
const auth = route?.action.forward?.auth as { user: string; pass: string } | undefined;
|
||||
|
||||
// Send via Rust SMTP client
|
||||
const result = await this.emailServer.sendOutboundEmail(targetServer, targetPort, email, {
|
||||
auth,
|
||||
dkimDomain,
|
||||
dkimSelector,
|
||||
});
|
||||
|
||||
// Send EHLO
|
||||
await this.smtpCommand(socket, `EHLO ${route?.action.options?.mtaOptions?.domain || 'localhost'}`);
|
||||
|
||||
// Start TLS if required
|
||||
if (useTls) {
|
||||
await this.smtpCommand(socket, 'STARTTLS');
|
||||
|
||||
// Upgrade to TLS
|
||||
const tlsSocket = await this.upgradeTls(socket, targetServer);
|
||||
|
||||
// Send EHLO again after STARTTLS
|
||||
await this.smtpCommand(tlsSocket, `EHLO ${route?.action.options?.mtaOptions?.domain || 'localhost'}`);
|
||||
|
||||
// Use tlsSocket for remaining commands
|
||||
return this.completeSMTPExchange(tlsSocket, email, route);
|
||||
}
|
||||
|
||||
// Complete the SMTP exchange
|
||||
return this.completeSMTPExchange(socket, email, route);
|
||||
} catch (error: any) {
|
||||
logger.log('error', `Failed to forward email: ${error.message}`);
|
||||
|
||||
// Close the connection
|
||||
socket.destroy();
|
||||
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Complete the SMTP exchange after connection and initial setup
|
||||
* @param socket Network socket
|
||||
* @param email Email to send
|
||||
* @param rule Domain rule
|
||||
*/
|
||||
private async completeSMTPExchange(socket: net.Socket | tls.TLSSocket, email: Email, route: any): Promise<any> {
|
||||
try {
|
||||
// Authenticate if credentials provided
|
||||
if (route?.action?.forward?.auth?.user && route?.action?.forward?.auth?.pass) {
|
||||
// Send AUTH LOGIN
|
||||
await this.smtpCommand(socket, 'AUTH LOGIN');
|
||||
|
||||
// Send username (base64)
|
||||
const username = Buffer.from(route.action.forward.auth.user).toString('base64');
|
||||
await this.smtpCommand(socket, username);
|
||||
|
||||
// Send password (base64)
|
||||
const password = Buffer.from(route.action.forward.auth.pass).toString('base64');
|
||||
await this.smtpCommand(socket, password);
|
||||
}
|
||||
|
||||
// Send MAIL FROM
|
||||
await this.smtpCommand(socket, `MAIL FROM:<${email.from}>`);
|
||||
|
||||
// Send RCPT TO for each recipient
|
||||
for (const recipient of email.getAllRecipients()) {
|
||||
await this.smtpCommand(socket, `RCPT TO:<${recipient}>`);
|
||||
}
|
||||
|
||||
// Send DATA
|
||||
await this.smtpCommand(socket, 'DATA');
|
||||
|
||||
// Send email content (simplified)
|
||||
const emailContent = await this.getFormattedEmail(email);
|
||||
await this.smtpData(socket, emailContent);
|
||||
|
||||
// Send QUIT
|
||||
await this.smtpCommand(socket, 'QUIT');
|
||||
|
||||
// Close the connection
|
||||
socket.end();
|
||||
|
||||
logger.log('info', `Email forwarded successfully to ${route?.action?.forward?.host}:${route?.action?.forward?.port || 25}`);
|
||||
|
||||
|
||||
logger.log('info', `Email forwarded successfully to ${targetServer}:${targetPort}`);
|
||||
|
||||
return {
|
||||
targetServer: route?.action?.forward?.host,
|
||||
targetPort: route?.action?.forward?.port || 25,
|
||||
recipients: email.getAllRecipients().length
|
||||
targetServer,
|
||||
targetPort,
|
||||
recipients: result.accepted.length,
|
||||
messageId: result.messageId,
|
||||
rejectedRecipients: result.rejected,
|
||||
};
|
||||
} catch (error: any) {
|
||||
logger.log('error', `Failed to forward email: ${error.message}`);
|
||||
|
||||
// Close the connection
|
||||
socket.destroy();
|
||||
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -790,210 +648,6 @@ export class MultiModeDeliverySystem extends EventEmitter {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Format email for SMTP transmission
|
||||
* @param email Email to format
|
||||
*/
|
||||
private async getFormattedEmail(email: Email): Promise<string> {
|
||||
// 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`;
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send SMTP command and wait for response
|
||||
* @param socket Socket connection
|
||||
* @param command SMTP command to send
|
||||
*/
|
||||
private async smtpCommand(socket: net.Socket, command: string): Promise<string> {
|
||||
return new Promise<string>((resolve, reject) => {
|
||||
const onData = (data: Buffer) => {
|
||||
const response = data.toString().trim();
|
||||
|
||||
// Clean up listeners
|
||||
socket.removeListener('data', onData);
|
||||
socket.removeListener('error', onError);
|
||||
socket.removeListener('timeout', onTimeout);
|
||||
|
||||
// Check response code
|
||||
if (response.charAt(0) === '2' || response.charAt(0) === '3') {
|
||||
resolve(response);
|
||||
} else {
|
||||
reject(new Error(`SMTP error: ${response}`));
|
||||
}
|
||||
};
|
||||
|
||||
const onError = (err: Error) => {
|
||||
// Clean up listeners
|
||||
socket.removeListener('data', onData);
|
||||
socket.removeListener('error', onError);
|
||||
socket.removeListener('timeout', onTimeout);
|
||||
|
||||
reject(err);
|
||||
};
|
||||
|
||||
const onTimeout = () => {
|
||||
// Clean up listeners
|
||||
socket.removeListener('data', onData);
|
||||
socket.removeListener('error', onError);
|
||||
socket.removeListener('timeout', onTimeout);
|
||||
|
||||
reject(new Error('SMTP command timeout'));
|
||||
};
|
||||
|
||||
// Set up listeners
|
||||
socket.once('data', onData);
|
||||
socket.once('error', onError);
|
||||
socket.once('timeout', onTimeout);
|
||||
|
||||
// Send command
|
||||
socket.write(command + '\r\n');
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Send SMTP DATA command with content
|
||||
* @param socket Socket connection
|
||||
* @param data Email content to send
|
||||
*/
|
||||
private async smtpData(socket: net.Socket, data: string): Promise<string> {
|
||||
return new Promise<string>((resolve, reject) => {
|
||||
const onData = (responseData: Buffer) => {
|
||||
const response = responseData.toString().trim();
|
||||
|
||||
// Clean up listeners
|
||||
socket.removeListener('data', onData);
|
||||
socket.removeListener('error', onError);
|
||||
socket.removeListener('timeout', onTimeout);
|
||||
|
||||
// Check response code
|
||||
if (response.charAt(0) === '2') {
|
||||
resolve(response);
|
||||
} else {
|
||||
reject(new Error(`SMTP error: ${response}`));
|
||||
}
|
||||
};
|
||||
|
||||
const onError = (err: Error) => {
|
||||
// Clean up listeners
|
||||
socket.removeListener('data', onData);
|
||||
socket.removeListener('error', onError);
|
||||
socket.removeListener('timeout', onTimeout);
|
||||
|
||||
reject(err);
|
||||
};
|
||||
|
||||
const onTimeout = () => {
|
||||
// Clean up listeners
|
||||
socket.removeListener('data', onData);
|
||||
socket.removeListener('error', onError);
|
||||
socket.removeListener('timeout', onTimeout);
|
||||
|
||||
reject(new Error('SMTP data timeout'));
|
||||
};
|
||||
|
||||
// Set up listeners
|
||||
socket.once('data', onData);
|
||||
socket.once('error', onError);
|
||||
socket.once('timeout', onTimeout);
|
||||
|
||||
// Send data and end with CRLF.CRLF
|
||||
socket.write(data + '\r\n.\r\n');
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Upgrade socket to TLS
|
||||
* @param socket Socket connection
|
||||
* @param hostname Target hostname for TLS
|
||||
*/
|
||||
private async upgradeTls(socket: net.Socket, hostname: string): Promise<tls.TLSSocket> {
|
||||
return new Promise<tls.TLSSocket>((resolve, reject) => {
|
||||
const tlsOptions: tls.ConnectionOptions = {
|
||||
socket,
|
||||
servername: hostname,
|
||||
rejectUnauthorized: this.options.verifyCertificates,
|
||||
minVersion: this.options.tlsMinVersion as tls.SecureVersion
|
||||
};
|
||||
|
||||
const tlsSocket = tls.connect(tlsOptions);
|
||||
|
||||
tlsSocket.once('secureConnect', () => {
|
||||
resolve(tlsSocket);
|
||||
});
|
||||
|
||||
tlsSocket.once('error', (err) => {
|
||||
reject(new Error(`TLS error: ${err.message}`));
|
||||
});
|
||||
|
||||
tlsSocket.setTimeout(this.options.socketTimeout);
|
||||
|
||||
tlsSocket.once('timeout', () => {
|
||||
reject(new Error('TLS connection timeout'));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Update delivery time statistics
|
||||
*/
|
||||
|
||||
@@ -1,425 +0,0 @@
|
||||
import * as plugins from '../../plugins.js';
|
||||
import * as paths from '../../paths.js';
|
||||
import { Email } from '../core/classes.email.js';
|
||||
import { EmailSignJob } from './classes.emailsignjob.js';
|
||||
import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
|
||||
import type { SmtpClient } from './smtpclient/smtp-client.js';
|
||||
import type { ISmtpSendResult } from './smtpclient/interfaces.js';
|
||||
|
||||
// Configuration options for email sending
|
||||
export interface IEmailSendOptions {
|
||||
maxRetries?: number;
|
||||
retryDelay?: number; // in milliseconds
|
||||
connectionTimeout?: number; // in milliseconds
|
||||
tlsOptions?: plugins.tls.ConnectionOptions;
|
||||
debugMode?: boolean;
|
||||
}
|
||||
|
||||
// Email delivery status
|
||||
export enum DeliveryStatus {
|
||||
PENDING = 'pending',
|
||||
SENDING = 'sending',
|
||||
DELIVERED = 'delivered',
|
||||
FAILED = 'failed',
|
||||
DEFERRED = 'deferred' // Temporary failure, will retry
|
||||
}
|
||||
|
||||
// Detailed information about delivery attempts
|
||||
export interface DeliveryInfo {
|
||||
status: DeliveryStatus;
|
||||
attempts: number;
|
||||
error?: Error;
|
||||
lastAttempt?: Date;
|
||||
nextAttempt?: Date;
|
||||
mxServer?: string;
|
||||
deliveryTime?: Date;
|
||||
logs: string[];
|
||||
}
|
||||
|
||||
export class EmailSendJob {
|
||||
emailServerRef: UnifiedEmailServer;
|
||||
private email: Email;
|
||||
private mxServers: string[] = [];
|
||||
private currentMxIndex = 0;
|
||||
private options: IEmailSendOptions;
|
||||
public deliveryInfo: DeliveryInfo;
|
||||
|
||||
constructor(emailServerRef: UnifiedEmailServer, emailArg: Email, options: IEmailSendOptions = {}) {
|
||||
this.email = emailArg;
|
||||
this.emailServerRef = emailServerRef;
|
||||
|
||||
// Set default options
|
||||
this.options = {
|
||||
maxRetries: options.maxRetries || 3,
|
||||
retryDelay: options.retryDelay || 30000, // 30 seconds
|
||||
connectionTimeout: options.connectionTimeout || 60000, // 60 seconds
|
||||
tlsOptions: options.tlsOptions || {},
|
||||
debugMode: options.debugMode || false
|
||||
};
|
||||
|
||||
// Initialize delivery info
|
||||
this.deliveryInfo = {
|
||||
status: DeliveryStatus.PENDING,
|
||||
attempts: 0,
|
||||
logs: []
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the email to its recipients
|
||||
*/
|
||||
async send(): Promise<DeliveryStatus> {
|
||||
try {
|
||||
// Check if the email is valid before attempting to send
|
||||
this.validateEmail();
|
||||
|
||||
// Resolve MX records for the recipient domain
|
||||
await this.resolveMxRecords();
|
||||
|
||||
// Try to send the email
|
||||
return await this.attemptDelivery();
|
||||
} catch (error) {
|
||||
this.log(`Critical error in send process: ${error.message}`);
|
||||
this.deliveryInfo.status = DeliveryStatus.FAILED;
|
||||
this.deliveryInfo.error = error;
|
||||
|
||||
// Save failed email for potential future retry or analysis
|
||||
await this.saveFailed();
|
||||
return DeliveryStatus.FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate the email before sending
|
||||
*/
|
||||
private validateEmail(): void {
|
||||
if (!this.email.to || this.email.to.length === 0) {
|
||||
throw new Error('No recipients specified');
|
||||
}
|
||||
|
||||
if (!this.email.from) {
|
||||
throw new Error('No sender specified');
|
||||
}
|
||||
|
||||
const fromDomain = this.email.getFromDomain();
|
||||
if (!fromDomain) {
|
||||
throw new Error('Invalid sender domain');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve MX records for the recipient domain
|
||||
*/
|
||||
private async resolveMxRecords(): Promise<void> {
|
||||
const domain = this.email.getPrimaryRecipient()?.split('@')[1];
|
||||
if (!domain) {
|
||||
throw new Error('Invalid recipient domain');
|
||||
}
|
||||
|
||||
this.log(`Resolving MX records for domain: ${domain}`);
|
||||
try {
|
||||
const addresses = await this.resolveMx(domain);
|
||||
|
||||
// Sort by priority (lowest number = highest priority)
|
||||
addresses.sort((a, b) => a.priority - b.priority);
|
||||
|
||||
this.mxServers = addresses.map(mx => mx.exchange);
|
||||
this.log(`Found ${this.mxServers.length} MX servers: ${this.mxServers.join(', ')}`);
|
||||
|
||||
if (this.mxServers.length === 0) {
|
||||
throw new Error(`No MX records found for domain: ${domain}`);
|
||||
}
|
||||
} catch (error) {
|
||||
this.log(`Failed to resolve MX records: ${error.message}`);
|
||||
throw new Error(`MX lookup failed for ${domain}: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempt to deliver the email with retries
|
||||
*/
|
||||
private async attemptDelivery(): Promise<DeliveryStatus> {
|
||||
while (this.deliveryInfo.attempts < this.options.maxRetries) {
|
||||
this.deliveryInfo.attempts++;
|
||||
this.deliveryInfo.lastAttempt = new Date();
|
||||
this.deliveryInfo.status = DeliveryStatus.SENDING;
|
||||
|
||||
try {
|
||||
this.log(`Delivery attempt ${this.deliveryInfo.attempts} of ${this.options.maxRetries}`);
|
||||
|
||||
// Try each MX server in order of priority
|
||||
while (this.currentMxIndex < this.mxServers.length) {
|
||||
const currentMx = this.mxServers[this.currentMxIndex];
|
||||
this.deliveryInfo.mxServer = currentMx;
|
||||
|
||||
try {
|
||||
this.log(`Attempting delivery to MX server: ${currentMx}`);
|
||||
await this.connectAndSend(currentMx);
|
||||
|
||||
// If we get here, email was sent successfully
|
||||
this.deliveryInfo.status = DeliveryStatus.DELIVERED;
|
||||
this.deliveryInfo.deliveryTime = new Date();
|
||||
this.log(`Email delivered successfully to ${currentMx}`);
|
||||
|
||||
// Record delivery for sender reputation monitoring
|
||||
this.recordDeliveryEvent('delivered');
|
||||
|
||||
// Save successful email record
|
||||
await this.saveSuccess();
|
||||
return DeliveryStatus.DELIVERED;
|
||||
} catch (error) {
|
||||
this.log(`Failed to deliver to ${currentMx}: ${error.message}`);
|
||||
this.currentMxIndex++;
|
||||
|
||||
// If this MX server failed, try the next one
|
||||
if (this.currentMxIndex >= this.mxServers.length) {
|
||||
throw error; // No more MX servers to try
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
throw new Error('All MX servers failed');
|
||||
} catch (error) {
|
||||
this.deliveryInfo.error = error;
|
||||
|
||||
// Check if this is a permanent failure
|
||||
if (this.isPermanentFailure(error)) {
|
||||
this.log('Permanent failure detected, not retrying');
|
||||
this.deliveryInfo.status = DeliveryStatus.FAILED;
|
||||
|
||||
// Record permanent failure for bounce management
|
||||
this.recordDeliveryEvent('bounced', true);
|
||||
|
||||
await this.saveFailed();
|
||||
return DeliveryStatus.FAILED;
|
||||
}
|
||||
|
||||
// This is a temporary failure
|
||||
if (this.deliveryInfo.attempts < this.options.maxRetries) {
|
||||
this.log(`Temporary failure, will retry in ${this.options.retryDelay}ms`);
|
||||
this.deliveryInfo.status = DeliveryStatus.DEFERRED;
|
||||
this.deliveryInfo.nextAttempt = new Date(Date.now() + this.options.retryDelay);
|
||||
|
||||
// Record temporary failure for monitoring
|
||||
this.recordDeliveryEvent('deferred');
|
||||
|
||||
// Reset MX server index for next retry
|
||||
this.currentMxIndex = 0;
|
||||
|
||||
// Wait before retrying
|
||||
await this.delay(this.options.retryDelay);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If we get here, all retries failed
|
||||
this.deliveryInfo.status = DeliveryStatus.FAILED;
|
||||
await this.saveFailed();
|
||||
return DeliveryStatus.FAILED;
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to a specific MX server and send the email using SmtpClient
|
||||
*/
|
||||
private async connectAndSend(mxServer: string): Promise<void> {
|
||||
this.log(`Connecting to ${mxServer}:25`);
|
||||
|
||||
try {
|
||||
// Get SMTP client from UnifiedEmailServer
|
||||
const smtpClient = this.emailServerRef.getSmtpClient(mxServer, 25);
|
||||
|
||||
// Sign the email with DKIM if available
|
||||
let signedEmail = this.email;
|
||||
try {
|
||||
const fromDomain = this.email.getFromDomain();
|
||||
if (fromDomain && this.emailServerRef.hasDkimKey(fromDomain)) {
|
||||
// Convert email to RFC822 format for signing
|
||||
const emailMessage = this.email.toRFC822String();
|
||||
|
||||
// Create sign job with proper options
|
||||
const emailSignJob = new EmailSignJob(this.emailServerRef, {
|
||||
domain: fromDomain,
|
||||
selector: 'default', // Using default selector
|
||||
headers: {}, // Headers will be extracted from emailMessage
|
||||
body: emailMessage
|
||||
});
|
||||
|
||||
// Get the DKIM signature header
|
||||
const signatureHeader = await emailSignJob.getSignatureHeader(emailMessage);
|
||||
|
||||
// Add the signature to the email
|
||||
if (signatureHeader) {
|
||||
// For now, we'll use the email as-is since SmtpClient will handle DKIM
|
||||
this.log(`Email ready for DKIM signing for domain: ${fromDomain}`);
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
this.log(`Failed to prepare DKIM: ${error.message}`);
|
||||
}
|
||||
|
||||
// Send the email using SmtpClient
|
||||
const result: ISmtpSendResult = await smtpClient.sendMail(signedEmail);
|
||||
|
||||
if (result.success) {
|
||||
this.log(`Email sent successfully: ${result.response}`);
|
||||
|
||||
// Record the send for reputation monitoring
|
||||
this.recordDeliveryEvent('delivered');
|
||||
} else {
|
||||
throw new Error(result.error?.message || 'Failed to send email');
|
||||
}
|
||||
} catch (error) {
|
||||
this.log(`Failed to send email via ${mxServer}: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Record delivery event for monitoring
|
||||
*/
|
||||
private recordDeliveryEvent(
|
||||
eventType: 'delivered' | 'bounced' | 'deferred',
|
||||
isHardBounce: boolean = false
|
||||
): void {
|
||||
try {
|
||||
const domain = this.email.getFromDomain();
|
||||
if (domain) {
|
||||
if (eventType === 'delivered') {
|
||||
this.emailServerRef.recordDelivery(domain);
|
||||
} else if (eventType === 'bounced') {
|
||||
// Get the receiving domain for bounce recording
|
||||
let receivingDomain = null;
|
||||
const primaryRecipient = this.email.getPrimaryRecipient();
|
||||
if (primaryRecipient) {
|
||||
receivingDomain = primaryRecipient.split('@')[1];
|
||||
}
|
||||
|
||||
if (receivingDomain) {
|
||||
this.emailServerRef.recordBounce(
|
||||
domain,
|
||||
receivingDomain,
|
||||
isHardBounce ? 'hard' : 'soft',
|
||||
this.deliveryInfo.error?.message || 'Unknown error'
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
this.log(`Failed to record delivery event: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if an error represents a permanent failure
|
||||
*/
|
||||
private isPermanentFailure(error: Error): boolean {
|
||||
const permanentFailurePatterns = [
|
||||
'User unknown',
|
||||
'No such user',
|
||||
'Mailbox not found',
|
||||
'Invalid recipient',
|
||||
'Account disabled',
|
||||
'Account suspended',
|
||||
'Domain not found',
|
||||
'No such domain',
|
||||
'Invalid domain',
|
||||
'Relay access denied',
|
||||
'Access denied',
|
||||
'Blacklisted',
|
||||
'Blocked',
|
||||
'550', // Permanent failure SMTP code
|
||||
'551',
|
||||
'552',
|
||||
'553',
|
||||
'554'
|
||||
];
|
||||
|
||||
const errorMessage = error.message.toLowerCase();
|
||||
return permanentFailurePatterns.some(pattern =>
|
||||
errorMessage.includes(pattern.toLowerCase())
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve MX records for a domain
|
||||
*/
|
||||
private resolveMx(domain: string): Promise<plugins.dns.MxRecord[]> {
|
||||
return new Promise((resolve, reject) => {
|
||||
plugins.dns.resolveMx(domain, (err, addresses) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve(addresses || []);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Log a message with timestamp
|
||||
*/
|
||||
private log(message: string): void {
|
||||
const timestamp = new Date().toISOString();
|
||||
const logEntry = `[${timestamp}] ${message}`;
|
||||
this.deliveryInfo.logs.push(logEntry);
|
||||
|
||||
if (this.options.debugMode) {
|
||||
console.log(`[EmailSendJob] ${logEntry}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Save successful email to storage
|
||||
*/
|
||||
private async saveSuccess(): Promise<void> {
|
||||
try {
|
||||
// Use the existing email storage path
|
||||
const emailContent = this.email.toRFC822String();
|
||||
const fileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_success.eml`;
|
||||
const filePath = plugins.path.join(paths.sentEmailsDir, fileName);
|
||||
|
||||
await plugins.smartfs.directory(paths.sentEmailsDir).recursive().create();
|
||||
await plugins.smartfs.file(filePath).write(emailContent);
|
||||
|
||||
// Also save delivery info
|
||||
const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_info.json`;
|
||||
const infoPath = plugins.path.join(paths.sentEmailsDir, infoFileName);
|
||||
await plugins.smartfs.file(infoPath).write(JSON.stringify(this.deliveryInfo, null, 2));
|
||||
|
||||
this.log(`Email saved to ${fileName}`);
|
||||
} catch (error) {
|
||||
this.log(`Failed to save email: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Save failed email to storage
|
||||
*/
|
||||
private async saveFailed(): Promise<void> {
|
||||
try {
|
||||
// Use the existing email storage path
|
||||
const emailContent = this.email.toRFC822String();
|
||||
const fileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_failed.eml`;
|
||||
const filePath = plugins.path.join(paths.failedEmailsDir, fileName);
|
||||
|
||||
await plugins.smartfs.directory(paths.failedEmailsDir).recursive().create();
|
||||
await plugins.smartfs.file(filePath).write(emailContent);
|
||||
|
||||
// Also save delivery info with error details
|
||||
const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_error.json`;
|
||||
const infoPath = plugins.path.join(paths.failedEmailsDir, infoFileName);
|
||||
await plugins.smartfs.file(infoPath).write(JSON.stringify(this.deliveryInfo, null, 2));
|
||||
|
||||
this.log(`Failed email saved to ${fileName}`);
|
||||
} catch (error) {
|
||||
this.log(`Failed to save failed email: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Delay for specified milliseconds
|
||||
*/
|
||||
private delay(ms: number): Promise<void> {
|
||||
return new Promise(resolve => setTimeout(resolve, ms));
|
||||
}
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
import * as plugins from '../../plugins.js';
|
||||
import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
|
||||
import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
|
||||
|
||||
interface Headers {
|
||||
[key: string]: string;
|
||||
}
|
||||
|
||||
interface IEmailSignJobOptions {
|
||||
domain: string;
|
||||
selector: string;
|
||||
headers: Headers;
|
||||
body: string;
|
||||
}
|
||||
|
||||
export class EmailSignJob {
|
||||
emailServerRef: UnifiedEmailServer;
|
||||
jobOptions: IEmailSignJobOptions;
|
||||
|
||||
constructor(emailServerRef: UnifiedEmailServer, options: IEmailSignJobOptions) {
|
||||
this.emailServerRef = emailServerRef;
|
||||
this.jobOptions = options;
|
||||
}
|
||||
|
||||
async loadPrivateKey(): Promise<string> {
|
||||
const keyInfo = await this.emailServerRef.dkimCreator.readDKIMKeys(this.jobOptions.domain);
|
||||
return keyInfo.privateKey;
|
||||
}
|
||||
|
||||
public async getSignatureHeader(emailMessage: string): Promise<string> {
|
||||
const privateKey = await this.loadPrivateKey();
|
||||
const bridge = RustSecurityBridge.getInstance();
|
||||
const signResult = await bridge.signDkim({
|
||||
rawMessage: emailMessage,
|
||||
domain: this.jobOptions.domain,
|
||||
selector: this.jobOptions.selector,
|
||||
privateKey,
|
||||
});
|
||||
return signResult.header;
|
||||
}
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
import * as plugins from '../../plugins.js';
|
||||
import * as paths from '../../paths.js';
|
||||
import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
|
||||
|
||||
/**
|
||||
* Configures email server storage settings
|
||||
* @param emailServer Reference to the unified email server
|
||||
* @param options Configuration options containing storage paths
|
||||
*/
|
||||
export async function configureEmailStorage(emailServer: UnifiedEmailServer, options: any): Promise<void> {
|
||||
// Extract the receivedEmailsPath if available
|
||||
if (options?.emailPortConfig?.receivedEmailsPath) {
|
||||
const receivedEmailsPath = options.emailPortConfig.receivedEmailsPath;
|
||||
|
||||
// Ensure the directory exists
|
||||
await plugins.smartfs.directory(receivedEmailsPath).recursive().create();
|
||||
|
||||
// Set path for received emails
|
||||
if (emailServer) {
|
||||
// Storage paths are now handled by the unified email server system
|
||||
await plugins.smartfs.directory(paths.receivedEmailsDir).recursive().create();
|
||||
|
||||
console.log(`Configured email server to store received emails to: ${receivedEmailsPath}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Configure email server with port and storage settings
|
||||
* @param emailServer Reference to the unified email server
|
||||
* @param config Configuration settings for email server
|
||||
*/
|
||||
export async function configureEmailServer(
|
||||
emailServer: UnifiedEmailServer,
|
||||
config: {
|
||||
ports?: number[];
|
||||
hostname?: string;
|
||||
tls?: {
|
||||
certPath?: string;
|
||||
keyPath?: string;
|
||||
caPath?: string;
|
||||
};
|
||||
storagePath?: string;
|
||||
}
|
||||
): Promise<boolean> {
|
||||
if (!emailServer) {
|
||||
console.error('Email server not available');
|
||||
return false;
|
||||
}
|
||||
|
||||
// Configure the email server with updated options
|
||||
const serverOptions = {
|
||||
ports: config.ports || [25, 587, 465],
|
||||
hostname: config.hostname || 'localhost',
|
||||
tls: config.tls
|
||||
};
|
||||
|
||||
// Update the email server options
|
||||
emailServer.updateOptions(serverOptions);
|
||||
|
||||
console.log(`Configured email server on ports ${serverOptions.ports.join(', ')}`);
|
||||
|
||||
// Set up storage path if provided
|
||||
if (config.storagePath) {
|
||||
await configureEmailStorage(emailServer, {
|
||||
emailPortConfig: {
|
||||
receivedEmailsPath: config.storagePath
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -1,325 +0,0 @@
|
||||
import { logger } from '../../logger.js';
|
||||
|
||||
/**
|
||||
* Configuration options for rate limiter
|
||||
*/
|
||||
export interface IRateLimitConfig {
|
||||
/** Maximum tokens per period */
|
||||
maxPerPeriod: number;
|
||||
|
||||
/** Time period in milliseconds */
|
||||
periodMs: number;
|
||||
|
||||
/** Whether to apply per domain/key (vs globally) */
|
||||
perKey: boolean;
|
||||
|
||||
/** Initial token count (defaults to max) */
|
||||
initialTokens?: number;
|
||||
|
||||
/** Grace tokens to allow occasional bursts */
|
||||
burstTokens?: number;
|
||||
|
||||
/** Apply global limit in addition to per-key limits */
|
||||
useGlobalLimit?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Token bucket for an individual key
|
||||
*/
|
||||
interface TokenBucket {
|
||||
/** Current number of tokens */
|
||||
tokens: number;
|
||||
|
||||
/** Last time tokens were refilled */
|
||||
lastRefill: number;
|
||||
|
||||
/** Total allowed requests */
|
||||
allowed: number;
|
||||
|
||||
/** Total denied requests */
|
||||
denied: number;
|
||||
|
||||
/** Error count for blocking decisions */
|
||||
errors: number;
|
||||
|
||||
/** Timestamp of first error in current window */
|
||||
firstErrorTime: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rate limiter using token bucket algorithm
|
||||
* Provides more sophisticated rate limiting with burst handling
|
||||
*/
|
||||
export class RateLimiter {
|
||||
/** Rate limit configuration */
|
||||
private config: IRateLimitConfig;
|
||||
|
||||
/** Token buckets per key */
|
||||
private buckets: Map<string, TokenBucket> = new Map();
|
||||
|
||||
/** Global bucket for non-keyed rate limiting */
|
||||
private globalBucket: TokenBucket;
|
||||
|
||||
/**
|
||||
* Create a new rate limiter
|
||||
* @param config Rate limiter configuration
|
||||
*/
|
||||
constructor(config: IRateLimitConfig) {
|
||||
// Set defaults
|
||||
this.config = {
|
||||
maxPerPeriod: config.maxPerPeriod,
|
||||
periodMs: config.periodMs,
|
||||
perKey: config.perKey ?? true,
|
||||
initialTokens: config.initialTokens ?? config.maxPerPeriod,
|
||||
burstTokens: config.burstTokens ?? 0,
|
||||
useGlobalLimit: config.useGlobalLimit ?? false
|
||||
};
|
||||
|
||||
// Initialize global bucket
|
||||
this.globalBucket = {
|
||||
tokens: this.config.initialTokens,
|
||||
lastRefill: Date.now(),
|
||||
allowed: 0,
|
||||
denied: 0,
|
||||
errors: 0,
|
||||
firstErrorTime: 0
|
||||
};
|
||||
|
||||
// Log initialization
|
||||
logger.log('info', `Rate limiter initialized: ${this.config.maxPerPeriod} per ${this.config.periodMs}ms${this.config.perKey ? ' per key' : ''}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a request is allowed under rate limits
|
||||
* @param key Key to check rate limit for (e.g. domain, user, IP)
|
||||
* @param cost Token cost (defaults to 1)
|
||||
* @returns Whether the request is allowed
|
||||
*/
|
||||
public isAllowed(key: string = 'global', cost: number = 1): boolean {
|
||||
// If using global bucket directly, just check that
|
||||
if (key === 'global' || !this.config.perKey) {
|
||||
return this.checkBucket(this.globalBucket, cost);
|
||||
}
|
||||
|
||||
// Get the key-specific bucket
|
||||
const bucket = this.getBucket(key);
|
||||
|
||||
// If we also need to check global limit
|
||||
if (this.config.useGlobalLimit) {
|
||||
// Both key bucket and global bucket must have tokens
|
||||
return this.checkBucket(bucket, cost) && this.checkBucket(this.globalBucket, cost);
|
||||
} else {
|
||||
// Only need to check the key-specific bucket
|
||||
return this.checkBucket(bucket, cost);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a bucket has enough tokens and consume them
|
||||
* @param bucket The token bucket to check
|
||||
* @param cost Token cost
|
||||
* @returns Whether tokens were consumed
|
||||
*/
|
||||
private checkBucket(bucket: TokenBucket, cost: number): boolean {
|
||||
// Refill tokens based on elapsed time
|
||||
this.refillBucket(bucket);
|
||||
|
||||
// Check if we have enough tokens
|
||||
if (bucket.tokens >= cost) {
|
||||
// Use tokens
|
||||
bucket.tokens -= cost;
|
||||
bucket.allowed++;
|
||||
return true;
|
||||
} else {
|
||||
// Rate limit exceeded
|
||||
bucket.denied++;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Consume tokens for a request (if available)
|
||||
* @param key Key to consume tokens for
|
||||
* @param cost Token cost (defaults to 1)
|
||||
* @returns Whether tokens were consumed
|
||||
*/
|
||||
public consume(key: string = 'global', cost: number = 1): boolean {
|
||||
const isAllowed = this.isAllowed(key, cost);
|
||||
return isAllowed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the remaining tokens for a key
|
||||
* @param key Key to check
|
||||
* @returns Number of remaining tokens
|
||||
*/
|
||||
public getRemainingTokens(key: string = 'global'): number {
|
||||
const bucket = this.getBucket(key);
|
||||
this.refillBucket(bucket);
|
||||
return bucket.tokens;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get stats for a specific key
|
||||
* @param key Key to get stats for
|
||||
* @returns Rate limit statistics
|
||||
*/
|
||||
public getStats(key: string = 'global'): {
|
||||
remaining: number;
|
||||
limit: number;
|
||||
resetIn: number;
|
||||
allowed: number;
|
||||
denied: number;
|
||||
} {
|
||||
const bucket = this.getBucket(key);
|
||||
this.refillBucket(bucket);
|
||||
|
||||
// Calculate time until next token
|
||||
const resetIn = bucket.tokens < this.config.maxPerPeriod ?
|
||||
Math.ceil(this.config.periodMs / this.config.maxPerPeriod) :
|
||||
0;
|
||||
|
||||
return {
|
||||
remaining: bucket.tokens,
|
||||
limit: this.config.maxPerPeriod,
|
||||
resetIn,
|
||||
allowed: bucket.allowed,
|
||||
denied: bucket.denied
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get or create a token bucket for a key
|
||||
* @param key The rate limit key
|
||||
* @returns Token bucket
|
||||
*/
|
||||
private getBucket(key: string): TokenBucket {
|
||||
if (!this.config.perKey || key === 'global') {
|
||||
return this.globalBucket;
|
||||
}
|
||||
|
||||
if (!this.buckets.has(key)) {
|
||||
// Create new bucket
|
||||
this.buckets.set(key, {
|
||||
tokens: this.config.initialTokens,
|
||||
lastRefill: Date.now(),
|
||||
allowed: 0,
|
||||
denied: 0,
|
||||
errors: 0,
|
||||
firstErrorTime: 0
|
||||
});
|
||||
}
|
||||
|
||||
return this.buckets.get(key);
|
||||
}
|
||||
|
||||
/**
|
||||
* Refill tokens in a bucket based on elapsed time
|
||||
* @param bucket Token bucket to refill
|
||||
*/
|
||||
private refillBucket(bucket: TokenBucket): void {
|
||||
const now = Date.now();
|
||||
const elapsedMs = now - bucket.lastRefill;
|
||||
|
||||
// Calculate how many tokens to add
|
||||
const rate = this.config.maxPerPeriod / this.config.periodMs;
|
||||
const tokensToAdd = elapsedMs * rate;
|
||||
|
||||
if (tokensToAdd >= 0.1) { // Allow for partial token refills
|
||||
// Add tokens, but don't exceed the normal maximum (without burst)
|
||||
// This ensures burst tokens are only used for bursts and don't refill
|
||||
const normalMax = this.config.maxPerPeriod;
|
||||
bucket.tokens = Math.min(
|
||||
// Don't exceed max + burst
|
||||
this.config.maxPerPeriod + (this.config.burstTokens || 0),
|
||||
// Don't exceed normal max when refilling
|
||||
Math.min(normalMax, bucket.tokens + tokensToAdd)
|
||||
);
|
||||
|
||||
// Update last refill time
|
||||
bucket.lastRefill = now;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset rate limits for a specific key
|
||||
* @param key Key to reset
|
||||
*/
|
||||
public reset(key: string = 'global'): void {
|
||||
if (key === 'global' || !this.config.perKey) {
|
||||
this.globalBucket.tokens = this.config.initialTokens;
|
||||
this.globalBucket.lastRefill = Date.now();
|
||||
} else if (this.buckets.has(key)) {
|
||||
const bucket = this.buckets.get(key);
|
||||
bucket.tokens = this.config.initialTokens;
|
||||
bucket.lastRefill = Date.now();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset all rate limiters
|
||||
*/
|
||||
public resetAll(): void {
|
||||
this.globalBucket.tokens = this.config.initialTokens;
|
||||
this.globalBucket.lastRefill = Date.now();
|
||||
|
||||
for (const bucket of this.buckets.values()) {
|
||||
bucket.tokens = this.config.initialTokens;
|
||||
bucket.lastRefill = Date.now();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup old buckets to prevent memory leaks
|
||||
* @param maxAge Maximum age in milliseconds
|
||||
*/
|
||||
public cleanup(maxAge: number = 24 * 60 * 60 * 1000): void {
|
||||
const now = Date.now();
|
||||
let removed = 0;
|
||||
|
||||
for (const [key, bucket] of this.buckets.entries()) {
|
||||
if (now - bucket.lastRefill > maxAge) {
|
||||
this.buckets.delete(key);
|
||||
removed++;
|
||||
}
|
||||
}
|
||||
|
||||
if (removed > 0) {
|
||||
logger.log('debug', `Cleaned up ${removed} stale rate limit buckets`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Record an error for a key (e.g., IP address) and determine if blocking is needed
|
||||
* RFC 5321 Section 4.5.4.1 suggests limiting errors to prevent abuse
|
||||
*
|
||||
* @param key Key to record error for (typically an IP address)
|
||||
* @param errorWindow Time window for error tracking in ms (default: 5 minutes)
|
||||
* @param errorThreshold Maximum errors before blocking (default: 10)
|
||||
* @returns true if the key should be blocked due to excessive errors
|
||||
*/
|
||||
public recordError(key: string, errorWindow: number = 5 * 60 * 1000, errorThreshold: number = 10): boolean {
|
||||
const bucket = this.getBucket(key);
|
||||
const now = Date.now();
|
||||
|
||||
// Reset error count if the time window has expired
|
||||
if (bucket.firstErrorTime === 0 || now - bucket.firstErrorTime > errorWindow) {
|
||||
bucket.errors = 0;
|
||||
bucket.firstErrorTime = now;
|
||||
}
|
||||
|
||||
// Increment error count
|
||||
bucket.errors++;
|
||||
|
||||
// Log error tracking
|
||||
logger.log('debug', `Error recorded for ${key}: ${bucket.errors}/${errorThreshold} in window`);
|
||||
|
||||
// Check if threshold exceeded
|
||||
if (bucket.errors >= errorThreshold) {
|
||||
logger.log('warn', `Error threshold exceeded for ${key}: ${bucket.errors} errors`);
|
||||
return true; // Should block
|
||||
}
|
||||
|
||||
return false; // Continue allowing
|
||||
}
|
||||
}
|
||||
@@ -1,23 +1,5 @@
|
||||
// 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';
|
||||
export type { IRateLimitConfig } 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';
|
||||
|
||||
export { smtpClientMod };
|
||||
@@ -1,232 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Authentication Handler
|
||||
* Authentication mechanisms implementation
|
||||
*/
|
||||
|
||||
import { AUTH_METHODS } from './constants.js';
|
||||
import type {
|
||||
ISmtpConnection,
|
||||
ISmtpAuthOptions,
|
||||
ISmtpClientOptions,
|
||||
ISmtpResponse,
|
||||
IOAuth2Options
|
||||
} from './interfaces.js';
|
||||
import {
|
||||
encodeAuthPlain,
|
||||
encodeAuthLogin,
|
||||
generateOAuth2String,
|
||||
isSuccessCode
|
||||
} from './utils/helpers.js';
|
||||
import { logAuthentication, logDebug } from './utils/logging.js';
|
||||
import type { CommandHandler } from './command-handler.js';
|
||||
|
||||
export class AuthHandler {
|
||||
private options: ISmtpClientOptions;
|
||||
private commandHandler: CommandHandler;
|
||||
|
||||
constructor(options: ISmtpClientOptions, commandHandler: CommandHandler) {
|
||||
this.options = options;
|
||||
this.commandHandler = commandHandler;
|
||||
}
|
||||
|
||||
/**
|
||||
* Authenticate using the configured method
|
||||
*/
|
||||
public async authenticate(connection: ISmtpConnection): Promise<void> {
|
||||
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
|
||||
*/
|
||||
private async authenticatePlain(connection: ISmtpConnection, auth: ISmtpAuthOptions): Promise<void> {
|
||||
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
|
||||
*/
|
||||
private async authenticateLogin(connection: ISmtpConnection, auth: ISmtpAuthOptions): Promise<void> {
|
||||
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
|
||||
*/
|
||||
private async authenticateOAuth2(connection: ISmtpConnection, auth: ISmtpAuthOptions): Promise<void> {
|
||||
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
|
||||
*/
|
||||
private selectAuthMethod(auth: ISmtpAuthOptions, serverMethods: Set<string>): string {
|
||||
// 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
|
||||
*/
|
||||
private isTokenExpired(oauth2: IOAuth2Options): boolean {
|
||||
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
|
||||
*/
|
||||
private async refreshOAuth2Token(oauth2: IOAuth2Options): Promise<string> {
|
||||
// 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
|
||||
*/
|
||||
public validateAuthConfig(auth: ISmtpAuthOptions): string[] {
|
||||
const errors: string[] = [];
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,343 +0,0 @@
|
||||
/**
|
||||
* 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 type {
|
||||
ISmtpConnection,
|
||||
ISmtpResponse,
|
||||
ISmtpClientOptions,
|
||||
ISmtpCapabilities
|
||||
} from './interfaces.js';
|
||||
import {
|
||||
parseSmtpResponse,
|
||||
parseEhloResponse,
|
||||
formatCommand,
|
||||
isSuccessCode
|
||||
} from './utils/helpers.js';
|
||||
import { logCommand, logDebug } from './utils/logging.js';
|
||||
|
||||
export class CommandHandler extends EventEmitter {
|
||||
private options: ISmtpClientOptions;
|
||||
private responseBuffer: string = '';
|
||||
private pendingCommand: { resolve: Function; reject: Function; command: string } | null = null;
|
||||
private commandTimeout: NodeJS.Timeout | null = null;
|
||||
|
||||
constructor(options: ISmtpClientOptions) {
|
||||
super();
|
||||
this.options = options;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send EHLO command and parse capabilities
|
||||
*/
|
||||
public async sendEhlo(connection: ISmtpConnection, domain?: string): Promise<ISmtpCapabilities> {
|
||||
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
|
||||
*/
|
||||
public async sendMailFrom(connection: ISmtpConnection, fromAddress: string): Promise<ISmtpResponse> {
|
||||
// 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
|
||||
*/
|
||||
public async sendRcptTo(connection: ISmtpConnection, toAddress: string): Promise<ISmtpResponse> {
|
||||
const command = `${SMTP_COMMANDS.RCPT_TO}:<${toAddress}>`;
|
||||
return this.sendCommand(connection, command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send DATA command
|
||||
*/
|
||||
public async sendData(connection: ISmtpConnection): Promise<ISmtpResponse> {
|
||||
return this.sendCommand(connection, SMTP_COMMANDS.DATA);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send email data content
|
||||
*/
|
||||
public async sendDataContent(connection: ISmtpConnection, emailData: string): Promise<ISmtpResponse> {
|
||||
// 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
|
||||
*/
|
||||
public async sendRset(connection: ISmtpConnection): Promise<ISmtpResponse> {
|
||||
return this.sendCommand(connection, SMTP_COMMANDS.RSET);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send NOOP command
|
||||
*/
|
||||
public async sendNoop(connection: ISmtpConnection): Promise<ISmtpResponse> {
|
||||
return this.sendCommand(connection, SMTP_COMMANDS.NOOP);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send QUIT command
|
||||
*/
|
||||
public async sendQuit(connection: ISmtpConnection): Promise<ISmtpResponse> {
|
||||
return this.sendCommand(connection, SMTP_COMMANDS.QUIT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send STARTTLS command
|
||||
*/
|
||||
public async sendStartTls(connection: ISmtpConnection): Promise<ISmtpResponse> {
|
||||
return this.sendCommand(connection, SMTP_COMMANDS.STARTTLS);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send AUTH command
|
||||
*/
|
||||
public async sendAuth(connection: ISmtpConnection, method: string, credentials?: string): Promise<ISmtpResponse> {
|
||||
const command = credentials ?
|
||||
`${SMTP_COMMANDS.AUTH} ${method} ${credentials}` :
|
||||
`${SMTP_COMMANDS.AUTH} ${method}`;
|
||||
return this.sendCommand(connection, command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a generic SMTP command
|
||||
*/
|
||||
public async sendCommand(connection: ISmtpConnection, command: string): Promise<ISmtpResponse> {
|
||||
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: Buffer) => {
|
||||
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: ISmtpResponse) => {
|
||||
cleanup();
|
||||
this.pendingCommand = null;
|
||||
logCommand(command, response, this.options);
|
||||
originalResolve(response);
|
||||
};
|
||||
|
||||
this.pendingCommand.reject = (error: Error) => {
|
||||
cleanup();
|
||||
this.pendingCommand = null;
|
||||
originalReject(error);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Send raw data without command formatting
|
||||
*/
|
||||
public async sendRawData(connection: ISmtpConnection, data: string): Promise<ISmtpResponse> {
|
||||
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: Buffer) => {
|
||||
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: ISmtpResponse) => {
|
||||
cleanup();
|
||||
this.pendingCommand = null;
|
||||
originalResolve(response);
|
||||
};
|
||||
|
||||
this.pendingCommand.reject = (error: 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
|
||||
*/
|
||||
public async waitForGreeting(connection: ISmtpConnection): Promise<ISmtpResponse> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const timeout = 30000; // 30 seconds
|
||||
let timeoutHandler: NodeJS.Timeout;
|
||||
|
||||
const dataHandler = (data: Buffer) => {
|
||||
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);
|
||||
});
|
||||
}
|
||||
|
||||
private handleIncomingData(data: string): void {
|
||||
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}`));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private isCompleteResponse(buffer: string): boolean {
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
@@ -1,289 +0,0 @@
|
||||
/**
|
||||
* 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 type {
|
||||
ISmtpClientOptions,
|
||||
ISmtpConnection,
|
||||
IConnectionPoolStatus,
|
||||
ConnectionState
|
||||
} from './interfaces.js';
|
||||
import { logConnection, logDebug } from './utils/logging.js';
|
||||
import { generateConnectionId } from './utils/helpers.js';
|
||||
|
||||
export class ConnectionManager extends EventEmitter {
|
||||
private options: ISmtpClientOptions;
|
||||
private connections: Map<string, ISmtpConnection> = new Map();
|
||||
private pendingConnections: Set<string> = new Set();
|
||||
private idleTimeout: NodeJS.Timeout | null = null;
|
||||
|
||||
constructor(options: ISmtpClientOptions) {
|
||||
super();
|
||||
this.options = options;
|
||||
this.setupIdleCleanup();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get or create a connection
|
||||
*/
|
||||
public async getConnection(): Promise<ISmtpConnection> {
|
||||
// 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
|
||||
*/
|
||||
public async createConnection(): Promise<ISmtpConnection> {
|
||||
const connectionId = generateConnectionId();
|
||||
|
||||
try {
|
||||
this.pendingConnections.add(connectionId);
|
||||
logConnection('connecting', this.options, { connectionId });
|
||||
|
||||
const socket = await this.establishSocket();
|
||||
const connection: ISmtpConnection = {
|
||||
socket,
|
||||
state: CONNECTION_STATES.CONNECTED as ConnectionState,
|
||||
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
|
||||
*/
|
||||
public releaseConnection(connection: ISmtpConnection): void {
|
||||
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 as ConnectionState;
|
||||
connection.lastActivity = new Date();
|
||||
logDebug('Connection returned to pool', this.options, { connectionId });
|
||||
} else {
|
||||
// Close connection
|
||||
this.closeConnection(connection);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close a specific connection
|
||||
*/
|
||||
public closeConnection(connection: ISmtpConnection): void {
|
||||
const connectionId = this.getConnectionId(connection);
|
||||
|
||||
if (connectionId) {
|
||||
this.connections.delete(connectionId);
|
||||
}
|
||||
|
||||
connection.state = CONNECTION_STATES.CLOSING as ConnectionState;
|
||||
|
||||
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
|
||||
*/
|
||||
public closeAllConnections(): void {
|
||||
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
|
||||
*/
|
||||
public getPoolStatus(): IConnectionPoolStatus {
|
||||
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
|
||||
*/
|
||||
public updateActivity(connection: ISmtpConnection): void {
|
||||
connection.lastActivity = new Date();
|
||||
}
|
||||
|
||||
private async establishSocket(): Promise<net.Socket | tls.TLSSocket> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const timeout = this.options.connectionTimeout || DEFAULTS.CONNECTION_TIMEOUT;
|
||||
let socket: net.Socket | tls.TLSSocket;
|
||||
|
||||
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);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
private setupSocketHandlers(socket: net.Socket | tls.TLSSocket, connectionId: string): void {
|
||||
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 });
|
||||
});
|
||||
}
|
||||
|
||||
private findIdleConnection(): ISmtpConnection | null {
|
||||
for (const connection of this.connections.values()) {
|
||||
if (connection.state === CONNECTION_STATES.READY) {
|
||||
return connection;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private shouldReuseConnection(connection: ISmtpConnection): boolean {
|
||||
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;
|
||||
}
|
||||
|
||||
private getActiveConnectionCount(): number {
|
||||
return this.connections.size + this.pendingConnections.size;
|
||||
}
|
||||
|
||||
private getConnectionId(connection: ISmtpConnection): string | null {
|
||||
for (const [id, conn] of this.connections.entries()) {
|
||||
if (conn === connection) {
|
||||
return id;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private setupIdleCleanup(): void {
|
||||
if (!this.options.pool) {
|
||||
return;
|
||||
}
|
||||
|
||||
const cleanupInterval = DEFAULTS.POOL_IDLE_TIMEOUT;
|
||||
|
||||
this.idleTimeout = setInterval(() => {
|
||||
const now = Date.now();
|
||||
const connectionsToClose: ISmtpConnection[] = [];
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -1,145 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Constants and Error Codes
|
||||
* All constants, error codes, and enums for SMTP client operations
|
||||
*/
|
||||
|
||||
/**
|
||||
* SMTP response codes
|
||||
*/
|
||||
export const SMTP_CODES = {
|
||||
// Positive completion replies
|
||||
SERVICE_READY: 220,
|
||||
SERVICE_CLOSING: 221,
|
||||
AUTHENTICATION_SUCCESSFUL: 235,
|
||||
REQUESTED_ACTION_OK: 250,
|
||||
USER_NOT_LOCAL: 251,
|
||||
CANNOT_VERIFY_USER: 252,
|
||||
|
||||
// Positive intermediate replies
|
||||
START_MAIL_INPUT: 354,
|
||||
|
||||
// Transient negative completion replies
|
||||
SERVICE_NOT_AVAILABLE: 421,
|
||||
MAILBOX_BUSY: 450,
|
||||
LOCAL_ERROR: 451,
|
||||
INSUFFICIENT_STORAGE: 452,
|
||||
UNABLE_TO_ACCOMMODATE: 455,
|
||||
|
||||
// Permanent negative completion replies
|
||||
SYNTAX_ERROR: 500,
|
||||
SYNTAX_ERROR_PARAMETERS: 501,
|
||||
COMMAND_NOT_IMPLEMENTED: 502,
|
||||
BAD_SEQUENCE: 503,
|
||||
PARAMETER_NOT_IMPLEMENTED: 504,
|
||||
MAILBOX_UNAVAILABLE: 550,
|
||||
USER_NOT_LOCAL_TRY_FORWARD: 551,
|
||||
EXCEEDED_STORAGE: 552,
|
||||
MAILBOX_NAME_NOT_ALLOWED: 553,
|
||||
TRANSACTION_FAILED: 554
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* SMTP command names
|
||||
*/
|
||||
export const SMTP_COMMANDS = {
|
||||
HELO: 'HELO',
|
||||
EHLO: 'EHLO',
|
||||
MAIL_FROM: 'MAIL FROM',
|
||||
RCPT_TO: 'RCPT TO',
|
||||
DATA: 'DATA',
|
||||
RSET: 'RSET',
|
||||
NOOP: 'NOOP',
|
||||
QUIT: 'QUIT',
|
||||
STARTTLS: 'STARTTLS',
|
||||
AUTH: 'AUTH'
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Authentication methods
|
||||
*/
|
||||
export const AUTH_METHODS = {
|
||||
PLAIN: 'PLAIN',
|
||||
LOGIN: 'LOGIN',
|
||||
OAUTH2: 'XOAUTH2',
|
||||
CRAM_MD5: 'CRAM-MD5'
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Common SMTP extensions
|
||||
*/
|
||||
export const SMTP_EXTENSIONS = {
|
||||
PIPELINING: 'PIPELINING',
|
||||
SIZE: 'SIZE',
|
||||
STARTTLS: 'STARTTLS',
|
||||
AUTH: 'AUTH',
|
||||
EIGHT_BIT_MIME: '8BITMIME',
|
||||
CHUNKING: 'CHUNKING',
|
||||
ENHANCED_STATUS_CODES: 'ENHANCEDSTATUSCODES',
|
||||
DSN: 'DSN'
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Default configuration values
|
||||
*/
|
||||
export const DEFAULTS = {
|
||||
CONNECTION_TIMEOUT: 60000, // 60 seconds
|
||||
SOCKET_TIMEOUT: 300000, // 5 minutes
|
||||
COMMAND_TIMEOUT: 30000, // 30 seconds
|
||||
MAX_CONNECTIONS: 5,
|
||||
MAX_MESSAGES: 100,
|
||||
PORT_SMTP: 25,
|
||||
PORT_SUBMISSION: 587,
|
||||
PORT_SMTPS: 465,
|
||||
RETRY_ATTEMPTS: 3,
|
||||
RETRY_DELAY: 1000,
|
||||
POOL_IDLE_TIMEOUT: 30000 // 30 seconds
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Error types for classification
|
||||
*/
|
||||
export enum SmtpErrorType {
|
||||
CONNECTION_ERROR = 'CONNECTION_ERROR',
|
||||
AUTHENTICATION_ERROR = 'AUTHENTICATION_ERROR',
|
||||
PROTOCOL_ERROR = 'PROTOCOL_ERROR',
|
||||
TIMEOUT_ERROR = 'TIMEOUT_ERROR',
|
||||
TLS_ERROR = 'TLS_ERROR',
|
||||
SYNTAX_ERROR = 'SYNTAX_ERROR',
|
||||
MAILBOX_ERROR = 'MAILBOX_ERROR',
|
||||
QUOTA_ERROR = 'QUOTA_ERROR',
|
||||
UNKNOWN_ERROR = 'UNKNOWN_ERROR'
|
||||
}
|
||||
|
||||
/**
|
||||
* Regular expressions for parsing
|
||||
*/
|
||||
export const REGEX_PATTERNS = {
|
||||
EMAIL_ADDRESS: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
|
||||
RESPONSE_CODE: /^(\d{3})([ -])(.*)/,
|
||||
ENHANCED_STATUS: /^(\d\.\d\.\d)\s/,
|
||||
AUTH_CAPABILITIES: /AUTH\s+(.+)/i,
|
||||
SIZE_EXTENSION: /SIZE\s+(\d+)/i
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Line endings and separators
|
||||
*/
|
||||
export const LINE_ENDINGS = {
|
||||
CRLF: '\r\n',
|
||||
LF: '\n',
|
||||
CR: '\r'
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Connection states for internal use
|
||||
*/
|
||||
export const CONNECTION_STATES = {
|
||||
DISCONNECTED: 'disconnected',
|
||||
CONNECTING: 'connecting',
|
||||
CONNECTED: 'connected',
|
||||
AUTHENTICATED: 'authenticated',
|
||||
READY: 'ready',
|
||||
BUSY: 'busy',
|
||||
CLOSING: 'closing',
|
||||
ERROR: 'error'
|
||||
} as const;
|
||||
@@ -1,94 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Factory
|
||||
* Factory function for client creation and dependency injection
|
||||
*/
|
||||
|
||||
import { SmtpClient } from './smtp-client.js';
|
||||
import { ConnectionManager } from './connection-manager.js';
|
||||
import { CommandHandler } from './command-handler.js';
|
||||
import { AuthHandler } from './auth-handler.js';
|
||||
import { TlsHandler } from './tls-handler.js';
|
||||
import { SmtpErrorHandler } from './error-handler.js';
|
||||
import type { ISmtpClientOptions } from './interfaces.js';
|
||||
import { validateClientOptions } from './utils/validation.js';
|
||||
import { DEFAULTS } from './constants.js';
|
||||
|
||||
/**
|
||||
* Create a complete SMTP client with all components
|
||||
*/
|
||||
export function createSmtpClient(options: ISmtpClientOptions): SmtpClient {
|
||||
// Validate options
|
||||
const errors = validateClientOptions(options);
|
||||
if (errors.length > 0) {
|
||||
throw new Error(`Invalid client options: ${errors.join(', ')}`);
|
||||
}
|
||||
|
||||
// Apply defaults
|
||||
const clientOptions: ISmtpClientOptions = {
|
||||
connectionTimeout: DEFAULTS.CONNECTION_TIMEOUT,
|
||||
socketTimeout: DEFAULTS.SOCKET_TIMEOUT,
|
||||
maxConnections: DEFAULTS.MAX_CONNECTIONS,
|
||||
maxMessages: DEFAULTS.MAX_MESSAGES,
|
||||
pool: false,
|
||||
secure: false,
|
||||
debug: false,
|
||||
...options
|
||||
};
|
||||
|
||||
// Create handlers
|
||||
const errorHandler = new SmtpErrorHandler(clientOptions);
|
||||
const connectionManager = new ConnectionManager(clientOptions);
|
||||
const commandHandler = new CommandHandler(clientOptions);
|
||||
const authHandler = new AuthHandler(clientOptions, commandHandler);
|
||||
const tlsHandler = new TlsHandler(clientOptions, commandHandler);
|
||||
|
||||
// Create and return SMTP client
|
||||
return new SmtpClient({
|
||||
options: clientOptions,
|
||||
connectionManager,
|
||||
commandHandler,
|
||||
authHandler,
|
||||
tlsHandler,
|
||||
errorHandler
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Create SMTP client with connection pooling enabled
|
||||
*/
|
||||
export function createPooledSmtpClient(options: ISmtpClientOptions): SmtpClient {
|
||||
return createSmtpClient({
|
||||
...options,
|
||||
pool: true,
|
||||
maxConnections: options.maxConnections || DEFAULTS.MAX_CONNECTIONS,
|
||||
maxMessages: options.maxMessages || DEFAULTS.MAX_MESSAGES
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Create SMTP client for high-volume sending
|
||||
*/
|
||||
export function createBulkSmtpClient(options: ISmtpClientOptions): SmtpClient {
|
||||
return createSmtpClient({
|
||||
...options,
|
||||
pool: true,
|
||||
maxConnections: Math.max(options.maxConnections || 10, 10),
|
||||
maxMessages: Math.max(options.maxMessages || 1000, 1000),
|
||||
connectionTimeout: options.connectionTimeout || 30000,
|
||||
socketTimeout: options.socketTimeout || 120000
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Create SMTP client for transactional emails
|
||||
*/
|
||||
export function createTransactionalSmtpClient(options: ISmtpClientOptions): SmtpClient {
|
||||
return createSmtpClient({
|
||||
...options,
|
||||
pool: false, // Use fresh connections for transactional emails
|
||||
maxConnections: 1,
|
||||
maxMessages: 1,
|
||||
connectionTimeout: options.connectionTimeout || 10000,
|
||||
socketTimeout: options.socketTimeout || 30000
|
||||
});
|
||||
}
|
||||
@@ -1,141 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Error Handler
|
||||
* Error classification and recovery strategies
|
||||
*/
|
||||
|
||||
import { SmtpErrorType } from './constants.js';
|
||||
import type { ISmtpResponse, ISmtpErrorContext, ISmtpClientOptions } from './interfaces.js';
|
||||
import { logDebug } from './utils/logging.js';
|
||||
|
||||
export class SmtpErrorHandler {
|
||||
private options: ISmtpClientOptions;
|
||||
|
||||
constructor(options: ISmtpClientOptions) {
|
||||
this.options = options;
|
||||
}
|
||||
|
||||
/**
|
||||
* Classify error type based on response or error
|
||||
*/
|
||||
public classifyError(error: Error | ISmtpResponse, context?: ISmtpErrorContext): SmtpErrorType {
|
||||
logDebug('Classifying error', this.options, { errorMessage: error instanceof Error ? error.message : String(error), context });
|
||||
|
||||
// Handle Error objects
|
||||
if (error instanceof Error) {
|
||||
return this.classifyErrorByMessage(error);
|
||||
}
|
||||
|
||||
// Handle SMTP response codes
|
||||
if (typeof error === 'object' && 'code' in error) {
|
||||
return this.classifyErrorByCode(error.code);
|
||||
}
|
||||
|
||||
return SmtpErrorType.UNKNOWN_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if error is retryable
|
||||
*/
|
||||
public isRetryable(errorType: SmtpErrorType, response?: ISmtpResponse): boolean {
|
||||
switch (errorType) {
|
||||
case SmtpErrorType.CONNECTION_ERROR:
|
||||
case SmtpErrorType.TIMEOUT_ERROR:
|
||||
return true;
|
||||
|
||||
case SmtpErrorType.PROTOCOL_ERROR:
|
||||
// Only retry on temporary failures (4xx codes)
|
||||
return response ? response.code >= 400 && response.code < 500 : false;
|
||||
|
||||
case SmtpErrorType.AUTHENTICATION_ERROR:
|
||||
case SmtpErrorType.TLS_ERROR:
|
||||
case SmtpErrorType.SYNTAX_ERROR:
|
||||
case SmtpErrorType.MAILBOX_ERROR:
|
||||
case SmtpErrorType.QUOTA_ERROR:
|
||||
return false;
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get retry delay for error type
|
||||
*/
|
||||
public getRetryDelay(attempt: number, errorType: SmtpErrorType): number {
|
||||
const baseDelay = 1000; // 1 second
|
||||
const maxDelay = 30000; // 30 seconds
|
||||
|
||||
// Exponential backoff with jitter
|
||||
const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
|
||||
const jitter = Math.random() * 0.1 * delay; // 10% jitter
|
||||
|
||||
return Math.floor(delay + jitter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create enhanced error with context
|
||||
*/
|
||||
public createError(
|
||||
message: string,
|
||||
errorType: SmtpErrorType,
|
||||
context?: ISmtpErrorContext,
|
||||
originalError?: Error
|
||||
): Error {
|
||||
const error = new Error(message);
|
||||
(error as any).type = errorType;
|
||||
(error as any).context = context;
|
||||
(error as any).originalError = originalError;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
private classifyErrorByMessage(error: Error): SmtpErrorType {
|
||||
const message = error.message.toLowerCase();
|
||||
|
||||
if (message.includes('timeout') || message.includes('etimedout')) {
|
||||
return SmtpErrorType.TIMEOUT_ERROR;
|
||||
}
|
||||
|
||||
if (message.includes('connect') || message.includes('econnrefused') ||
|
||||
message.includes('enotfound') || message.includes('enetunreach')) {
|
||||
return SmtpErrorType.CONNECTION_ERROR;
|
||||
}
|
||||
|
||||
if (message.includes('tls') || message.includes('ssl') ||
|
||||
message.includes('certificate') || message.includes('handshake')) {
|
||||
return SmtpErrorType.TLS_ERROR;
|
||||
}
|
||||
|
||||
if (message.includes('auth')) {
|
||||
return SmtpErrorType.AUTHENTICATION_ERROR;
|
||||
}
|
||||
|
||||
return SmtpErrorType.UNKNOWN_ERROR;
|
||||
}
|
||||
|
||||
private classifyErrorByCode(code: number): SmtpErrorType {
|
||||
if (code >= 500) {
|
||||
// Permanent failures
|
||||
if (code === 550 || code === 551 || code === 553) {
|
||||
return SmtpErrorType.MAILBOX_ERROR;
|
||||
}
|
||||
if (code === 552) {
|
||||
return SmtpErrorType.QUOTA_ERROR;
|
||||
}
|
||||
if (code === 500 || code === 501 || code === 502 || code === 504) {
|
||||
return SmtpErrorType.SYNTAX_ERROR;
|
||||
}
|
||||
return SmtpErrorType.PROTOCOL_ERROR;
|
||||
}
|
||||
|
||||
if (code >= 400) {
|
||||
// Temporary failures
|
||||
if (code === 450 || code === 451 || code === 452) {
|
||||
return SmtpErrorType.QUOTA_ERROR;
|
||||
}
|
||||
return SmtpErrorType.PROTOCOL_ERROR;
|
||||
}
|
||||
|
||||
return SmtpErrorType.UNKNOWN_ERROR;
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Module Exports
|
||||
* Modular SMTP client implementation for robust email delivery
|
||||
*/
|
||||
|
||||
// Main client class and factory
|
||||
export * from './smtp-client.js';
|
||||
export * from './create-client.js';
|
||||
|
||||
// Core handlers
|
||||
export * from './connection-manager.js';
|
||||
export * from './command-handler.js';
|
||||
export * from './auth-handler.js';
|
||||
export * from './tls-handler.js';
|
||||
export * from './error-handler.js';
|
||||
|
||||
// Interfaces and types
|
||||
export * from './interfaces.js';
|
||||
export * from './constants.js';
|
||||
|
||||
// Utilities
|
||||
export * from './utils/validation.js';
|
||||
export * from './utils/logging.js';
|
||||
export * from './utils/helpers.js';
|
||||
@@ -1,242 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Interfaces and Types
|
||||
* All interface definitions for the modular SMTP client
|
||||
*/
|
||||
|
||||
import type * as tls from 'node:tls';
|
||||
import type * as net from 'node:net';
|
||||
import type { Email } from '../../core/classes.email.js';
|
||||
|
||||
/**
|
||||
* SMTP client connection options
|
||||
*/
|
||||
export interface ISmtpClientOptions {
|
||||
/** Hostname of the SMTP server */
|
||||
host: string;
|
||||
|
||||
/** Port to connect to */
|
||||
port: number;
|
||||
|
||||
/** Whether to use TLS for the connection */
|
||||
secure?: boolean;
|
||||
|
||||
/** Connection timeout in milliseconds */
|
||||
connectionTimeout?: number;
|
||||
|
||||
/** Socket timeout in milliseconds */
|
||||
socketTimeout?: number;
|
||||
|
||||
/** Domain name for EHLO command */
|
||||
domain?: string;
|
||||
|
||||
/** Authentication options */
|
||||
auth?: ISmtpAuthOptions;
|
||||
|
||||
/** TLS options */
|
||||
tls?: tls.ConnectionOptions;
|
||||
|
||||
/** Maximum number of connections in pool */
|
||||
pool?: boolean;
|
||||
maxConnections?: number;
|
||||
maxMessages?: number;
|
||||
|
||||
/** Enable debug logging */
|
||||
debug?: boolean;
|
||||
|
||||
/** Proxy settings */
|
||||
proxy?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Authentication options for SMTP
|
||||
*/
|
||||
export interface ISmtpAuthOptions {
|
||||
/** Username */
|
||||
user?: string;
|
||||
|
||||
/** Password */
|
||||
pass?: string;
|
||||
|
||||
/** OAuth2 settings */
|
||||
oauth2?: IOAuth2Options;
|
||||
|
||||
/** Authentication method preference */
|
||||
method?: 'PLAIN' | 'LOGIN' | 'OAUTH2' | 'AUTO';
|
||||
}
|
||||
|
||||
/**
|
||||
* OAuth2 authentication options
|
||||
*/
|
||||
export interface IOAuth2Options {
|
||||
/** OAuth2 user identifier */
|
||||
user: string;
|
||||
|
||||
/** OAuth2 client ID */
|
||||
clientId: string;
|
||||
|
||||
/** OAuth2 client secret */
|
||||
clientSecret: string;
|
||||
|
||||
/** OAuth2 refresh token */
|
||||
refreshToken: string;
|
||||
|
||||
/** OAuth2 access token */
|
||||
accessToken?: string;
|
||||
|
||||
/** Token expiry time */
|
||||
expires?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Result of an email send operation
|
||||
*/
|
||||
export interface ISmtpSendResult {
|
||||
/** Whether the send was successful */
|
||||
success: boolean;
|
||||
|
||||
/** Message ID from server */
|
||||
messageId?: string;
|
||||
|
||||
/** List of accepted recipients */
|
||||
acceptedRecipients: string[];
|
||||
|
||||
/** List of rejected recipients */
|
||||
rejectedRecipients: string[];
|
||||
|
||||
/** Error information if failed */
|
||||
error?: Error;
|
||||
|
||||
/** Server response */
|
||||
response?: string;
|
||||
|
||||
/** Envelope information */
|
||||
envelope?: ISmtpEnvelope;
|
||||
}
|
||||
|
||||
/**
|
||||
* SMTP envelope information
|
||||
*/
|
||||
export interface ISmtpEnvelope {
|
||||
/** Sender address */
|
||||
from: string;
|
||||
|
||||
/** Recipient addresses */
|
||||
to: string[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Connection pool status
|
||||
*/
|
||||
export interface IConnectionPoolStatus {
|
||||
/** Total connections in pool */
|
||||
total: number;
|
||||
|
||||
/** Active connections */
|
||||
active: number;
|
||||
|
||||
/** Idle connections */
|
||||
idle: number;
|
||||
|
||||
/** Pending connection requests */
|
||||
pending: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* SMTP command response
|
||||
*/
|
||||
export interface ISmtpResponse {
|
||||
/** Response code */
|
||||
code: number;
|
||||
|
||||
/** Response message */
|
||||
message: string;
|
||||
|
||||
/** Enhanced status code */
|
||||
enhancedCode?: string;
|
||||
|
||||
/** Raw response */
|
||||
raw: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Connection state
|
||||
*/
|
||||
export enum ConnectionState {
|
||||
DISCONNECTED = 'disconnected',
|
||||
CONNECTING = 'connecting',
|
||||
CONNECTED = 'connected',
|
||||
AUTHENTICATED = 'authenticated',
|
||||
READY = 'ready',
|
||||
BUSY = 'busy',
|
||||
CLOSING = 'closing',
|
||||
ERROR = 'error'
|
||||
}
|
||||
|
||||
/**
|
||||
* SMTP capabilities
|
||||
*/
|
||||
export interface ISmtpCapabilities {
|
||||
/** Supported extensions */
|
||||
extensions: Set<string>;
|
||||
|
||||
/** Maximum message size */
|
||||
maxSize?: number;
|
||||
|
||||
/** Supported authentication methods */
|
||||
authMethods: Set<string>;
|
||||
|
||||
/** Support for pipelining */
|
||||
pipelining: boolean;
|
||||
|
||||
/** Support for STARTTLS */
|
||||
starttls: boolean;
|
||||
|
||||
/** Support for 8BITMIME */
|
||||
eightBitMime: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Internal connection interface
|
||||
*/
|
||||
export interface ISmtpConnection {
|
||||
/** Socket connection */
|
||||
socket: net.Socket | tls.TLSSocket;
|
||||
|
||||
/** Connection state */
|
||||
state: ConnectionState;
|
||||
|
||||
/** Server capabilities */
|
||||
capabilities?: ISmtpCapabilities;
|
||||
|
||||
/** Connection options */
|
||||
options: ISmtpClientOptions;
|
||||
|
||||
/** Whether connection is secure */
|
||||
secure: boolean;
|
||||
|
||||
/** Connection creation time */
|
||||
createdAt: Date;
|
||||
|
||||
/** Last activity time */
|
||||
lastActivity: Date;
|
||||
|
||||
/** Number of messages sent */
|
||||
messageCount: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Error context for detailed error reporting
|
||||
*/
|
||||
export interface ISmtpErrorContext {
|
||||
/** Command that caused the error */
|
||||
command?: string;
|
||||
|
||||
/** Server response */
|
||||
response?: ISmtpResponse;
|
||||
|
||||
/** Connection state */
|
||||
connectionState?: ConnectionState;
|
||||
|
||||
/** Additional context data */
|
||||
data?: Record<string, any>;
|
||||
}
|
||||
@@ -1,357 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Core Implementation
|
||||
* Main client class with delegation to handlers
|
||||
*/
|
||||
|
||||
import { EventEmitter } from 'node:events';
|
||||
import type { Email } from '../../core/classes.email.js';
|
||||
import type {
|
||||
ISmtpClientOptions,
|
||||
ISmtpSendResult,
|
||||
ISmtpConnection,
|
||||
IConnectionPoolStatus,
|
||||
ConnectionState
|
||||
} from './interfaces.js';
|
||||
import { CONNECTION_STATES, SmtpErrorType } from './constants.js';
|
||||
import type { ConnectionManager } from './connection-manager.js';
|
||||
import type { CommandHandler } from './command-handler.js';
|
||||
import type { AuthHandler } from './auth-handler.js';
|
||||
import type { TlsHandler } from './tls-handler.js';
|
||||
import type { SmtpErrorHandler } from './error-handler.js';
|
||||
import { validateSender, validateRecipients } from './utils/validation.js';
|
||||
import { logEmailSend, logPerformance, logDebug } from './utils/logging.js';
|
||||
|
||||
interface ISmtpClientDependencies {
|
||||
options: ISmtpClientOptions;
|
||||
connectionManager: ConnectionManager;
|
||||
commandHandler: CommandHandler;
|
||||
authHandler: AuthHandler;
|
||||
tlsHandler: TlsHandler;
|
||||
errorHandler: SmtpErrorHandler;
|
||||
}
|
||||
|
||||
export class SmtpClient extends EventEmitter {
|
||||
private options: ISmtpClientOptions;
|
||||
private connectionManager: ConnectionManager;
|
||||
private commandHandler: CommandHandler;
|
||||
private authHandler: AuthHandler;
|
||||
private tlsHandler: TlsHandler;
|
||||
private errorHandler: SmtpErrorHandler;
|
||||
private isShuttingDown: boolean = false;
|
||||
|
||||
constructor(dependencies: ISmtpClientDependencies) {
|
||||
super();
|
||||
|
||||
this.options = dependencies.options;
|
||||
this.connectionManager = dependencies.connectionManager;
|
||||
this.commandHandler = dependencies.commandHandler;
|
||||
this.authHandler = dependencies.authHandler;
|
||||
this.tlsHandler = dependencies.tlsHandler;
|
||||
this.errorHandler = dependencies.errorHandler;
|
||||
|
||||
this.setupEventForwarding();
|
||||
}
|
||||
|
||||
/**
|
||||
* Send an email
|
||||
*/
|
||||
public async sendMail(email: Email): Promise<ISmtpSendResult> {
|
||||
const startTime = Date.now();
|
||||
|
||||
// Extract clean email addresses without display names for SMTP operations
|
||||
const fromAddress = email.getFromAddress();
|
||||
const recipients = email.getToAddresses();
|
||||
const ccRecipients = email.getCcAddresses();
|
||||
const bccRecipients = email.getBccAddresses();
|
||||
|
||||
// Combine all recipients for SMTP operations
|
||||
const allRecipients = [...recipients, ...ccRecipients, ...bccRecipients];
|
||||
|
||||
// Validate email addresses
|
||||
if (!validateSender(fromAddress)) {
|
||||
throw new Error(`Invalid sender address: ${fromAddress}`);
|
||||
}
|
||||
|
||||
const recipientErrors = validateRecipients(allRecipients);
|
||||
if (recipientErrors.length > 0) {
|
||||
throw new Error(`Invalid recipients: ${recipientErrors.join(', ')}`);
|
||||
}
|
||||
|
||||
logEmailSend('start', allRecipients, this.options);
|
||||
|
||||
let connection: ISmtpConnection | null = null;
|
||||
const result: ISmtpSendResult = {
|
||||
success: false,
|
||||
acceptedRecipients: [],
|
||||
rejectedRecipients: [],
|
||||
envelope: {
|
||||
from: fromAddress,
|
||||
to: allRecipients
|
||||
}
|
||||
};
|
||||
|
||||
try {
|
||||
// Get connection
|
||||
connection = await this.connectionManager.getConnection();
|
||||
connection.state = CONNECTION_STATES.BUSY as ConnectionState;
|
||||
|
||||
// Wait for greeting if new connection
|
||||
if (!connection.capabilities) {
|
||||
await this.commandHandler.waitForGreeting(connection);
|
||||
}
|
||||
|
||||
// Perform EHLO
|
||||
await this.commandHandler.sendEhlo(connection, this.options.domain);
|
||||
|
||||
// Upgrade to TLS if needed
|
||||
if (this.tlsHandler.shouldUseTLS(connection)) {
|
||||
await this.tlsHandler.upgradeToTLS(connection);
|
||||
// Re-send EHLO after TLS upgrade
|
||||
await this.commandHandler.sendEhlo(connection, this.options.domain);
|
||||
}
|
||||
|
||||
// Authenticate if needed
|
||||
if (this.options.auth) {
|
||||
await this.authHandler.authenticate(connection);
|
||||
}
|
||||
|
||||
// Send MAIL FROM
|
||||
const mailFromResponse = await this.commandHandler.sendMailFrom(connection, fromAddress);
|
||||
if (mailFromResponse.code >= 400) {
|
||||
throw new Error(`MAIL FROM failed: ${mailFromResponse.message}`);
|
||||
}
|
||||
|
||||
// Send RCPT TO for each recipient (includes TO, CC, and BCC)
|
||||
for (const recipient of allRecipients) {
|
||||
try {
|
||||
const rcptResponse = await this.commandHandler.sendRcptTo(connection, recipient);
|
||||
if (rcptResponse.code >= 400) {
|
||||
result.rejectedRecipients.push(recipient);
|
||||
logDebug(`Recipient rejected: ${recipient}`, this.options, { response: rcptResponse });
|
||||
} else {
|
||||
result.acceptedRecipients.push(recipient);
|
||||
}
|
||||
} catch (error) {
|
||||
result.rejectedRecipients.push(recipient);
|
||||
logDebug(`Recipient error: ${recipient}`, this.options, { error });
|
||||
}
|
||||
}
|
||||
|
||||
// Check if we have any accepted recipients
|
||||
if (result.acceptedRecipients.length === 0) {
|
||||
throw new Error('All recipients were rejected');
|
||||
}
|
||||
|
||||
// Send DATA command
|
||||
const dataResponse = await this.commandHandler.sendData(connection);
|
||||
if (dataResponse.code !== 354) {
|
||||
throw new Error(`DATA command failed: ${dataResponse.message}`);
|
||||
}
|
||||
|
||||
// Send email content
|
||||
const emailData = await this.formatEmailData(email);
|
||||
const sendResponse = await this.commandHandler.sendDataContent(connection, emailData);
|
||||
|
||||
if (sendResponse.code >= 400) {
|
||||
throw new Error(`Email data rejected: ${sendResponse.message}`);
|
||||
}
|
||||
|
||||
// Success
|
||||
result.success = true;
|
||||
result.messageId = this.extractMessageId(sendResponse.message);
|
||||
result.response = sendResponse.message;
|
||||
|
||||
connection.messageCount++;
|
||||
logEmailSend('success', recipients, this.options, {
|
||||
messageId: result.messageId,
|
||||
duration: Date.now() - startTime
|
||||
});
|
||||
|
||||
} catch (error) {
|
||||
result.success = false;
|
||||
result.error = error instanceof Error ? error : new Error(String(error));
|
||||
|
||||
// Classify error and determine if we should retry
|
||||
const errorType = this.errorHandler.classifyError(result.error);
|
||||
result.error = this.errorHandler.createError(
|
||||
result.error.message,
|
||||
errorType,
|
||||
{ command: 'SEND_MAIL' },
|
||||
result.error
|
||||
);
|
||||
|
||||
logEmailSend('failure', recipients, this.options, {
|
||||
error: result.error,
|
||||
duration: Date.now() - startTime
|
||||
});
|
||||
|
||||
} finally {
|
||||
// Release connection
|
||||
if (connection) {
|
||||
connection.state = CONNECTION_STATES.READY as ConnectionState;
|
||||
this.connectionManager.updateActivity(connection);
|
||||
this.connectionManager.releaseConnection(connection);
|
||||
}
|
||||
|
||||
logPerformance('sendMail', Date.now() - startTime, this.options);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Test connection to SMTP server
|
||||
*/
|
||||
public async verify(): Promise<boolean> {
|
||||
let connection: ISmtpConnection | null = null;
|
||||
|
||||
try {
|
||||
connection = await this.connectionManager.createConnection();
|
||||
await this.commandHandler.waitForGreeting(connection);
|
||||
await this.commandHandler.sendEhlo(connection, this.options.domain);
|
||||
|
||||
if (this.tlsHandler.shouldUseTLS(connection)) {
|
||||
await this.tlsHandler.upgradeToTLS(connection);
|
||||
await this.commandHandler.sendEhlo(connection, this.options.domain);
|
||||
}
|
||||
|
||||
if (this.options.auth) {
|
||||
await this.authHandler.authenticate(connection);
|
||||
}
|
||||
|
||||
await this.commandHandler.sendQuit(connection);
|
||||
return true;
|
||||
|
||||
} catch (error) {
|
||||
logDebug('Connection verification failed', this.options, { error });
|
||||
return false;
|
||||
|
||||
} finally {
|
||||
if (connection) {
|
||||
this.connectionManager.closeConnection(connection);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if client is connected
|
||||
*/
|
||||
public isConnected(): boolean {
|
||||
const status = this.connectionManager.getPoolStatus();
|
||||
return status.total > 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get connection pool status
|
||||
*/
|
||||
public getPoolStatus(): IConnectionPoolStatus {
|
||||
return this.connectionManager.getPoolStatus();
|
||||
}
|
||||
|
||||
/**
|
||||
* Update client options
|
||||
*/
|
||||
public updateOptions(newOptions: Partial<ISmtpClientOptions>): void {
|
||||
this.options = { ...this.options, ...newOptions };
|
||||
logDebug('Client options updated', this.options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Close all connections and shutdown client
|
||||
*/
|
||||
public async close(): Promise<void> {
|
||||
if (this.isShuttingDown) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.isShuttingDown = true;
|
||||
logDebug('Shutting down SMTP client', this.options);
|
||||
|
||||
try {
|
||||
this.connectionManager.closeAllConnections();
|
||||
this.emit('close');
|
||||
} catch (error) {
|
||||
logDebug('Error during client shutdown', this.options, { error });
|
||||
}
|
||||
}
|
||||
|
||||
private async formatEmailData(email: Email): Promise<string> {
|
||||
// Convert Email object to raw SMTP data
|
||||
const headers: string[] = [];
|
||||
|
||||
// Required headers
|
||||
headers.push(`From: ${email.from}`);
|
||||
headers.push(`To: ${Array.isArray(email.to) ? email.to.join(', ') : email.to}`);
|
||||
headers.push(`Subject: ${email.subject || ''}`);
|
||||
headers.push(`Date: ${new Date().toUTCString()}`);
|
||||
headers.push(`Message-ID: <${Date.now()}.${Math.random().toString(36)}@${this.options.host}>`);
|
||||
|
||||
// Optional headers
|
||||
if (email.cc) {
|
||||
const cc = Array.isArray(email.cc) ? email.cc.join(', ') : email.cc;
|
||||
headers.push(`Cc: ${cc}`);
|
||||
}
|
||||
|
||||
if (email.bcc) {
|
||||
const bcc = Array.isArray(email.bcc) ? email.bcc.join(', ') : email.bcc;
|
||||
headers.push(`Bcc: ${bcc}`);
|
||||
}
|
||||
|
||||
// Content headers
|
||||
if (email.html && email.text) {
|
||||
// Multipart message
|
||||
const boundary = `boundary_${Date.now()}_${Math.random().toString(36)}`;
|
||||
headers.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
|
||||
headers.push('MIME-Version: 1.0');
|
||||
|
||||
const body = [
|
||||
`--${boundary}`,
|
||||
'Content-Type: text/plain; charset=utf-8',
|
||||
'Content-Transfer-Encoding: quoted-printable',
|
||||
'',
|
||||
email.text,
|
||||
'',
|
||||
`--${boundary}`,
|
||||
'Content-Type: text/html; charset=utf-8',
|
||||
'Content-Transfer-Encoding: quoted-printable',
|
||||
'',
|
||||
email.html,
|
||||
'',
|
||||
`--${boundary}--`
|
||||
].join('\r\n');
|
||||
|
||||
return headers.join('\r\n') + '\r\n\r\n' + body;
|
||||
} else if (email.html) {
|
||||
headers.push('Content-Type: text/html; charset=utf-8');
|
||||
headers.push('MIME-Version: 1.0');
|
||||
return headers.join('\r\n') + '\r\n\r\n' + email.html;
|
||||
} else {
|
||||
headers.push('Content-Type: text/plain; charset=utf-8');
|
||||
headers.push('MIME-Version: 1.0');
|
||||
return headers.join('\r\n') + '\r\n\r\n' + (email.text || '');
|
||||
}
|
||||
}
|
||||
|
||||
private extractMessageId(response: string): string | undefined {
|
||||
// Try to extract message ID from server response
|
||||
const match = response.match(/queued as ([^\s]+)/i) ||
|
||||
response.match(/id=([^\s]+)/i) ||
|
||||
response.match(/Message-ID: <([^>]+)>/i);
|
||||
return match ? match[1] : undefined;
|
||||
}
|
||||
|
||||
private setupEventForwarding(): void {
|
||||
// Forward events from connection manager
|
||||
this.connectionManager.on('connection', (connection) => {
|
||||
this.emit('connection', connection);
|
||||
});
|
||||
|
||||
this.connectionManager.on('disconnect', (connection) => {
|
||||
this.emit('disconnect', connection);
|
||||
});
|
||||
|
||||
this.connectionManager.on('error', (error) => {
|
||||
this.emit('error', error);
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -1,254 +0,0 @@
|
||||
/**
|
||||
* SMTP Client TLS Handler
|
||||
* TLS and STARTTLS client functionality
|
||||
*/
|
||||
|
||||
import * as tls from 'node:tls';
|
||||
import * as net from 'node:net';
|
||||
import { DEFAULTS } from './constants.js';
|
||||
import type {
|
||||
ISmtpConnection,
|
||||
ISmtpClientOptions,
|
||||
ConnectionState
|
||||
} from './interfaces.js';
|
||||
import { CONNECTION_STATES } from './constants.js';
|
||||
import { logTLS, logDebug } from './utils/logging.js';
|
||||
import { isSuccessCode } from './utils/helpers.js';
|
||||
import type { CommandHandler } from './command-handler.js';
|
||||
|
||||
export class TlsHandler {
|
||||
private options: ISmtpClientOptions;
|
||||
private commandHandler: CommandHandler;
|
||||
|
||||
constructor(options: ISmtpClientOptions, commandHandler: CommandHandler) {
|
||||
this.options = options;
|
||||
this.commandHandler = commandHandler;
|
||||
}
|
||||
|
||||
/**
|
||||
* Upgrade connection to TLS using STARTTLS
|
||||
*/
|
||||
public async upgradeToTLS(connection: ISmtpConnection): Promise<void> {
|
||||
if (connection.secure) {
|
||||
logDebug('Connection already secure', this.options);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if STARTTLS is supported
|
||||
if (!connection.capabilities?.starttls) {
|
||||
throw new Error('Server does not support STARTTLS');
|
||||
}
|
||||
|
||||
logTLS('starttls_start', this.options);
|
||||
|
||||
try {
|
||||
// Send STARTTLS command
|
||||
const response = await this.commandHandler.sendStartTls(connection);
|
||||
|
||||
if (!isSuccessCode(response.code)) {
|
||||
throw new Error(`STARTTLS command failed: ${response.message}`);
|
||||
}
|
||||
|
||||
// Upgrade the socket to TLS
|
||||
await this.performTLSUpgrade(connection);
|
||||
|
||||
// Clear capabilities as they may have changed after TLS
|
||||
connection.capabilities = undefined;
|
||||
connection.secure = true;
|
||||
|
||||
logTLS('starttls_success', this.options);
|
||||
|
||||
} catch (error) {
|
||||
logTLS('starttls_failure', this.options, { error });
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a direct TLS connection
|
||||
*/
|
||||
public async createTLSConnection(host: string, port: number): Promise<tls.TLSSocket> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const timeout = this.options.connectionTimeout || DEFAULTS.CONNECTION_TIMEOUT;
|
||||
|
||||
const tlsOptions: tls.ConnectionOptions = {
|
||||
host,
|
||||
port,
|
||||
...this.options.tls,
|
||||
// Default TLS options for email
|
||||
secureProtocol: 'TLS_method',
|
||||
ciphers: 'HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
|
||||
rejectUnauthorized: this.options.tls?.rejectUnauthorized !== false
|
||||
};
|
||||
|
||||
logTLS('tls_connected', this.options, { host, port });
|
||||
|
||||
const socket = tls.connect(tlsOptions);
|
||||
|
||||
const timeoutHandler = setTimeout(() => {
|
||||
socket.destroy();
|
||||
reject(new Error(`TLS connection timeout after ${timeout}ms`));
|
||||
}, timeout);
|
||||
|
||||
socket.once('secureConnect', () => {
|
||||
clearTimeout(timeoutHandler);
|
||||
|
||||
if (!socket.authorized && this.options.tls?.rejectUnauthorized !== false) {
|
||||
socket.destroy();
|
||||
reject(new Error(`TLS certificate verification failed: ${socket.authorizationError}`));
|
||||
return;
|
||||
}
|
||||
|
||||
logDebug('TLS connection established', this.options, {
|
||||
authorized: socket.authorized,
|
||||
protocol: socket.getProtocol(),
|
||||
cipher: socket.getCipher()
|
||||
});
|
||||
|
||||
resolve(socket);
|
||||
});
|
||||
|
||||
socket.once('error', (error) => {
|
||||
clearTimeout(timeoutHandler);
|
||||
reject(error);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate TLS certificate
|
||||
*/
|
||||
public validateCertificate(socket: tls.TLSSocket): boolean {
|
||||
if (!socket.authorized) {
|
||||
logDebug('TLS certificate not authorized', this.options, {
|
||||
error: socket.authorizationError
|
||||
});
|
||||
|
||||
// Allow self-signed certificates if explicitly configured
|
||||
if (this.options.tls?.rejectUnauthorized === false) {
|
||||
logDebug('Accepting unauthorized certificate (rejectUnauthorized: false)', this.options);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
const cert = socket.getPeerCertificate();
|
||||
if (!cert) {
|
||||
logDebug('No peer certificate available', this.options);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Additional certificate validation
|
||||
const now = new Date();
|
||||
if (cert.valid_from && new Date(cert.valid_from) > now) {
|
||||
logDebug('Certificate not yet valid', this.options, { validFrom: cert.valid_from });
|
||||
return false;
|
||||
}
|
||||
|
||||
if (cert.valid_to && new Date(cert.valid_to) < now) {
|
||||
logDebug('Certificate expired', this.options, { validTo: cert.valid_to });
|
||||
return false;
|
||||
}
|
||||
|
||||
logDebug('TLS certificate validated', this.options, {
|
||||
subject: cert.subject,
|
||||
issuer: cert.issuer,
|
||||
validFrom: cert.valid_from,
|
||||
validTo: cert.valid_to
|
||||
});
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get TLS connection information
|
||||
*/
|
||||
public getTLSInfo(socket: tls.TLSSocket): any {
|
||||
if (!(socket instanceof tls.TLSSocket)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
authorized: socket.authorized,
|
||||
authorizationError: socket.authorizationError,
|
||||
protocol: socket.getProtocol(),
|
||||
cipher: socket.getCipher(),
|
||||
peerCertificate: socket.getPeerCertificate(),
|
||||
alpnProtocol: socket.alpnProtocol
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if TLS upgrade is required or recommended
|
||||
*/
|
||||
public shouldUseTLS(connection: ISmtpConnection): boolean {
|
||||
// Already secure
|
||||
if (connection.secure) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Direct TLS connection configured
|
||||
if (this.options.secure) {
|
||||
return false; // Already handled in connection establishment
|
||||
}
|
||||
|
||||
// STARTTLS available and not explicitly disabled
|
||||
if (connection.capabilities?.starttls) {
|
||||
return this.options.tls !== null && this.options.tls !== undefined; // Use TLS if configured
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private async performTLSUpgrade(connection: ISmtpConnection): Promise<void> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const plainSocket = connection.socket as net.Socket;
|
||||
const timeout = this.options.connectionTimeout || DEFAULTS.CONNECTION_TIMEOUT;
|
||||
|
||||
const tlsOptions: tls.ConnectionOptions = {
|
||||
socket: plainSocket,
|
||||
host: this.options.host,
|
||||
...this.options.tls,
|
||||
// Default TLS options for STARTTLS
|
||||
secureProtocol: 'TLS_method',
|
||||
ciphers: 'HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
|
||||
rejectUnauthorized: this.options.tls?.rejectUnauthorized !== false
|
||||
};
|
||||
|
||||
const timeoutHandler = setTimeout(() => {
|
||||
reject(new Error(`TLS upgrade timeout after ${timeout}ms`));
|
||||
}, timeout);
|
||||
|
||||
// Create TLS socket from existing connection
|
||||
const tlsSocket = tls.connect(tlsOptions);
|
||||
|
||||
tlsSocket.once('secureConnect', () => {
|
||||
clearTimeout(timeoutHandler);
|
||||
|
||||
// Validate certificate if required
|
||||
if (!this.validateCertificate(tlsSocket)) {
|
||||
tlsSocket.destroy();
|
||||
reject(new Error('TLS certificate validation failed'));
|
||||
return;
|
||||
}
|
||||
|
||||
// Replace the socket in the connection
|
||||
connection.socket = tlsSocket;
|
||||
connection.secure = true;
|
||||
|
||||
logDebug('STARTTLS upgrade completed', this.options, {
|
||||
protocol: tlsSocket.getProtocol(),
|
||||
cipher: tlsSocket.getCipher()
|
||||
});
|
||||
|
||||
resolve();
|
||||
});
|
||||
|
||||
tlsSocket.once('error', (error) => {
|
||||
clearTimeout(timeoutHandler);
|
||||
reject(error);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -1,224 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Helper Functions
|
||||
* Protocol helper functions and utilities
|
||||
*/
|
||||
|
||||
import { SMTP_CODES, REGEX_PATTERNS, LINE_ENDINGS } from '../constants.js';
|
||||
import type { ISmtpResponse, ISmtpCapabilities } from '../interfaces.js';
|
||||
|
||||
/**
|
||||
* Parse SMTP server response
|
||||
*/
|
||||
export function parseSmtpResponse(data: string): ISmtpResponse {
|
||||
const lines = data.trim().split(/\r?\n/);
|
||||
const firstLine = lines[0];
|
||||
const match = firstLine.match(REGEX_PATTERNS.RESPONSE_CODE);
|
||||
|
||||
if (!match) {
|
||||
return {
|
||||
code: 500,
|
||||
message: 'Invalid server response',
|
||||
raw: data
|
||||
};
|
||||
}
|
||||
|
||||
const code = parseInt(match[1], 10);
|
||||
const separator = match[2];
|
||||
const message = lines.map(line => line.substring(4)).join(' ');
|
||||
|
||||
// Check for enhanced status code
|
||||
const enhancedMatch = message.match(REGEX_PATTERNS.ENHANCED_STATUS);
|
||||
const enhancedCode = enhancedMatch ? enhancedMatch[1] : undefined;
|
||||
|
||||
return {
|
||||
code,
|
||||
message: enhancedCode ? message.substring(enhancedCode.length + 1) : message,
|
||||
enhancedCode,
|
||||
raw: data
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse EHLO response and extract capabilities
|
||||
*/
|
||||
export function parseEhloResponse(response: string): ISmtpCapabilities {
|
||||
const lines = response.trim().split(/\r?\n/);
|
||||
const capabilities: ISmtpCapabilities = {
|
||||
extensions: new Set(),
|
||||
authMethods: new Set(),
|
||||
pipelining: false,
|
||||
starttls: false,
|
||||
eightBitMime: false
|
||||
};
|
||||
|
||||
for (const line of lines.slice(1)) { // Skip first line (greeting)
|
||||
const extensionLine = line.substring(4); // Remove "250-" or "250 "
|
||||
const parts = extensionLine.split(/\s+/);
|
||||
const extension = parts[0].toUpperCase();
|
||||
|
||||
capabilities.extensions.add(extension);
|
||||
|
||||
switch (extension) {
|
||||
case 'PIPELINING':
|
||||
capabilities.pipelining = true;
|
||||
break;
|
||||
case 'STARTTLS':
|
||||
capabilities.starttls = true;
|
||||
break;
|
||||
case '8BITMIME':
|
||||
capabilities.eightBitMime = true;
|
||||
break;
|
||||
case 'SIZE':
|
||||
if (parts[1]) {
|
||||
capabilities.maxSize = parseInt(parts[1], 10);
|
||||
}
|
||||
break;
|
||||
case 'AUTH':
|
||||
// Parse authentication methods
|
||||
for (let i = 1; i < parts.length; i++) {
|
||||
capabilities.authMethods.add(parts[i].toUpperCase());
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return capabilities;
|
||||
}
|
||||
|
||||
/**
|
||||
* Format SMTP command with proper line ending
|
||||
*/
|
||||
export function formatCommand(command: string, ...args: string[]): string {
|
||||
const fullCommand = args.length > 0 ? `${command} ${args.join(' ')}` : command;
|
||||
return fullCommand + LINE_ENDINGS.CRLF;
|
||||
}
|
||||
|
||||
/**
|
||||
* Encode authentication string for AUTH PLAIN
|
||||
*/
|
||||
export function encodeAuthPlain(username: string, password: string): string {
|
||||
const authString = `\0${username}\0${password}`;
|
||||
return Buffer.from(authString, 'utf8').toString('base64');
|
||||
}
|
||||
|
||||
/**
|
||||
* Encode authentication string for AUTH LOGIN
|
||||
*/
|
||||
export function encodeAuthLogin(value: string): string {
|
||||
return Buffer.from(value, 'utf8').toString('base64');
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate OAuth2 authentication string
|
||||
*/
|
||||
export function generateOAuth2String(username: string, accessToken: string): string {
|
||||
const authString = `user=${username}\x01auth=Bearer ${accessToken}\x01\x01`;
|
||||
return Buffer.from(authString, 'utf8').toString('base64');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if response code indicates success
|
||||
*/
|
||||
export function isSuccessCode(code: number): boolean {
|
||||
return code >= 200 && code < 300;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if response code indicates temporary failure
|
||||
*/
|
||||
export function isTemporaryFailure(code: number): boolean {
|
||||
return code >= 400 && code < 500;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if response code indicates permanent failure
|
||||
*/
|
||||
export function isPermanentFailure(code: number): boolean {
|
||||
return code >= 500;
|
||||
}
|
||||
|
||||
/**
|
||||
* Escape email address for SMTP commands
|
||||
*/
|
||||
export function escapeEmailAddress(email: string): string {
|
||||
return `<${email.trim()}>`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract email address from angle brackets
|
||||
*/
|
||||
export function extractEmailAddress(email: string): string {
|
||||
const match = email.match(/^<(.+)>$/);
|
||||
return match ? match[1] : email.trim();
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate unique connection ID
|
||||
*/
|
||||
export function generateConnectionId(): string {
|
||||
return `smtp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Format timeout duration for human readability
|
||||
*/
|
||||
export function formatTimeout(milliseconds: number): string {
|
||||
if (milliseconds < 1000) {
|
||||
return `${milliseconds}ms`;
|
||||
} else if (milliseconds < 60000) {
|
||||
return `${Math.round(milliseconds / 1000)}s`;
|
||||
} else {
|
||||
return `${Math.round(milliseconds / 60000)}m`;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate and normalize email data size
|
||||
*/
|
||||
export function validateEmailSize(emailData: string, maxSize?: number): boolean {
|
||||
const size = Buffer.byteLength(emailData, 'utf8');
|
||||
return !maxSize || size <= maxSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clean sensitive data from logs
|
||||
*/
|
||||
export function sanitizeForLogging(data: any): any {
|
||||
if (typeof data !== 'object' || data === null) {
|
||||
return data;
|
||||
}
|
||||
|
||||
const sanitized = { ...data };
|
||||
const sensitiveFields = ['password', 'pass', 'accessToken', 'refreshToken', 'clientSecret'];
|
||||
|
||||
for (const field of sensitiveFields) {
|
||||
if (field in sanitized) {
|
||||
sanitized[field] = '[REDACTED]';
|
||||
}
|
||||
}
|
||||
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate exponential backoff delay
|
||||
*/
|
||||
export function calculateBackoffDelay(attempt: number, baseDelay: number = 1000): number {
|
||||
return Math.min(baseDelay * Math.pow(2, attempt - 1), 30000); // Max 30 seconds
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse enhanced status code
|
||||
*/
|
||||
export function parseEnhancedStatusCode(code: string): { class: number; subject: number; detail: number } | null {
|
||||
const match = code.match(/^(\d)\.(\d)\.(\d)$/);
|
||||
if (!match) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
class: parseInt(match[1], 10),
|
||||
subject: parseInt(match[2], 10),
|
||||
detail: parseInt(match[3], 10)
|
||||
};
|
||||
}
|
||||
@@ -1,212 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Logging Utilities
|
||||
* Client-side logging utilities for SMTP operations
|
||||
*/
|
||||
|
||||
import { logger } from '../../../../logger.js';
|
||||
import type { ISmtpResponse, ISmtpClientOptions } from '../interfaces.js';
|
||||
|
||||
export interface ISmtpClientLogData {
|
||||
component: string;
|
||||
host?: string;
|
||||
port?: number;
|
||||
secure?: boolean;
|
||||
command?: string;
|
||||
response?: ISmtpResponse;
|
||||
error?: Error;
|
||||
connectionId?: string;
|
||||
messageId?: string;
|
||||
duration?: number;
|
||||
[key: string]: any;
|
||||
}
|
||||
|
||||
/**
|
||||
* Log SMTP client connection events
|
||||
*/
|
||||
export function logConnection(
|
||||
event: 'connecting' | 'connected' | 'disconnected' | 'error',
|
||||
options: ISmtpClientOptions,
|
||||
data?: Partial<ISmtpClientLogData>
|
||||
): void {
|
||||
const logData: ISmtpClientLogData = {
|
||||
component: 'smtp-client',
|
||||
event,
|
||||
host: options.host,
|
||||
port: options.port,
|
||||
secure: options.secure,
|
||||
...data
|
||||
};
|
||||
|
||||
switch (event) {
|
||||
case 'connecting':
|
||||
logger.info('SMTP client connecting', logData);
|
||||
break;
|
||||
case 'connected':
|
||||
logger.info('SMTP client connected', logData);
|
||||
break;
|
||||
case 'disconnected':
|
||||
logger.info('SMTP client disconnected', logData);
|
||||
break;
|
||||
case 'error':
|
||||
logger.error('SMTP client connection error', logData);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Log SMTP command execution
|
||||
*/
|
||||
export function logCommand(
|
||||
command: string,
|
||||
response?: ISmtpResponse,
|
||||
options?: ISmtpClientOptions,
|
||||
data?: Partial<ISmtpClientLogData>
|
||||
): void {
|
||||
const logData: ISmtpClientLogData = {
|
||||
component: 'smtp-client',
|
||||
command,
|
||||
response,
|
||||
host: options?.host,
|
||||
port: options?.port,
|
||||
...data
|
||||
};
|
||||
|
||||
if (response && response.code >= 400) {
|
||||
logger.warn('SMTP command failed', logData);
|
||||
} else {
|
||||
logger.debug('SMTP command executed', logData);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Log authentication events
|
||||
*/
|
||||
export function logAuthentication(
|
||||
event: 'start' | 'success' | 'failure',
|
||||
method: string,
|
||||
options: ISmtpClientOptions,
|
||||
data?: Partial<ISmtpClientLogData>
|
||||
): void {
|
||||
const logData: ISmtpClientLogData = {
|
||||
component: 'smtp-client',
|
||||
event: `auth_${event}`,
|
||||
authMethod: method,
|
||||
host: options.host,
|
||||
port: options.port,
|
||||
...data
|
||||
};
|
||||
|
||||
switch (event) {
|
||||
case 'start':
|
||||
logger.debug('SMTP authentication started', logData);
|
||||
break;
|
||||
case 'success':
|
||||
logger.info('SMTP authentication successful', logData);
|
||||
break;
|
||||
case 'failure':
|
||||
logger.error('SMTP authentication failed', logData);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Log TLS/STARTTLS events
|
||||
*/
|
||||
export function logTLS(
|
||||
event: 'starttls_start' | 'starttls_success' | 'starttls_failure' | 'tls_connected',
|
||||
options: ISmtpClientOptions,
|
||||
data?: Partial<ISmtpClientLogData>
|
||||
): void {
|
||||
const logData: ISmtpClientLogData = {
|
||||
component: 'smtp-client',
|
||||
event,
|
||||
host: options.host,
|
||||
port: options.port,
|
||||
...data
|
||||
};
|
||||
|
||||
if (event.includes('failure')) {
|
||||
logger.error('SMTP TLS operation failed', logData);
|
||||
} else {
|
||||
logger.info('SMTP TLS operation', logData);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Log email sending events
|
||||
*/
|
||||
export function logEmailSend(
|
||||
event: 'start' | 'success' | 'failure',
|
||||
recipients: string[],
|
||||
options: ISmtpClientOptions,
|
||||
data?: Partial<ISmtpClientLogData>
|
||||
): void {
|
||||
const logData: ISmtpClientLogData = {
|
||||
component: 'smtp-client',
|
||||
event: `send_${event}`,
|
||||
recipientCount: recipients.length,
|
||||
recipients: recipients.slice(0, 5), // Only log first 5 recipients for privacy
|
||||
host: options.host,
|
||||
port: options.port,
|
||||
...data
|
||||
};
|
||||
|
||||
switch (event) {
|
||||
case 'start':
|
||||
logger.info('SMTP email send started', logData);
|
||||
break;
|
||||
case 'success':
|
||||
logger.info('SMTP email send successful', logData);
|
||||
break;
|
||||
case 'failure':
|
||||
logger.error('SMTP email send failed', logData);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Log performance metrics
|
||||
*/
|
||||
export function logPerformance(
|
||||
operation: string,
|
||||
duration: number,
|
||||
options: ISmtpClientOptions,
|
||||
data?: Partial<ISmtpClientLogData>
|
||||
): void {
|
||||
const logData: ISmtpClientLogData = {
|
||||
component: 'smtp-client',
|
||||
operation,
|
||||
duration,
|
||||
host: options.host,
|
||||
port: options.port,
|
||||
...data
|
||||
};
|
||||
|
||||
if (duration > 10000) { // Log slow operations (>10s)
|
||||
logger.warn('SMTP slow operation detected', logData);
|
||||
} else {
|
||||
logger.debug('SMTP operation performance', logData);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Log debug information (only when debug is enabled)
|
||||
*/
|
||||
export function logDebug(
|
||||
message: string,
|
||||
options: ISmtpClientOptions,
|
||||
data?: Partial<ISmtpClientLogData>
|
||||
): void {
|
||||
if (!options.debug) {
|
||||
return;
|
||||
}
|
||||
|
||||
const logData: ISmtpClientLogData = {
|
||||
component: 'smtp-client-debug',
|
||||
host: options.host,
|
||||
port: options.port,
|
||||
...data
|
||||
};
|
||||
|
||||
logger.debug(`[SMTP Client Debug] ${message}`, logData);
|
||||
}
|
||||
@@ -1,170 +0,0 @@
|
||||
/**
|
||||
* SMTP Client Validation Utilities
|
||||
* Input validation functions for SMTP client operations
|
||||
*/
|
||||
|
||||
import { REGEX_PATTERNS } from '../constants.js';
|
||||
import type { ISmtpClientOptions, ISmtpAuthOptions } from '../interfaces.js';
|
||||
|
||||
/**
|
||||
* Validate email address format
|
||||
* Supports RFC-compliant addresses including empty return paths for bounces
|
||||
*/
|
||||
export function validateEmailAddress(email: string): boolean {
|
||||
if (typeof email !== 'string') {
|
||||
return false;
|
||||
}
|
||||
|
||||
const trimmed = email.trim();
|
||||
|
||||
// Handle empty return path for bounce messages (RFC 5321)
|
||||
if (trimmed === '' || trimmed === '<>') {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Handle display name formats
|
||||
const angleMatch = trimmed.match(/<([^>]+)>/);
|
||||
if (angleMatch) {
|
||||
return REGEX_PATTERNS.EMAIL_ADDRESS.test(angleMatch[1]);
|
||||
}
|
||||
|
||||
// Regular email validation
|
||||
return REGEX_PATTERNS.EMAIL_ADDRESS.test(trimmed);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate SMTP client options
|
||||
*/
|
||||
export function validateClientOptions(options: ISmtpClientOptions): string[] {
|
||||
const errors: string[] = [];
|
||||
|
||||
// Required fields
|
||||
if (!options.host || typeof options.host !== 'string') {
|
||||
errors.push('Host is required and must be a string');
|
||||
}
|
||||
|
||||
if (!options.port || typeof options.port !== 'number' || options.port < 1 || options.port > 65535) {
|
||||
errors.push('Port must be a number between 1 and 65535');
|
||||
}
|
||||
|
||||
// Optional field validation
|
||||
if (options.connectionTimeout !== undefined) {
|
||||
if (typeof options.connectionTimeout !== 'number' || options.connectionTimeout < 1000) {
|
||||
errors.push('Connection timeout must be a number >= 1000ms');
|
||||
}
|
||||
}
|
||||
|
||||
if (options.socketTimeout !== undefined) {
|
||||
if (typeof options.socketTimeout !== 'number' || options.socketTimeout < 1000) {
|
||||
errors.push('Socket timeout must be a number >= 1000ms');
|
||||
}
|
||||
}
|
||||
|
||||
if (options.maxConnections !== undefined) {
|
||||
if (typeof options.maxConnections !== 'number' || options.maxConnections < 1) {
|
||||
errors.push('Max connections must be a positive number');
|
||||
}
|
||||
}
|
||||
|
||||
if (options.maxMessages !== undefined) {
|
||||
if (typeof options.maxMessages !== 'number' || options.maxMessages < 1) {
|
||||
errors.push('Max messages must be a positive number');
|
||||
}
|
||||
}
|
||||
|
||||
// Validate authentication options
|
||||
if (options.auth) {
|
||||
errors.push(...validateAuthOptions(options.auth));
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate authentication options
|
||||
*/
|
||||
export function validateAuthOptions(auth: ISmtpAuthOptions): string[] {
|
||||
const errors: string[] = [];
|
||||
|
||||
if (auth.method && !['PLAIN', 'LOGIN', 'OAUTH2', 'AUTO'].includes(auth.method)) {
|
||||
errors.push('Invalid authentication method');
|
||||
}
|
||||
|
||||
// For basic auth, require user and pass
|
||||
if ((auth.user || auth.pass) && (!auth.user || !auth.pass)) {
|
||||
errors.push('Both user and pass are required for basic authentication');
|
||||
}
|
||||
|
||||
// For OAuth2, validate required fields
|
||||
if (auth.oauth2) {
|
||||
const oauth = auth.oauth2;
|
||||
if (!oauth.user || !oauth.clientId || !oauth.clientSecret || !oauth.refreshToken) {
|
||||
errors.push('OAuth2 requires user, clientId, clientSecret, and refreshToken');
|
||||
}
|
||||
|
||||
if (oauth.user && !validateEmailAddress(oauth.user)) {
|
||||
errors.push('OAuth2 user must be a valid email address');
|
||||
}
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate hostname format
|
||||
*/
|
||||
export function validateHostname(hostname: string): boolean {
|
||||
if (!hostname || typeof hostname !== 'string') {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Basic hostname validation (allow IP addresses and domain names)
|
||||
const hostnameRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$|^(?:\d{1,3}\.){3}\d{1,3}$|^\[(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\]$/;
|
||||
return hostnameRegex.test(hostname);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate port number
|
||||
*/
|
||||
export function validatePort(port: number): boolean {
|
||||
return typeof port === 'number' && port >= 1 && port <= 65535;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitize and validate domain name for EHLO
|
||||
*/
|
||||
export function validateAndSanitizeDomain(domain: string): string {
|
||||
if (!domain || typeof domain !== 'string') {
|
||||
return 'localhost';
|
||||
}
|
||||
|
||||
const sanitized = domain.trim().toLowerCase();
|
||||
if (validateHostname(sanitized)) {
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
return 'localhost';
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate recipient list
|
||||
*/
|
||||
export function validateRecipients(recipients: string | string[]): string[] {
|
||||
const errors: string[] = [];
|
||||
const recipientList = Array.isArray(recipients) ? recipients : [recipients];
|
||||
|
||||
for (const recipient of recipientList) {
|
||||
if (!validateEmailAddress(recipient)) {
|
||||
errors.push(`Invalid email address: ${recipient}`);
|
||||
}
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate sender address
|
||||
*/
|
||||
export function validateSender(sender: string): boolean {
|
||||
return validateEmailAddress(sender);
|
||||
}
|
||||
@@ -17,8 +17,7 @@ import { Email } from '../core/classes.email.js';
|
||||
import { DomainRegistry } from './classes.domain.registry.js';
|
||||
import { DnsManager } from './classes.dns.manager.js';
|
||||
import { BounceManager, BounceType, BounceCategory } from '../core/classes.bouncemanager.js';
|
||||
import { createPooledSmtpClient } from '../delivery/smtpclient/create-client.js';
|
||||
import type { SmtpClient } from '../delivery/smtpclient/smtp-client.js';
|
||||
import type { ISmtpSendResult, IOutboundEmail } from '../../security/classes.rustsecuritybridge.js';
|
||||
import { MultiModeDeliverySystem, type IMultiModeDeliveryOptions } from '../delivery/classes.delivery.system.js';
|
||||
import { UnifiedDeliveryQueue, type IQueueOptions } from '../delivery/classes.delivery.queue.js';
|
||||
import { UnifiedRateLimiter, type IHierarchicalRateLimits } from '../delivery/classes.unified.rate.limiter.js';
|
||||
@@ -167,7 +166,6 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
public deliverySystem: MultiModeDeliverySystem;
|
||||
private rateLimiter: UnifiedRateLimiter; // TODO: Implement rate limiting in SMTP server handlers
|
||||
private dkimKeys: Map<string, string> = new Map(); // domain -> private key
|
||||
private smtpClients: Map<string, SmtpClient> = new Map(); // host:port -> client
|
||||
|
||||
constructor(dcRouter: DcRouter, options: IUnifiedEmailServerOptions) {
|
||||
super();
|
||||
@@ -242,17 +240,8 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
bounceHandler: {
|
||||
processSmtpFailure: this.processSmtpFailure.bind(this)
|
||||
},
|
||||
onDeliverySuccess: async (item, _result) => {
|
||||
// Record delivery success event for reputation monitoring
|
||||
const email = item.processingResult as Email;
|
||||
const senderDomain = email.from.split('@')[1];
|
||||
|
||||
if (senderDomain) {
|
||||
this.recordReputationEvent(senderDomain, {
|
||||
type: 'delivered',
|
||||
count: email.to.length
|
||||
});
|
||||
}
|
||||
onDeliverySuccess: async (_item, _result) => {
|
||||
// Delivery success recorded via delivery system
|
||||
}
|
||||
};
|
||||
|
||||
@@ -281,34 +270,50 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get or create an SMTP client for the given host and port
|
||||
* Uses connection pooling for efficiency
|
||||
* Send an outbound email via the Rust SMTP client.
|
||||
* Uses connection pooling in the Rust binary for efficiency.
|
||||
*/
|
||||
public getSmtpClient(host: string, port: number = 25): SmtpClient {
|
||||
const clientKey = `${host}:${port}`;
|
||||
|
||||
// Check if we already have a client for this destination
|
||||
let client = this.smtpClients.get(clientKey);
|
||||
|
||||
if (!client) {
|
||||
// Create a new pooled SMTP client
|
||||
client = createPooledSmtpClient({
|
||||
host,
|
||||
port,
|
||||
secure: port === 465,
|
||||
connectionTimeout: this.options.outbound?.connectionTimeout || 30000,
|
||||
socketTimeout: this.options.outbound?.socketTimeout || 120000,
|
||||
maxConnections: this.options.outbound?.maxConnections || 10,
|
||||
maxMessages: 1000, // Messages per connection before reconnect
|
||||
pool: true,
|
||||
debug: false
|
||||
});
|
||||
|
||||
this.smtpClients.set(clientKey, client);
|
||||
logger.log('info', `Created new SMTP client pool for ${clientKey}`);
|
||||
public async sendOutboundEmail(host: string, port: number, email: Email, options?: {
|
||||
auth?: { user: string; pass: string };
|
||||
dkimDomain?: string;
|
||||
dkimSelector?: string;
|
||||
}): Promise<ISmtpSendResult> {
|
||||
// Build DKIM config if domain has keys
|
||||
let dkim: { domain: string; selector: string; privateKey: string } | undefined;
|
||||
if (options?.dkimDomain) {
|
||||
try {
|
||||
const { privateKey } = await this.dkimCreator.readDKIMKeys(options.dkimDomain);
|
||||
dkim = { domain: options.dkimDomain, selector: options.dkimSelector || 'default', privateKey };
|
||||
} catch (err) {
|
||||
logger.log('warn', `Failed to read DKIM keys for ${options.dkimDomain}: ${(err as Error).message}`);
|
||||
}
|
||||
}
|
||||
|
||||
return client;
|
||||
|
||||
// Serialize the Email to the outbound format
|
||||
const outboundEmail: IOutboundEmail = {
|
||||
from: email.from,
|
||||
to: email.to,
|
||||
cc: email.cc || [],
|
||||
bcc: email.bcc || [],
|
||||
subject: email.subject || '',
|
||||
text: email.text || '',
|
||||
html: email.html || undefined,
|
||||
headers: email.headers as Record<string, string> || {},
|
||||
};
|
||||
|
||||
return this.rustBridge.sendOutboundEmail({
|
||||
host,
|
||||
port,
|
||||
secure: port === 465,
|
||||
domain: this.options.hostname,
|
||||
auth: options?.auth,
|
||||
email: outboundEmail,
|
||||
dkim,
|
||||
connectionTimeoutSecs: Math.floor((this.options.outbound?.connectionTimeout || 30000) / 1000),
|
||||
socketTimeoutSecs: Math.floor((this.options.outbound?.socketTimeout || 120000) / 1000),
|
||||
poolKey: `${host}:${port}`,
|
||||
maxPoolConnections: this.options.outbound?.maxConnections || 10,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -486,16 +491,12 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
logger.log('info', 'Email delivery queue shut down');
|
||||
}
|
||||
|
||||
// Close all SMTP client connections
|
||||
for (const [clientKey, client] of this.smtpClients) {
|
||||
try {
|
||||
await client.close();
|
||||
logger.log('info', `Closed SMTP client pool for ${clientKey}`);
|
||||
} catch (error) {
|
||||
logger.log('warn', `Error closing SMTP client for ${clientKey}: ${error.message}`);
|
||||
}
|
||||
// Close all Rust SMTP client connection pools
|
||||
try {
|
||||
await this.rustBridge.closeSmtpPool();
|
||||
} catch {
|
||||
// Bridge may already be stopped
|
||||
}
|
||||
this.smtpClients.clear();
|
||||
|
||||
logger.log('info', 'UnifiedEmailServer stopped successfully');
|
||||
this.emit('stopped');
|
||||
@@ -826,13 +827,12 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
email.headers['X-Forwarded-To'] = email.to.join(', ');
|
||||
email.headers['X-Forwarded-Date'] = new Date().toISOString();
|
||||
|
||||
// Get SMTP client
|
||||
const client = this.getSmtpClient(host, port);
|
||||
|
||||
try {
|
||||
// Send email
|
||||
await client.sendMail(email);
|
||||
|
||||
// Send email via Rust SMTP client
|
||||
await this.sendOutboundEmail(host, port, email, {
|
||||
auth: auth as { user: string; pass: string } | undefined,
|
||||
});
|
||||
|
||||
logger.log('info', `Successfully forwarded email to ${host}:${port}`);
|
||||
|
||||
SecurityLogger.getInstance().logEvent({
|
||||
@@ -1297,15 +1297,6 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
// Queue the email for delivery
|
||||
await this.deliveryQueue.enqueue(email, mode, route);
|
||||
|
||||
// Record 'sent' event for domain reputation monitoring
|
||||
const senderDomain = email.from.split('@')[1];
|
||||
if (senderDomain) {
|
||||
this.recordReputationEvent(senderDomain, {
|
||||
type: 'sent',
|
||||
count: email.to.length
|
||||
});
|
||||
}
|
||||
|
||||
logger.log('info', `Email queued with ID: ${id}`);
|
||||
return id;
|
||||
} catch (error) {
|
||||
@@ -1370,15 +1361,6 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
// Notify any registered listeners about the bounce
|
||||
this.emit('bounceProcessed', bounceRecord);
|
||||
|
||||
// Record bounce event for domain reputation tracking
|
||||
if (bounceRecord.domain) {
|
||||
this.recordReputationEvent(bounceRecord.domain, {
|
||||
type: 'bounce',
|
||||
hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
|
||||
receivingDomain: bounceRecord.recipient.split('@')[1]
|
||||
});
|
||||
}
|
||||
|
||||
// Log security event
|
||||
SecurityLogger.getInstance().logEvent({
|
||||
level: SecurityLogLevel.INFO,
|
||||
@@ -1450,15 +1432,6 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
// Notify any registered listeners about the bounce
|
||||
this.emit('bounceProcessed', bounceRecord);
|
||||
|
||||
// Record bounce event for domain reputation tracking
|
||||
if (bounceRecord.domain) {
|
||||
this.recordReputationEvent(bounceRecord.domain, {
|
||||
type: 'bounce',
|
||||
hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
|
||||
receivingDomain: bounceRecord.recipient.split('@')[1]
|
||||
});
|
||||
}
|
||||
|
||||
// Log security event
|
||||
SecurityLogger.getInstance().logEvent({
|
||||
level: SecurityLogLevel.INFO,
|
||||
@@ -1566,40 +1539,6 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
logger.log('info', `Removed ${email} from suppression list`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Record an email event for domain reputation tracking.
|
||||
* Currently a no-op — the sender reputation monitor is not yet implemented.
|
||||
* @param domain Domain sending the email
|
||||
* @param event Event details
|
||||
*/
|
||||
public recordReputationEvent(domain: string, event: {
|
||||
type: 'sent' | 'delivered' | 'bounce' | 'complaint' | 'open' | 'click';
|
||||
count?: number;
|
||||
hardBounce?: boolean;
|
||||
receivingDomain?: string;
|
||||
}): void {
|
||||
logger.log('debug', `Reputation event for ${domain}: ${event.type}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if DKIM key exists for a domain
|
||||
* @param domain Domain to check
|
||||
*/
|
||||
public hasDkimKey(domain: string): boolean {
|
||||
return this.dkimKeys.has(domain);
|
||||
}
|
||||
|
||||
/**
|
||||
* Record successful email delivery
|
||||
* @param domain Sending domain
|
||||
*/
|
||||
public recordDelivery(domain: string): void {
|
||||
this.recordReputationEvent(domain, {
|
||||
type: 'delivered',
|
||||
count: 1
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Record email bounce
|
||||
* @param domain Sending domain
|
||||
@@ -1608,7 +1547,6 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
* @param reason Bounce reason
|
||||
*/
|
||||
public recordBounce(domain: string, receivingDomain: string, bounceType: 'hard' | 'soft', reason: string): void {
|
||||
// Record bounce in bounce manager
|
||||
const bounceRecord = {
|
||||
id: `bounce_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
|
||||
recipient: `user@${receivingDomain}`,
|
||||
@@ -1622,17 +1560,8 @@ export class UnifiedEmailServer extends EventEmitter {
|
||||
statusCode: bounceType === 'hard' ? '550' : '450',
|
||||
processed: false
|
||||
};
|
||||
|
||||
// Process the bounce
|
||||
|
||||
this.bounceManager.processBounce(bounceRecord);
|
||||
|
||||
// Record reputation event
|
||||
this.recordReputationEvent(domain, {
|
||||
type: 'bounce',
|
||||
count: 1,
|
||||
hardBounce: bounceType === 'hard',
|
||||
receivingDomain
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -21,61 +21,21 @@ export {
|
||||
util,
|
||||
}
|
||||
|
||||
// @serve.zone scope
|
||||
import * as servezoneInterfaces from '@serve.zone/interfaces';
|
||||
|
||||
export {
|
||||
servezoneInterfaces
|
||||
}
|
||||
|
||||
// @api.global scope
|
||||
import * as typedrequest from '@api.global/typedrequest';
|
||||
import * as typedserver from '@api.global/typedserver';
|
||||
import * as typedsocket from '@api.global/typedsocket';
|
||||
|
||||
export {
|
||||
typedrequest,
|
||||
typedserver,
|
||||
typedsocket,
|
||||
}
|
||||
|
||||
// @push.rocks scope
|
||||
import * as projectinfo from '@push.rocks/projectinfo';
|
||||
import * as qenv from '@push.rocks/qenv';
|
||||
import * as smartacme from '@push.rocks/smartacme';
|
||||
import * as smartdata from '@push.rocks/smartdata';
|
||||
import * as smartdns from '@push.rocks/smartdns';
|
||||
import * as smartfile from '@push.rocks/smartfile';
|
||||
import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
|
||||
import * as smartguard from '@push.rocks/smartguard';
|
||||
import * as smartjwt from '@push.rocks/smartjwt';
|
||||
import * as smartlog from '@push.rocks/smartlog';
|
||||
import * as smartmail from '@push.rocks/smartmail';
|
||||
import * as smartmetrics from '@push.rocks/smartmetrics';
|
||||
import * as smartnetwork from '@push.rocks/smartnetwork';
|
||||
import * as smartpath from '@push.rocks/smartpath';
|
||||
import * as smartproxy from '@push.rocks/smartproxy';
|
||||
import * as smartpromise from '@push.rocks/smartpromise';
|
||||
import * as smartrequest from '@push.rocks/smartrequest';
|
||||
import * as smartrule from '@push.rocks/smartrule';
|
||||
import * as smartrust from '@push.rocks/smartrust';
|
||||
import * as smartrx from '@push.rocks/smartrx';
|
||||
import * as smartunique from '@push.rocks/smartunique';
|
||||
|
||||
export const smartfs = new SmartFs(new SmartFsProviderNode());
|
||||
|
||||
export { projectinfo, qenv, smartacme, smartdata, smartdns, smartfile, SmartFs, smartguard, smartjwt, smartlog, smartmail, smartmetrics, smartnetwork, smartpath, smartproxy, smartpromise, smartrequest, smartrule, smartrust, smartrx, smartunique };
|
||||
export { smartfile, SmartFs, smartlog, smartmail, smartpath, smartrust };
|
||||
|
||||
// Define SmartLog types for use in error handling
|
||||
export type TLogLevel = 'error' | 'warn' | 'info' | 'success' | 'debug';
|
||||
|
||||
// apiclient.xyz scope
|
||||
import * as cloudflare from '@apiclient.xyz/cloudflare';
|
||||
|
||||
export {
|
||||
cloudflare,
|
||||
}
|
||||
|
||||
// tsclass scope
|
||||
import * as tsclass from '@tsclass/tsclass';
|
||||
|
||||
|
||||
@@ -67,6 +67,71 @@ interface IContentScanResult {
|
||||
scannedElements: string[];
|
||||
}
|
||||
|
||||
// --- SMTP Client types ---
|
||||
|
||||
interface IOutboundEmail {
|
||||
from: string;
|
||||
to: string[];
|
||||
cc?: string[];
|
||||
bcc?: string[];
|
||||
subject?: string;
|
||||
text?: string;
|
||||
html?: string;
|
||||
headers?: Record<string, string>;
|
||||
}
|
||||
|
||||
interface ISmtpSendResult {
|
||||
accepted: string[];
|
||||
rejected: string[];
|
||||
messageId?: string;
|
||||
response: string;
|
||||
envelope: { from: string; to: string[] };
|
||||
}
|
||||
|
||||
interface ISmtpSendOptions {
|
||||
host: string;
|
||||
port: number;
|
||||
secure?: boolean;
|
||||
domain?: string;
|
||||
auth?: { user: string; pass: string; method?: string };
|
||||
email: IOutboundEmail;
|
||||
dkim?: { domain: string; selector: string; privateKey: string };
|
||||
connectionTimeoutSecs?: number;
|
||||
socketTimeoutSecs?: number;
|
||||
poolKey?: string;
|
||||
maxPoolConnections?: number;
|
||||
}
|
||||
|
||||
interface ISmtpSendRawOptions {
|
||||
host: string;
|
||||
port: number;
|
||||
secure?: boolean;
|
||||
domain?: string;
|
||||
auth?: { user: string; pass: string; method?: string };
|
||||
envelopeFrom: string;
|
||||
envelopeTo: string[];
|
||||
rawMessageBase64: string;
|
||||
poolKey?: string;
|
||||
}
|
||||
|
||||
interface ISmtpVerifyOptions {
|
||||
host: string;
|
||||
port: number;
|
||||
secure?: boolean;
|
||||
domain?: string;
|
||||
auth?: { user: string; pass: string; method?: string };
|
||||
}
|
||||
|
||||
interface ISmtpVerifyResult {
|
||||
reachable: boolean;
|
||||
greeting?: string;
|
||||
capabilities?: string[];
|
||||
}
|
||||
|
||||
interface ISmtpPoolStatus {
|
||||
pools: Record<string, { total: number; active: number; idle: number }>;
|
||||
}
|
||||
|
||||
interface IVersionInfo {
|
||||
bin: string;
|
||||
core: string;
|
||||
@@ -212,6 +277,26 @@ type TMailerCommands = {
|
||||
params: IRateLimitConfig;
|
||||
result: { configured: boolean };
|
||||
};
|
||||
sendEmail: {
|
||||
params: ISmtpSendOptions;
|
||||
result: ISmtpSendResult;
|
||||
};
|
||||
sendRawEmail: {
|
||||
params: ISmtpSendRawOptions;
|
||||
result: ISmtpSendResult;
|
||||
};
|
||||
verifySmtpConnection: {
|
||||
params: ISmtpVerifyOptions;
|
||||
result: ISmtpVerifyResult;
|
||||
};
|
||||
closeSmtpPool: {
|
||||
params: { poolKey?: string };
|
||||
result: { closed: boolean };
|
||||
};
|
||||
getSmtpPoolStatus: {
|
||||
params: Record<string, never>;
|
||||
result: ISmtpPoolStatus;
|
||||
};
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -660,6 +745,40 @@ export class RustSecurityBridge extends EventEmitter {
|
||||
return this.bridge.sendCommand('verifyEmail', opts);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// SMTP Client — outbound email delivery via Rust
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
/** Send a structured email via the Rust SMTP client. */
|
||||
public async sendOutboundEmail(opts: ISmtpSendOptions): Promise<ISmtpSendResult> {
|
||||
this.ensureRunning();
|
||||
return this.bridge.sendCommand('sendEmail', opts);
|
||||
}
|
||||
|
||||
/** Send a pre-formatted raw email via the Rust SMTP client. */
|
||||
public async sendRawEmail(opts: ISmtpSendRawOptions): Promise<ISmtpSendResult> {
|
||||
this.ensureRunning();
|
||||
return this.bridge.sendCommand('sendRawEmail', opts);
|
||||
}
|
||||
|
||||
/** Verify connectivity to an SMTP server. */
|
||||
public async verifySmtpConnection(opts: ISmtpVerifyOptions): Promise<ISmtpVerifyResult> {
|
||||
this.ensureRunning();
|
||||
return this.bridge.sendCommand('verifySmtpConnection', opts);
|
||||
}
|
||||
|
||||
/** Close a specific connection pool (or all pools if no key is given). */
|
||||
public async closeSmtpPool(poolKey?: string): Promise<void> {
|
||||
this.ensureRunning();
|
||||
await this.bridge.sendCommand('closeSmtpPool', poolKey ? { poolKey } : ({} as any));
|
||||
}
|
||||
|
||||
/** Get status of all SMTP client connection pools. */
|
||||
public async getSmtpPoolStatus(): Promise<ISmtpPoolStatus> {
|
||||
this.ensureRunning();
|
||||
return this.bridge.sendCommand('getSmtpPoolStatus', {} as any);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// SMTP Server lifecycle
|
||||
// -----------------------------------------------------------------------
|
||||
@@ -763,4 +882,11 @@ export type {
|
||||
IEmailData,
|
||||
IEmailReceivedEvent,
|
||||
IAuthRequestEvent,
|
||||
IOutboundEmail,
|
||||
ISmtpSendResult,
|
||||
ISmtpSendOptions,
|
||||
ISmtpSendRawOptions,
|
||||
ISmtpVerifyOptions,
|
||||
ISmtpVerifyResult,
|
||||
ISmtpPoolStatus,
|
||||
};
|
||||
|
||||
@@ -32,4 +32,9 @@ export {
|
||||
type IBounceDetection,
|
||||
type IRustReputationResult,
|
||||
type IVersionInfo,
|
||||
type IOutboundEmail,
|
||||
type ISmtpSendResult,
|
||||
type ISmtpSendOptions,
|
||||
type ISmtpVerifyResult,
|
||||
type ISmtpPoolStatus,
|
||||
} from './classes.rustsecuritybridge.js';
|
||||
Reference in New Issue
Block a user