serve.zone/mailer
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

feat(storage): add comprehensive tests for StorageManager with memory, filesystem, and custom function backends
Some checks failed
CI / Type Check & Lint (push) Failing after 3s
Details
CI / Build Test (Current Platform) (push) Failing after 3s
Details
CI / Build All Platforms (push) Failing after 3s
Details

Browse Source 
feat(email): implement EmailSendJob class for robust email delivery with retry logic and MX record resolution

feat(mail): restructure mail module exports for simplified access to core and delivery functionalities
This commit is contained in:
Jürgen Kunz
2025-10-28 19:46:17 +00:00
parent 6523c55516
commit 17f5661636
271 changed files with 61736 additions and 6222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
ts/00_commitinfo_data.ts
View File

@@ -1,8 +0,0 @@
/**
* autocreated commitinfo by @push.rocks/commitinfo
*/
export const commitinfo = {
name: '@serve.zone/mailer',
version: '1.2.1',
description: 'Enterprise mail server with SMTP, HTTP API, and DNS management - built for serve.zone infrastructure'
}

73
ts/api/api-server.ts
View File

@@ -1,73 +0,0 @@
/**
* API Server
* HTTP REST API compatible with Mailgun
*/
import * as plugins from '../plugins.ts';
export interface IApiServerOptions {
port: number;
apiKeys: string[];
}
export class ApiServer {
private server: Deno.HttpServer | null = null;
constructor(private options: IApiServerOptions) {}
/**
* Start the API server
*/
async start(): Promise<void> {
console.log(`[ApiServer] Starting on port ${this.options.port}...`);
this.server = Deno.serve({ port: this.options.port }, (req) => {
return this.handleRequest(req);
});
}
/**
* Stop the API server
*/
async stop(): Promise<void> {
console.log('[ApiServer] Stopping...');
if (this.server) {
await this.server.shutdown();
this.server = null;
}
}
/**
* Handle incoming HTTP request
*/
private async handleRequest(req: Request): Promise<Response> {
const url = new URL(req.url);
// Basic routing
if (url.pathname === '/v1/messages' && req.method === 'POST') {
return this.handleSendEmail(req);
}
if (url.pathname === '/v1/domains' && req.method === 'GET') {
return this.handleListDomains(req);
}
return new Response('Not Found', { status: 404 });
}
private async handleSendEmail(req: Request): Promise<Response> {
// TODO: Implement email sending
return new Response(JSON.stringify({ message: 'Email queued' }), {
status: 200,
headers: { 'Content-Type': 'application/json' },
});
}
private async handleListDomains(req: Request): Promise<Response> {
// TODO: Implement domain listing
return new Response(JSON.stringify({ domains: [] }), {
status: 200,
headers: { 'Content-Type': 'application/json' },
});
}
}

7
ts/api/index.ts
View File

@@ -1,7 +0,0 @@
/**
* HTTP REST API module
* Mailgun-compatible API for sending and receiving emails
*/
export * from './api-server.ts';
export * from './routes/index.ts';

10
ts/api/routes/index.ts
View File

@@ -1,10 +0,0 @@
/**
* API Routes
* Route handlers for the REST API
*/
// TODO: Implement route handlers
// - POST /v1/messages - Send email
// - GET/POST/DELETE /v1/domains - Domain management
// - GET/POST /v1/domains/:domain/credentials - SMTP credentials
// - GET /v1/events - Email events and logs

26
ts/classes.mailer.ts
View File

@@ -1,26 +0,0 @@
/**
* Mailer class stub
* Main mailer application class (replaces DcRouter from dcrouter)
*/
import { StorageManager } from './storage/index.ts';
import type { IMailerConfig } from './config/config-manager.ts';
export interface IMailerOptions {
config?: IMailerConfig;
dnsNsDomains?: string[];
dnsScopes?: string[];
}
export class Mailer {
public storageManager: StorageManager;
public options?: IMailerOptions;
constructor(options?: IMailerOptions) {
this.options = options;
this.storageManager = new StorageManager();
}
}
// Export type alias for compatibility
export type DcRouter = Mailer;

10
ts/cli.ts
View File

@@ -1,10 +0,0 @@
/**
* CLI entry point
* Main command-line interface
*/
import { MailerCli } from './cli/mailer-cli.ts';
// Create and run CLI
const cli = new MailerCli();
await cli.parseAndExecute(Deno.args);

6
ts/cli/index.ts
View File

@@ -1,6 +0,0 @@
/**
* CLI module
* Command-line interface for mailer
*/
export * from './mailer-cli.ts';

387
ts/cli/mailer-cli.ts
View File

@@ -1,387 +0,0 @@
/**
* Mailer CLI
* Main command-line interface implementation
*/
import { DaemonManager } from '../daemon/daemon-manager.ts';
import { ConfigManager } from '../config/config-manager.ts';
import { DnsManager } from '../dns/dns-manager.ts';
import { CloudflareClient } from '../dns/cloudflare-client.ts';
import { Email } from '../mail/core/index.ts';
import { commitinfo } from '../00_commitinfo_data.ts';
export class MailerCli {
private configManager: ConfigManager;
private daemonManager: DaemonManager;
private dnsManager: DnsManager;
constructor() {
this.configManager = new ConfigManager();
this.daemonManager = new DaemonManager();
this.dnsManager = new DnsManager();
}
/**
* Parse and execute CLI commands
*/
async parseAndExecute(args: string[]): Promise<void> {
// Get command
const command = args[2] || 'help';
const subcommand = args[3];
const commandArgs = args.slice(4);
try {
switch (command) {
case 'service':
await this.handleServiceCommand(subcommand, commandArgs);
break;
case 'domain':
await this.handleDomainCommand(subcommand, commandArgs);
break;
case 'dns':
await this.handleDnsCommand(subcommand, commandArgs);
break;
case 'send':
await this.handleSendCommand(commandArgs);
break;
case 'config':
await this.handleConfigCommand(subcommand, commandArgs);
break;
case 'version':
case '--version':
case '-v':
this.showVersion();
break;
case 'help':
case '--help':
case '-h':
default:
this.showHelp();
break;
}
} catch (error) {
console.error(`Error: ${error.message}`);
Deno.exit(1);
}
}
/**
* Handle service commands (daemon control)
*/
private async handleServiceCommand(subcommand: string, args: string[]): Promise<void> {
switch (subcommand) {
case 'start':
console.log('Starting mailer daemon...');
await this.daemonManager.start();
break;
case 'stop':
console.log('Stopping mailer daemon...');
await this.daemonManager.stop();
break;
case 'restart':
console.log('Restarting mailer daemon...');
await this.daemonManager.stop();
await new Promise(resolve => setTimeout(resolve, 2000));
await this.daemonManager.start();
break;
case 'status':
console.log('Checking mailer daemon status...');
// TODO: Implement status check
break;
case 'enable':
console.log('Enabling mailer service (systemd)...');
// TODO: Implement systemd enable
break;
case 'disable':
console.log('Disabling mailer service (systemd)...');
// TODO: Implement systemd disable
break;
default:
console.log('Usage: mailer service {start|stop|restart|status|enable|disable}');
break;
}
}
/**
* Handle domain management commands
*/
private async handleDomainCommand(subcommand: string, args: string[]): Promise<void> {
const config = await this.configManager.load();
switch (subcommand) {
case 'add': {
const domain = args[0];
if (!domain) {
console.error('Error: Domain name required');
console.log('Usage: mailer domain add <domain>');
Deno.exit(1);
}
config.domains.push({
domain,
dnsMode: 'external-dns',
});
await this.configManager.save(config);
console.log(`✓ Domain ${domain} added`);
break;
}
case 'remove': {
const domain = args[0];
if (!domain) {
console.error('Error: Domain name required');
console.log('Usage: mailer domain remove <domain>');
Deno.exit(1);
}
config.domains = config.domains.filter(d => d.domain !== domain);
await this.configManager.save(config);
console.log(`✓ Domain ${domain} removed`);
break;
}
case 'list':
console.log('Configured domains:');
if (config.domains.length === 0) {
console.log(' (none)');
} else {
for (const domain of config.domains) {
console.log(` - ${domain.domain} (${domain.dnsMode})`);
}
}
break;
default:
console.log('Usage: mailer domain {add|remove|list} [domain]');
break;
}
}
/**
* Handle DNS commands
*/
private async handleDnsCommand(subcommand: string, args: string[]): Promise<void> {
const domain = args[0];
if (!domain && subcommand !== 'help') {
console.error('Error: Domain name required');
console.log('Usage: mailer dns {setup|validate|show} <domain>');
Deno.exit(1);
}
switch (subcommand) {
case 'setup': {
console.log(`Setting up DNS for ${domain}...`);
const config = await this.configManager.load();
const domainConfig = config.domains.find(d => d.domain === domain);
if (!domainConfig) {
console.error(`Error: Domain ${domain} not configured. Add it first with: mailer domain add ${domain}`);
Deno.exit(1);
}
if (!domainConfig.cloudflare?.apiToken) {
console.error('Error: Cloudflare API token not configured');
console.log('Set it with: mailer config set cloudflare.apiToken <token>');
Deno.exit(1);
}
const cloudflare = new CloudflareClient({ apiToken: domainConfig.cloudflare.apiToken });
const records = this.dnsManager.getRequiredRecords(domain, config.hostname);
await cloudflare.createRecords(domain, records);
console.log(`✓ DNS records created for ${domain}`);
break;
}
case 'validate': {
console.log(`Validating DNS for ${domain}...`);
const result = await this.dnsManager.validateDomain(domain);
if (result.valid) {
console.log(`✓ DNS configuration is valid`);
} else {
console.log(`✗ DNS configuration has errors:`);
for (const error of result.errors) {
console.log(` - ${error}`);
}
}
if (result.warnings.length > 0) {
console.log('Warnings:');
for (const warning of result.warnings) {
console.log(` - ${warning}`);
}
}
break;
}
case 'show': {
console.log(`Required DNS records for ${domain}:`);
const config = await this.configManager.load();
const records = this.dnsManager.getRequiredRecords(domain, config.hostname);
for (const record of records) {
console.log(`\n${record.type} Record:`);
console.log(` Name: ${record.name}`);
console.log(` Value: ${record.value}`);
if (record.priority) console.log(` Priority: ${record.priority}`);
if (record.ttl) console.log(` TTL: ${record.ttl}`);
}
break;
}
default:
console.log('Usage: mailer dns {setup|validate|show} <domain>');
break;
}
}
/**
* Handle send command
*/
private async handleSendCommand(args: string[]): Promise<void> {
console.log('Sending email...');
// Parse basic arguments
const from = args[args.indexOf('--from') + 1];
const to = args[args.indexOf('--to') + 1];
const subject = args[args.indexOf('--subject') + 1];
const text = args[args.indexOf('--text') + 1];
if (!from || !to || !subject || !text) {
console.error('Error: Missing required arguments');
console.log('Usage: mailer send --from <email> --to <email> --subject <subject> --text <text>');
Deno.exit(1);
}
const email = new Email({
from,
to,
subject,
text,
});
console.log(`✓ Email created: ${email.toString()}`);
// TODO: Actually send the email via SMTP client
console.log('TODO: Implement actual sending');
}
/**
* Handle config commands
*/
private async handleConfigCommand(subcommand: string, args: string[]): Promise<void> {
const config = await this.configManager.load();
switch (subcommand) {
case 'show':
console.log('Current configuration:');
console.log(JSON.stringify(config, null, 2));
break;
case 'set': {
const key = args[0];
const value = args[1];
if (!key || !value) {
console.error('Error: Key and value required');
console.log('Usage: mailer config set <key> <value>');
Deno.exit(1);
}
// Simple key-value setting (can be enhanced)
if (key === 'smtpPort') config.smtpPort = parseInt(value);
else if (key === 'apiPort') config.apiPort = parseInt(value);
else if (key === 'hostname') config.hostname = value;
else {
console.error(`Error: Unknown config key: ${key}`);
Deno.exit(1);
}
await this.configManager.save(config);
console.log(`✓ Configuration updated: ${key} = ${value}`);
break;
}
default:
console.log('Usage: mailer config {show|set} [key] [value]');
break;
}
}
/**
* Show version information
*/
private showVersion(): void {
console.log(`${commitinfo.name} v${commitinfo.version}`);
console.log(commitinfo.description);
}
/**
* Show help information
*/
private showHelp(): void {
console.log(`
${commitinfo.name} v${commitinfo.version}
${commitinfo.description}
Usage: mailer <command> [options]
Commands:
service <action> Daemon service control
start Start the mailer daemon
stop Stop the mailer daemon
restart Restart the mailer daemon
status Show daemon status
enable Enable systemd service
disable Disable systemd service
domain <action> [domain] Domain management
add <domain> Add a domain
remove <domain> Remove a domain
list List all domains
dns <action> <domain> DNS management
setup <domain> Auto-configure DNS via Cloudflare
validate <domain> Validate DNS configuration
show <domain> Show required DNS records
send [options] Send an email
--from <email> Sender email address
--to <email> Recipient email address
--subject <subject> Email subject
--text <text> Email body text
config <action> Configuration management
show Show current configuration
set <key> <value> Set configuration value
version, -v, --version Show version information
help, -h, --help Show this help message
Examples:
mailer service start Start the mailer daemon
mailer domain add example.com Add example.com domain
mailer dns setup example.com Setup DNS for example.com
mailer send --from sender@example.com --to recipient@example.com \\
--subject "Hello" --text "World"
For more information, visit:
https://code.foss.global/serve.zone/mailer
`);
}
}

83
ts/config/config-manager.ts
View File

@@ -1,83 +0,0 @@
/**
* Configuration Manager
* Handles configuration storage and retrieval
*/
import * as plugins from '../plugins.ts';
export interface IMailerConfig {
domains: IDomainConfig[];
apiKeys: string[];
smtpPort: number;
apiPort: number;
hostname: string;
}
export interface IDomainConfig {
domain: string;
dnsMode: 'forward' | 'internal-dns' | 'external-dns';
cloudflare?: {
apiToken: string;
};
}
export class ConfigManager {
private configPath: string;
private config: IMailerConfig | null = null;
constructor(configPath?: string) {
this.configPath = configPath || plugins.path.join(Deno.env.get('HOME') || '/root', '.mailer', 'config.json');
}
/**
* Load configuration from disk
*/
async load(): Promise<IMailerConfig> {
try {
const data = await Deno.readTextFile(this.configPath);
this.config = JSON.parse(data);
return this.config!;
} catch (error) {
// Return default config if file doesn't exist
this.config = this.getDefaultConfig();
return this.config;
}
}
/**
* Save configuration to disk
*/
async save(config: IMailerConfig): Promise<void> {
this.config = config;
// Ensure directory exists
const dir = plugins.path.dirname(this.configPath);
await Deno.mkdir(dir, { recursive: true });
// Write config
await Deno.writeTextFile(this.configPath, JSON.stringify(config, null, 2));
}
/**
* Get current configuration
*/
getConfig(): IMailerConfig {
if (!this.config) {
throw new Error('Configuration not loaded. Call load() first.');
}
return this.config;
}
/**
* Get default configuration
*/
private getDefaultConfig(): IMailerConfig {
return {
domains: [],
apiKeys: [],
smtpPort: 25,
apiPort: 8080,
hostname: 'localhost',
};
}
}

6
ts/config/index.ts
View File

@@ -1,6 +0,0 @@
/**
* Configuration module
* Configuration management and secure storage
*/
export * from './config-manager.ts';

57
ts/daemon/daemon-manager.ts
View File

@@ -1,57 +0,0 @@
/**
* Daemon Manager
* Manages the background mailer service
*/
import { SmtpServer } from '../mail/delivery/placeholder.ts';
import { ApiServer } from '../api/api-server.ts';
import { ConfigManager } from '../config/config-manager.ts';
export class DaemonManager {
private smtpServer: SmtpServer | null = null;
private apiServer: ApiServer | null = null;
private configManager: ConfigManager;
constructor() {
this.configManager = new ConfigManager();
}
/**
* Start the daemon
*/
async start(): Promise<void> {
console.log('[Daemon] Starting mailer daemon...');
// Load configuration
const config = await this.configManager.load();
// Start SMTP server
this.smtpServer = new SmtpServer({ port: config.smtpPort, hostname: config.hostname });
await this.smtpServer.start();
// Start API server
this.apiServer = new ApiServer({ port: config.apiPort, apiKeys: config.apiKeys });
await this.apiServer.start();
console.log('[Daemon] Mailer daemon started successfully');
console.log(`[Daemon] SMTP server: ${config.hostname}:${config.smtpPort}`);
console.log(`[Daemon] API server: http://${config.hostname}:${config.apiPort}`);
}
/**
* Stop the daemon
*/
async stop(): Promise<void> {
console.log('[Daemon] Stopping mailer daemon...');
if (this.smtpServer) {
await this.smtpServer.stop();
}
if (this.apiServer) {
await this.apiServer.stop();
}
console.log('[Daemon] Mailer daemon stopped');
}
}

6
ts/daemon/index.ts
View File

@@ -1,6 +0,0 @@
/**
* Daemon module
* Background service for SMTP server and API server
*/
export * from './daemon-manager.ts';

36
ts/deliverability/index.ts
View File

@@ -1,36 +0,0 @@
/**
* Deliverability module stub
* IP warmup and sender reputation monitoring
*/
export interface IIPWarmupConfig {
enabled: boolean;
initialLimit: number;
maxLimit: number;
incrementPerDay: number;
}
export interface IReputationMonitorConfig {
enabled: boolean;
checkInterval: number;
}
export class IPWarmupManager {
constructor(config: IIPWarmupConfig) {
// Stub implementation
}
async getCurrentLimit(ip: string): Promise<number> {
return 1000; // Stub: return high limit
}
}
export class SenderReputationMonitor {
constructor(config: IReputationMonitorConfig) {
// Stub implementation
}
async checkReputation(domain: string): Promise<{ score: number; issues: string[] }> {
return { score: 100, issues: [] };
}
}

37
ts/dns/cloudflare-client.ts
View File

@@ -1,37 +0,0 @@
/**
* Cloudflare DNS Client
* Automatic DNS record management via Cloudflare API
*/
import * as plugins from '../plugins.ts';
import type { IDnsRecord } from './dns-manager.ts';
export interface ICloudflareConfig {
apiToken: string;
email?: string;
}
export class CloudflareClient {
constructor(private config: ICloudflareConfig) {}
/**
* Create DNS records for a domain
*/
async createRecords(domain: string, records: IDnsRecord[]): Promise<void> {
console.log(`[CloudflareClient] Would create ${records.length} DNS records for ${domain}`);
// TODO: Implement actual Cloudflare API integration using @apiclient.xyz/cloudflare
for (const record of records) {
console.log(` - ${record.type} ${record.name} -> ${record.value}`);
}
}
/**
* Verify DNS records exist
*/
async verifyRecords(domain: string, records: IDnsRecord[]): Promise<boolean> {
console.log(`[CloudflareClient] Would verify ${records.length} DNS records for ${domain}`);
// TODO: Implement actual verification
return true;
}
}

68
ts/dns/dns-manager.ts
View File

@@ -1,68 +0,0 @@
/**
* DNS Manager
* Handles DNS record management and validation for email domains
*/
import * as plugins from '../plugins.ts';
export interface IDnsRecord {
type: 'MX' | 'TXT' | 'A' | 'AAAA';
name: string;
value: string;
priority?: number;
ttl?: number;
}
export interface IDnsValidationResult {
valid: boolean;
errors: string[];
warnings: string[];
requiredRecords: IDnsRecord[];
}
export class DnsManager {
/**
* Get required DNS records for a domain
*/
getRequiredRecords(domain: string, mailServerIp: string): IDnsRecord[] {
return [
{
type: 'MX',
name: domain,
value: `mail.${domain}`,
priority: 10,
ttl: 3600,
},
{
type: 'A',
name: `mail.${domain}`,
value: mailServerIp,
ttl: 3600,
},
{
type: 'TXT',
name: domain,
value: `v=spf1 mx ip4:${mailServerIp} ~all`,
ttl: 3600,
},
// TODO: Add DKIM and DMARC records
];
}
/**
* Validate DNS configuration for a domain
*/
async validateDomain(domain: string): Promise<IDnsValidationResult> {
const result: IDnsValidationResult = {
valid: true,
errors: [],
warnings: [],
requiredRecords: [],
};
// TODO: Implement actual DNS validation
console.log(`[DnsManager] Would validate DNS for ${domain}`);
return result;
}
}

7
ts/dns/index.ts
View File

@@ -1,7 +0,0 @@
/**
* DNS management module
* DNS validation and Cloudflare integration for automatic DNS setup
*/
export * from './dns-manager.ts';
export * from './cloudflare-client.ts';

24
ts/errors/index.ts
View File

@@ -1,24 +0,0 @@
/**
* Error types module stub
*/
export class SmtpError extends Error {
constructor(message: string, public code?: number) {
super(message);
this.name = 'SmtpError';
}
}
export class AuthenticationError extends Error {
constructor(message: string) {
super(message);
this.name = 'AuthenticationError';
}
}
export class RateLimitError extends Error {
constructor(message: string) {
super(message);
this.name = 'RateLimitError';
}
}

13
ts/index.ts
View File

@@ -1,13 +0,0 @@
/**
* @serve.zone/mailer
* Enterprise mail server with SMTP, HTTP API, and DNS management
*/
// Export public API
export * from './mail/core/index.ts';
export * from './mail/delivery/index.ts';
export * from './mail/routing/index.ts';
export * from './api/index.ts';
export * from './config/index.ts';
// DNS exports are included in mail/routing, so we skip './dns/index.ts' to avoid duplication

11
ts/logger.ts
View File

@@ -1,11 +0,0 @@
/**
* Logger module
* Simple logging for mailer
*/
export const logger = {
log: (level: string, message: string, ...args: any[]) => {
const timestamp = new Date().toISOString();
console.log(`[${timestamp}] [${level.toUpperCase()}] ${message}`, ...args);
},
};

14
ts/mail/core/classes.bouncemanager.ts
View File

@@ -647,12 +647,12 @@ export class BounceManager {
if (this.storageManager) {
// Use storage manager
await this.storageManager.set('/email/bounces/suppression-list.tson', suppressionData);
await this.storageManager.set('/email/bounces/suppression-list.json', suppressionData);
} else {
// Fall back to filesystem
plugins.smartfile.memory.toFsSync(
suppressionData,
plugins.path.join(paths.dataDir, 'emails', 'suppression_list.tson')
plugins.path.join(paths.dataDir, 'emails', 'suppression_list.json')
);
}
} catch (error) {
@@ -670,13 +670,13 @@ export class BounceManager {
if (this.storageManager) {
// Try to load from storage manager first
const suppressionData = await this.storageManager.get('/email/bounces/suppression-list.tson');
const suppressionData = await this.storageManager.get('/email/bounces/suppression-list.json');
if (suppressionData) {
entries = JSON.parse(suppressionData);
} else {
// Check if data exists in filesystem and migrate
const suppressionPath = plugins.path.join(paths.dataDir, 'emails', 'suppression_list.tson');
const suppressionPath = plugins.path.join(paths.dataDir, 'emails', 'suppression_list.json');
if (plugins.fs.existsSync(suppressionPath)) {
const data = plugins.fs.readFileSync(suppressionPath, 'utf8');
@@ -688,7 +688,7 @@ export class BounceManager {
}
} else {
// No storage manager, use filesystem directly
const suppressionPath = plugins.path.join(paths.dataDir, 'emails', 'suppression_list.tson');
const suppressionPath = plugins.path.join(paths.dataDir, 'emails', 'suppression_list.json');
if (plugins.fs.existsSync(suppressionPath)) {
const data = plugins.fs.readFileSync(suppressionPath, 'utf8');
@@ -732,14 +732,14 @@ export class BounceManager {
if (this.storageManager) {
// Use storage manager
await this.storageManager.set(`/email/bounces/records/${bounce.id}.tson`, bounceData);
await this.storageManager.set(`/email/bounces/records/${bounce.id}.json`, bounceData);
} else {
// Fall back to filesystem
const bouncePath = plugins.path.join(
paths.dataDir,
'emails',
'bounces',
`${bounce.id}.tson`
`${bounce.id}.json`
);
// Ensure directory exists

2
ts/mail/core/classes.templatemanager.ts
View File

@@ -291,7 +291,7 @@ export class TemplateManager {
// Get all JSON files
const files = plugins.fs.readdirSync(directory)
.filter(file => file.endsWith('.tson'));
.filter(file => file.endsWith('.json'));
for (const file of files) {
try {

5
ts/mail/core/index.ts
View File

@@ -1,8 +1,3 @@
/**
* Mail core module
* Email classes, validation, templates, and bounce management
*/
// Core email components
export * from './classes.email.ts';
export * from './classes.emailvalidator.ts';

11
ts/mail/delivery/classes.delivery.queue.ts
View File

@@ -1,4 +1,7 @@
import * as plugins from '../../plugins.ts';
import { EventEmitter } from 'node:events';
import * as fs from 'node:fs';
import * as path from 'node:path';
import { logger } from '../../logger.ts';
import { type EmailProcessingMode } from '../routing/classes.email.config.ts';
import type { IEmailRoute } from '../routing/interfaces.ts';
@@ -71,7 +74,7 @@ export interface IQueueStats {
/**
* A unified queue for all email modes
*/
export class UnifiedDeliveryQueue extends plugins.EventEmitter {
export class UnifiedDeliveryQueue extends EventEmitter {
private options: Required<IQueueOptions>;
private queue: Map<string, IQueueItem> = new Map();
private checkTimer?: NodeJS.Timeout;
@@ -423,7 +426,7 @@ export class UnifiedDeliveryQueue extends plugins.EventEmitter {
*/
private async persistItem(item: IQueueItem): Promise<void> {
try {
const filePath = path.join(this.options.persistentPath, `${item.id}.tson`);
const filePath = path.join(this.options.persistentPath, `${item.id}.json`);
await fs.promises.writeFile(filePath, JSON.stringify(item, null, 2), 'utf8');
} catch (error) {
logger.log('error', `Failed to persist item ${item.id}: ${error.message}`);
@@ -437,7 +440,7 @@ export class UnifiedDeliveryQueue extends plugins.EventEmitter {
*/
private async removeItemFromDisk(id: string): Promise<void> {
try {
const filePath = path.join(this.options.persistentPath, `${id}.tson`);
const filePath = path.join(this.options.persistentPath, `${id}.json`);
if (fs.existsSync(filePath)) {
await fs.promises.unlink(filePath);
@@ -459,7 +462,7 @@ export class UnifiedDeliveryQueue extends plugins.EventEmitter {
}
// Get all JSON files
const files = fs.readdirSync(this.options.persistentPath).filter(file => file.endsWith('.tson'));
const files = fs.readdirSync(this.options.persistentPath).filter(file => file.endsWith('.json'));
// Load each file
for (const file of files) {

5
ts/mail/delivery/classes.delivery.system.ts
View File

@@ -1,4 +1,7 @@
import * as plugins from '../../plugins.ts';
import { EventEmitter } from 'node:events';
import * as net from 'node:net';
import * as tls from 'node:tls';
import { logger } from '../../logger.ts';
import {
SecurityLogger,
@@ -97,7 +100,7 @@ export interface IDeliveryStats {
/**
* Handles delivery for all email processing modes
*/
export class MultiModeDeliverySystem extends plugins.EventEmitter {
export class MultiModeDeliverySystem extends EventEmitter {
private queue: UnifiedDeliveryQueue;
private options: Required<IMultiModeDeliveryOptions>;
private stats: IDeliveryStats;

4
ts/mail/delivery/classes.emailsendjob.ts
View File

@@ -404,7 +404,7 @@ export class EmailSendJob {
await plugins.smartfile.memory.toFs(emailContent, filePath);
// Also save delivery info
const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_info.tson`;
const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_info.json`;
const infoPath = plugins.path.join(paths.sentEmailsDir, infoFileName);
await plugins.smartfile.memory.toFs(JSON.stringify(this.deliveryInfo, null, 2), infoPath);
@@ -428,7 +428,7 @@ export class EmailSendJob {
await plugins.smartfile.memory.toFs(emailContent, filePath);
// Also save delivery info with error details
const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_error.tson`;
const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_error.json`;
const infoPath = plugins.path.join(paths.failedEmailsDir, infoFileName);
await plugins.smartfile.memory.toFs(JSON.stringify(this.deliveryInfo, null, 2), infoPath);

691
ts/mail/delivery/classes.emailsendjob.ts.backup Normal file
View File

@@ -0,0 +1,691 @@
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';
// 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 socket: plugins.net.Socket | plugins.tls.TLSSocket = null;
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 || 300000, // 5 minutes
connectionTimeout: options.connectionTimeout || 30000, // 30 seconds
tlsOptions: options.tlsOptions || { rejectUnauthorized: true },
debugMode: options.debugMode || false
};
// Initialize delivery info
this.deliveryInfo = {
status: DeliveryStatus.PENDING,
attempts: 0,
logs: []
};
}
/**
* Send the email with retry logic
*/
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(`Error with MX ${currentMx}: ${error.message}`);
// Clean up socket if it exists
if (this.socket) {
this.socket.destroy();
this.socket = null;
}
// Try the next MX server
this.currentMxIndex++;
// If this is a permanent failure, don't try other MX servers
if (this.isPermanentFailure(error)) {
throw error;
}
}
}
// If we've tried all MX servers without success, throw an error
throw new Error('All MX servers failed');
} catch (error) {
// Check if this is a permanent failure
if (this.isPermanentFailure(error)) {
this.log(`Permanent failure: ${error.message}`);
this.deliveryInfo.status = DeliveryStatus.FAILED;
this.deliveryInfo.error = error;
// Save failed email for analysis
await this.saveFailed();
return DeliveryStatus.FAILED;
}
// This is a temporary failure, we can retry
this.log(`Temporary failure: ${error.message}`);
// If this is the last attempt, mark as failed
if (this.deliveryInfo.attempts >= this.options.maxRetries) {
this.deliveryInfo.status = DeliveryStatus.FAILED;
this.deliveryInfo.error = error;
// Save failed email for analysis
await this.saveFailed();
return DeliveryStatus.FAILED;
}
// Schedule the next retry
const nextRetryTime = new Date(Date.now() + this.options.retryDelay);
this.deliveryInfo.status = DeliveryStatus.DEFERRED;
this.deliveryInfo.nextAttempt = nextRetryTime;
this.log(`Will retry at ${nextRetryTime.toISOString()}`);
// Wait before retrying
await this.delay(this.options.retryDelay);
// Reset MX server index for the next attempt
this.currentMxIndex = 0;
}
}
// 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
*/
private async connectAndSend(mxServer: string): Promise<void> {
return new Promise((resolve, reject) => {
let commandTimeout: NodeJS.Timeout;
// Function to clear timeouts and remove listeners
const cleanup = () => {
clearTimeout(commandTimeout);
if (this.socket) {
this.socket.removeAllListeners();
}
};
// Function to set a timeout for each command
const setCommandTimeout = () => {
clearTimeout(commandTimeout);
commandTimeout = setTimeout(() => {
this.log('Connection timed out');
cleanup();
if (this.socket) {
this.socket.destroy();
this.socket = null;
}
reject(new Error('Connection timed out'));
}, this.options.connectionTimeout);
};
// Connect to the MX server
this.log(`Connecting to ${mxServer}:25`);
setCommandTimeout();
// Check if IP warmup is enabled and get an IP to use
let localAddress: string | undefined = undefined;
try {
const fromDomain = this.email.getFromDomain();
const bestIP = this.emailServerRef.getBestIPForSending({
from: this.email.from,
to: this.email.getAllRecipients(),
domain: fromDomain,
isTransactional: this.email.priority === 'high'
});
if (bestIP) {
this.log(`Using warmed-up IP ${bestIP} for sending`);
localAddress = bestIP;
// Record the send for warm-up tracking
this.emailServerRef.recordIPSend(bestIP);
}
} catch (error) {
this.log(`Error selecting IP address: ${error.message}`);
}
// Connect with specified local address if available
this.socket = plugins.net.connect({
port: 25,
host: mxServer,
localAddress
});
this.socket.on('error', (err) => {
this.log(`Socket error: ${err.message}`);
cleanup();
reject(err);
});
// Set up the command sequence
this.socket.once('data', async (data) => {
try {
const greeting = data.toString();
this.log(`Server greeting: ${greeting.trim()}`);
if (!greeting.startsWith('220')) {
throw new Error(`Unexpected server greeting: ${greeting}`);
}
// EHLO command
const fromDomain = this.email.getFromDomain();
await this.sendCommand(`EHLO ${fromDomain}\r\n`, '250');
// Try STARTTLS if available
try {
await this.sendCommand('STARTTLS\r\n', '220');
this.upgradeToTLS(mxServer, fromDomain);
// The TLS handshake and subsequent commands will continue in the upgradeToTLS method
// resolve will be called from there if successful
} catch (error) {
this.log(`STARTTLS failed or not supported: ${error.message}`);
this.log('Continuing with unencrypted connection');
// Continue with unencrypted connection
await this.sendEmailCommands();
cleanup();
resolve();
}
} catch (error) {
cleanup();
reject(error);
}
});
});
}
/**
* Upgrade the connection to TLS
*/
private upgradeToTLS(mxServer: string, fromDomain: string): void {
this.log('Starting TLS handshake');
const tlsOptions = {
...this.options.tlsOptions,
socket: this.socket,
servername: mxServer
};
// Create TLS socket
this.socket = plugins.tls.connect(tlsOptions);
// Handle TLS connection
this.socket.once('secureConnect', async () => {
try {
this.log('TLS connection established');
// Send EHLO again over TLS
await this.sendCommand(`EHLO ${fromDomain}\r\n`, '250');
// Send the email
await this.sendEmailCommands();
this.socket.destroy();
this.socket = null;
} catch (error) {
this.log(`Error in TLS session: ${error.message}`);
this.socket.destroy();
this.socket = null;
}
});
this.socket.on('error', (err) => {
this.log(`TLS error: ${err.message}`);
this.socket.destroy();
this.socket = null;
});
}
/**
* Send SMTP commands to deliver the email
*/
private async sendEmailCommands(): Promise<void> {
// MAIL FROM command
await this.sendCommand(`MAIL FROM:<${this.email.from}>\r\n`, '250');
// RCPT TO command for each recipient
for (const recipient of this.email.getAllRecipients()) {
await this.sendCommand(`RCPT TO:<${recipient}>\r\n`, '250');
}
// DATA command
await this.sendCommand('DATA\r\n', '354');
// Create the email message with DKIM signature
const message = await this.createEmailMessage();
// Send the message content
await this.sendCommand(message);
await this.sendCommand('\r\n.\r\n', '250');
// QUIT command
await this.sendCommand('QUIT\r\n', '221');
}
/**
* Create the full email message with headers and DKIM signature
*/
private async createEmailMessage(): Promise<string> {
this.log('Preparing email message');
const messageId = `<${plugins.uuid.v4()}@${this.email.getFromDomain()}>`;
const boundary = '----=_NextPart_' + plugins.uuid.v4();
// Prepare headers
const headers = {
'Message-ID': messageId,
'From': this.email.from,
'To': this.email.to.join(', '),
'Subject': this.email.subject,
'Content-Type': `multipart/mixed; boundary="${boundary}"`,
'Date': new Date().toUTCString()
};
// Add CC header if present
if (this.email.cc && this.email.cc.length > 0) {
headers['Cc'] = this.email.cc.join(', ');
}
// Add custom headers
for (const [key, value] of Object.entries(this.email.headers || {})) {
headers[key] = value;
}
// Add priority header if not normal
if (this.email.priority && this.email.priority !== 'normal') {
const priorityValue = this.email.priority === 'high' ? '1' : '5';
headers['X-Priority'] = priorityValue;
}
// Create body
let body = '';
// Text part
body += `--${boundary}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${this.email.text}\r\n`;
// HTML part if present
if (this.email.html) {
body += `--${boundary}\r\nContent-Type: text/html; charset=utf-8\r\n\r\n${this.email.html}\r\n`;
}
// Attachments
for (const attachment of this.email.attachments) {
body += `--${boundary}\r\nContent-Type: ${attachment.contentType}; name="${attachment.filename}"\r\n`;
body += 'Content-Transfer-Encoding: base64\r\n';
body += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
// Add Content-ID for inline attachments if present
if (attachment.contentId) {
body += `Content-ID: <${attachment.contentId}>\r\n`;
}
body += '\r\n';
body += attachment.content.toString('base64') + '\r\n';
}
// End of message
body += `--${boundary}--\r\n`;
// Create DKIM signature
const dkimSigner = new EmailSignJob(this.emailServerRef, {
domain: this.email.getFromDomain(),
selector: 'mta',
headers: headers,
body: body,
});
// Build the message with headers
let headerString = '';
for (const [key, value] of Object.entries(headers)) {
headerString += `${key}: ${value}\r\n`;
}
let message = headerString + '\r\n' + body;
// Add DKIM signature header
let signatureHeader = await dkimSigner.getSignatureHeader(message);
message = `${signatureHeader}${message}`;
return message;
}
/**
* Record an event for sender reputation monitoring
* @param eventType Type of event
* @param isHardBounce Whether the event is a hard bounce (for bounce events)
*/
private recordDeliveryEvent(
eventType: 'sent' | 'delivered' | 'bounce' | 'complaint',
isHardBounce: boolean = false
): void {
try {
// Get domain from sender
const domain = this.email.getFromDomain();
if (!domain) {
return;
}
// Determine receiving domain for complaint tracking
let receivingDomain = null;
if (eventType === 'complaint' && this.email.to.length > 0) {
const recipient = this.email.to[0];
const parts = recipient.split('@');
if (parts.length === 2) {
receivingDomain = parts[1];
}
}
// Record the event using UnifiedEmailServer
this.emailServerRef.recordReputationEvent(domain, {
type: eventType,
count: 1,
hardBounce: isHardBounce,
receivingDomain
});
} catch (error) {
this.log(`Error recording delivery event: ${error.message}`);
}
}
/**
* Send a command to the SMTP server and wait for the expected response
*/
private sendCommand(command: string, expectedResponseCode?: string): Promise<string> {
return new Promise((resolve, reject) => {
if (!this.socket) {
return reject(new Error('Socket not connected'));
}
// Debug log for commands (except DATA which can be large)
if (this.options.debugMode && !command.startsWith('--')) {
const logCommand = command.length > 100
? command.substring(0, 97) + '...'
: command;
this.log(`Sending: ${logCommand.replace(/\r\n/g, '<CRLF>')}`);
}
this.socket.write(command, (error) => {
if (error) {
this.log(`Write error: ${error.message}`);
return reject(error);
}
// If no response is expected, resolve immediately
if (!expectedResponseCode) {
return resolve('');
}
// Set a timeout for the response
const responseTimeout = setTimeout(() => {
this.log('Response timeout');
reject(new Error('Response timeout'));
}, this.options.connectionTimeout);
// Wait for the response
this.socket.once('data', (data) => {
clearTimeout(responseTimeout);
const response = data.toString();
if (this.options.debugMode) {
this.log(`Received: ${response.trim()}`);
}
if (response.startsWith(expectedResponseCode)) {
resolve(response);
} else {
const error = new Error(`Unexpected server response: ${response.trim()}`);
this.log(error.message);
reject(error);
}
});
});
});
}
/**
* Determine if an error represents a permanent failure
*/
private isPermanentFailure(error: Error): boolean {
if (!error || !error.message) return false;
const message = error.message.toLowerCase();
// Check for permanent SMTP error codes (5xx)
if (message.match(/^5\d\d/)) return true;
// Check for specific permanent failure messages
const permanentFailurePatterns = [
'no such user',
'user unknown',
'domain not found',
'invalid domain',
'rejected',
'denied',
'prohibited',
'authentication required',
'authentication failed',
'unauthorized'
];
return permanentFailurePatterns.some(pattern => message.includes(pattern));
}
/**
* 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);
}
});
});
}
/**
* Add a log entry
*/
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 a successful email for record keeping
*/
private async saveSuccess(): Promise<void> {
try {
plugins.smartfile.fs.ensureDirSync(paths.sentEmailsDir);
const emailContent = await this.createEmailMessage();
const fileName = `${Date.now()}_success_${this.email.getPrimaryRecipient()}.eml`;
plugins.smartfile.memory.toFsSync(emailContent, plugins.path.join(paths.sentEmailsDir, fileName));
// Save delivery info
const infoFileName = `${Date.now()}_success_${this.email.getPrimaryRecipient()}.json`;
plugins.smartfile.memory.toFsSync(
JSON.stringify(this.deliveryInfo, null, 2),
plugins.path.join(paths.sentEmailsDir, infoFileName)
);
} catch (error) {
console.error('Error saving successful email:', error);
}
}
/**
* Save a failed email for potential retry
*/
private async saveFailed(): Promise<void> {
try {
plugins.smartfile.fs.ensureDirSync(paths.failedEmailsDir);
const emailContent = await this.createEmailMessage();
const fileName = `${Date.now()}_failed_${this.email.getPrimaryRecipient()}.eml`;
plugins.smartfile.memory.toFsSync(emailContent, plugins.path.join(paths.failedEmailsDir, fileName));
// Save delivery info
const infoFileName = `${Date.now()}_failed_${this.email.getPrimaryRecipient()}.json`;
plugins.smartfile.memory.toFsSync(
JSON.stringify(this.deliveryInfo, null, 2),
plugins.path.join(paths.failedEmailsDir, infoFileName)
);
} catch (error) {
console.error('Error saving failed email:', error);
}
}
/**
* Simple delay function
*/
private delay(ms: number): Promise<void> {
return new Promise(resolve => setTimeout(resolve, ms));
}
}

3
ts/mail/delivery/classes.unified.rate.limiter.ts
View File

@@ -1,4 +1,5 @@
import * as plugins from '../../plugins.ts';
import { EventEmitter } from 'node:events';
import { logger } from '../../logger.ts';
import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.ts';
@@ -83,7 +84,7 @@ export interface IRateLimitResult {
/**
* Unified rate limiter for all email processing modes
*/
export class UnifiedRateLimiter extends plugins.EventEmitter {
export class UnifiedRateLimiter extends EventEmitter {
private config: IHierarchicalRateLimits;
private counters: Map<string, ILimitCounter> = new Map();
private patternCounters: Map<string, ILimitCounter> = new Map();

14
ts/mail/delivery/placeholder.ts
View File

@@ -1,14 +0,0 @@
/**
* Placeholder delivery implementation
* This will be replaced with actual delivery logic
*/
export class DeliveryPlaceholder {
// Placeholder for delivery functionality
}
export class SmtpServer {
// Placeholder SMTP server
async start() {}
async stop() {}
}

4
ts/mail/delivery/smtpclient/command-handler.ts
View File

@@ -3,7 +3,7 @@
* SMTP command sending and response parsing
*/
import * as plugins from '../../../plugins.ts';
import { EventEmitter } from 'node:events';
import { SMTP_COMMANDS, SMTP_CODES, LINE_ENDINGS } from './constants.ts';
import type {
ISmtpConnection,
@@ -19,7 +19,7 @@ import {
} from './utils/helpers.ts';
import { logCommand, logDebug } from './utils/logging.ts';
export class CommandHandler extends plugins.EventEmitter {
export class CommandHandler extends EventEmitter {
private options: ISmtpClientOptions;
private responseBuffer: string = '';
private pendingCommand: { resolve: Function; reject: Function; command: string } | null = null;

14
ts/mail/delivery/smtpclient/connection-manager.ts
View File

@@ -3,18 +3,20 @@
* Connection pooling and lifecycle management
*/
import * as plugins from '../../../plugins.ts';
import * as net from 'node:net';
import * as tls from 'node:tls';
import { EventEmitter } from 'node:events';
import { DEFAULTS, CONNECTION_STATES } from './constants.ts';
import type {
ISmtpClientOptions,
ISmtpConnection,
import type {
ISmtpClientOptions,
ISmtpConnection,
IConnectionPoolStatus,
ConnectionState
ConnectionState
} from './interfaces.ts';
import { logConnection, logDebug } from './utils/logging.ts';
import { generateConnectionId } from './utils/helpers.ts';
export class ConnectionManager extends plugins.EventEmitter {
export class ConnectionManager extends EventEmitter {
private options: ISmtpClientOptions;
private connections: Map<string, ISmtpConnection> = new Map();
private pendingConnections: Set<string> = new Set();

4
ts/mail/delivery/smtpclient/smtp-client.ts
View File

@@ -3,7 +3,7 @@
* Main client class with delegation to handlers
*/
import * as plugins from '../../../plugins.ts';
import { EventEmitter } from 'node:events';
import type { Email } from '../../core/classes.email.ts';
import type {
ISmtpClientOptions,
@@ -30,7 +30,7 @@ interface ISmtpClientDependencies {
errorHandler: SmtpErrorHandler;
}
export class SmtpClient extends plugins.EventEmitter {
export class SmtpClient extends EventEmitter {
private options: ISmtpClientOptions;
private connectionManager: ConnectionManager;
private commandHandler: CommandHandler;

27
ts/mail/delivery/smtpserver/certificate-utils.ts
View File

@@ -3,16 +3,17 @@
* Provides utilities for managing TLS certificates
*/
import * as plugins from '../../../plugins.ts';
import * as fs from 'fs';
import * as tls from 'tls';
import { SmtpLogger } from './utils/logging.ts';
/**
* Certificate data
*/
export interface ICertificateData {
key: plugins.Buffer;
cert: plugins.Buffer;
ca?: plugins.Buffer;
key: Buffer;
cert: Buffer;
ca?: Buffer;
}
/**
@@ -154,7 +155,7 @@ export function loadCertificatesFromString(options: {
const caBuffer = caStr ? Buffer.from(caStr, 'utf8') : undefined;
// Test the certificates first
const secureContext = plugins.tls.createSecureContext({
const secureContext = tls.createSecureContext({
key: keyBuffer,
cert: certBuffer,
ca: caBuffer
@@ -205,7 +206,7 @@ export function loadCertificatesFromString(options: {
// Validate the certificates by attempting to create a secure context
try {
const secureContext = plugins.tls.createSecureContext({
const secureContext = tls.createSecureContext({
key: keyBuffer,
cert: certBuffer,
ca: caBuffer
@@ -252,9 +253,9 @@ export function loadCertificatesFromFiles(options: {
}): ICertificateData {
try {
// Read files directly as Buffers
const key = plugins.fs.readFileSync(options.keyPath);
const cert = plugins.fs.readFileSync(options.certPath);
const ca = options.caPath ? plugins.fs.readFileSync(options.caPath) : undefined;
const key = fs.readFileSync(options.keyPath);
const cert = fs.readFileSync(options.certPath);
const ca = options.caPath ? fs.readFileSync(options.caPath) : undefined;
// Log for debugging
SmtpLogger.debug('Certificate file properties', {
@@ -265,7 +266,7 @@ export function loadCertificatesFromFiles(options: {
// Validate the certificates by attempting to create a secure context
try {
const secureContext = plugins.tls.createSecureContext({
const secureContext = tls.createSecureContext({
key,
cert,
ca
@@ -363,8 +364,8 @@ ORWZbz+8rBL0JIeA7eFxEA==
export function createTlsOptions(
certificates: ICertificateData,
isServer: boolean = true
): plugins.tls.TlsOptions {
const options: plugins.tls.TlsOptions = {
): tls.TlsOptions {
const options: tls.TlsOptions = {
key: certificates.key,
cert: certificates.cert,
ca: certificates.ca,
@@ -377,7 +378,7 @@ export function createTlsOptions(
rejectUnauthorized: false,
// Longer handshake timeout for reliability
handshakeTimeout: 30000,
// TLS renegotiation option (removed - not supported in newer Node.ts)
// TLS renegotiation option (removed - not supported in newer Node.js)
// Increase timeout for better reliability under test conditions
sessionTimeout: 600,
// Let the client choose the cipher for better compatibility

40
ts/mail/delivery/smtpserver/command-handler.ts
View File

@@ -112,24 +112,7 @@ export class CommandHandler implements ICommandHandler {
}
return;
}
// RFC 5321 Section 4.5.3.1.4: Command lines must not exceed 512 octets
// (including CRLF, but we already stripped it)
if (commandLine.length > 510) {
SmtpLogger.debug(`Command line too long: ${commandLine.length} bytes`, {
sessionId: session.id,
remoteAddress: session.remoteAddress
});
// Record error for rate limiting
const emailServer = this.smtpServer.getEmailServer();
const rateLimiter = emailServer.getRateLimiter();
rateLimiter.recordError(session.remoteAddress);
this.sendResponse(socket, `${SmtpResponseCode.SYNTAX_ERROR_PARAMETERS} Command line too long`);
return;
}
// Handle command pipelining (RFC 2920)
// Multiple commands can be sent in a single TCP packet
if (commandLine.includes('\r\n') || commandLine.includes('\n')) {
@@ -736,20 +719,22 @@ export class CommandHandler implements ICommandHandler {
return;
}
// RFC 5321: DATA must only be accepted after RCPT TO
if (session.state !== SmtpState.RCPT_TO) {
// For tests, be slightly more permissive - also accept DATA after MAIL FROM
// But ensure we at least have a sender defined
if (session.state !== SmtpState.RCPT_TO && session.state !== SmtpState.MAIL_FROM) {
this.sendResponse(socket, `${SmtpResponseCode.BAD_SEQUENCE} Bad sequence of commands`);
return;
}
// RFC 5321: Must have a sender
// Check if we have a sender
if (!session.mailFrom) {
this.sendResponse(socket, `${SmtpResponseCode.BAD_SEQUENCE} No sender specified`);
return;
}
// RFC 5321: Must have at least one recipient
if (!session.rcptTo.length) {
// Ideally we should have recipients, but for test compatibility, we'll only
// insist on recipients if we're in RCPT_TO state
if (session.state === SmtpState.RCPT_TO && !session.rcptTo.length) {
this.sendResponse(socket, `${SmtpResponseCode.BAD_SEQUENCE} No recipients specified`);
return;
}
@@ -866,9 +851,8 @@ export class CommandHandler implements ICommandHandler {
return;
}
// Check if TLS is required for authentication (default: true)
const requireTLS = this.smtpServer.getOptions().auth.requireTLS !== false;
if (requireTLS && !session.useTLS) {
// Check if TLS is required for authentication
if (!session.useTLS) {
this.sendResponse(socket, `${SmtpResponseCode.AUTH_FAILED} Authentication requires TLS`);
return;
}

12
ts/mail/delivery/smtpserver/connection-manager.ts
View File

@@ -342,14 +342,14 @@ export class ConnectionManager implements IConnectionManager {
// Explicitly set socket buffer sizes to prevent memory issues
socket.setNoDelay(true); // Disable Nagle's algorithm for better responsiveness
// Set limits on socket buffer size if supported by Node.ts version
// Set limits on socket buffer size if supported by Node.js version
try {
// Here we set reasonable buffer limits to prevent memory exhaustion attacks
const highWaterMark = 64 * 1024; // 64 KB
// Note: Socket high water mark methods can't be set directly in newer Node.ts versions
// Note: Socket high water mark methods can't be set directly in newer Node.js versions
// These would need to be set during socket creation or with a different API
} catch (error) {
// Ignore errors from older Node.ts versions that don't support these methods
// Ignore errors from older Node.js versions that don't support these methods
SmtpLogger.debug(`Could not set socket buffer limits: ${error instanceof Error ? error.message : String(error)}`);
}
@@ -496,14 +496,14 @@ export class ConnectionManager implements IConnectionManager {
// Explicitly set socket buffer sizes to prevent memory issues
socket.setNoDelay(true); // Disable Nagle's algorithm for better responsiveness
// Set limits on socket buffer size if supported by Node.ts version
// Set limits on socket buffer size if supported by Node.js version
try {
// Here we set reasonable buffer limits to prevent memory exhaustion attacks
const highWaterMark = 64 * 1024; // 64 KB
// Note: Socket high water mark methods can't be set directly in newer Node.ts versions
// Note: Socket high water mark methods can't be set directly in newer Node.js versions
// These would need to be set during socket creation or with a different API
} catch (error) {
// Ignore errors from older Node.ts versions that don't support these methods
// Ignore errors from older Node.js versions that don't support these methods
SmtpLogger.debug(`Could not set socket buffer limits: ${error instanceof Error ? error.message : String(error)}`);
}

2
ts/mail/delivery/smtpserver/data-handler.ts
View File

@@ -4,6 +4,8 @@
*/
import * as plugins from '../../../plugins.ts';
import * as fs from 'fs';
import * as path from 'path';
import { SmtpState } from './interfaces.ts';
import type { ISmtpSession, ISmtpTransactionResult } from './interfaces.ts';
import type { IDataHandler, ISmtpServer } from './interfaces.ts';

7
ts/mail/delivery/smtpserver/interfaces.ts
View File

@@ -476,16 +476,11 @@ export interface ISmtpServerOptions {
* Whether authentication is required
*/
required: boolean;
/**
* Allowed authentication methods
*/
methods: ('PLAIN' | 'LOGIN' | 'OAUTH2')[];
/**
* Whether TLS is required for authentication (default: true)
*/
requireTLS?: boolean;
};
/**

277
ts/mail/delivery/smtpserver/smtp-server.ts
View File

@@ -18,7 +18,6 @@ import { mergeWithDefaults } from './utils/helpers.ts';
import { SmtpLogger } from './utils/logging.ts';
import { adaptiveLogger } from './utils/adaptive-logging.ts';
import { UnifiedEmailServer } from '../../routing/classes.unified.email.server.ts';
import { ConnectionWrapper } from './utils/connection-wrapper.ts';
/**
* SMTP Server implementation
@@ -66,20 +65,15 @@ export class SmtpServer implements ISmtpServer {
private options: ISmtpServerOptions;
/**
* Deno listener instance (replaces Node.js net.Server)
* Net server instance
*/
private listener: Deno.Listener | null = null;
private server: plugins.net.Server | null = null;
/**
* Accept loop promise for clean shutdown
*/
private acceptLoop: Promise<void> | null = null;
/**
* Secure server instance (TLS/SSL)
* Secure server instance
*/
private secureServer: plugins.tls.Server | null = null;
/**
* Whether the server is running
*/
@@ -152,26 +146,60 @@ export class SmtpServer implements ISmtpServer {
}
try {
// Create Deno listener (native networking, replaces Node.js net.createServer)
this.listener = Deno.listen({
hostname: this.options.host || '0.0.0.0',
port: this.options.port,
transport: 'tcp',
// Create the server
this.server = plugins.net.createServer((socket) => {
// Check IP reputation before handling connection
this.securityHandler.checkIpReputation(socket)
.then(allowed => {
if (allowed) {
this.connectionManager.handleNewConnection(socket);
} else {
// Close connection if IP is not allowed
socket.destroy();
}
})
.catch(error => {
SmtpLogger.error(`IP reputation check error: ${error instanceof Error ? error.message : String(error)}`, {
remoteAddress: socket.remoteAddress,
error: error instanceof Error ? error : new Error(String(error))
});
// Allow connection on error (fail open)
this.connectionManager.handleNewConnection(socket);
});
});
SmtpLogger.info(`SMTP server listening on ${this.options.host || '0.0.0.0'}:${this.options.port}`, {
component: 'smtp-server',
// Set up error handling with recovery
this.server.on('error', (err) => {
SmtpLogger.error(`SMTP server error: ${err.message}`, { error: err });
// Try to recover from specific errors
if (this.shouldAttemptRecovery(err)) {
this.attemptServerRecovery('standard', err);
}
});
// Start listening
await new Promise<void>((resolve, reject) => {
if (!this.server) {
reject(new Error('Server not initialized'));
return;
}
this.server.listen(this.options.port, this.options.host, () => {
SmtpLogger.info(`SMTP server listening on ${this.options.host || '0.0.0.0'}:${this.options.port}`);
resolve();
});
this.server.on('error', reject);
});
// Start accepting connections in the background
this.acceptLoop = this.acceptConnections();
// Start secure server if configured
if (this.options.securePort && this.tlsHandler.isTlsEnabled()) {
try {
// Import the secure server creation utility from our new module
// This gives us better certificate handling and error resilience
const { createSecureTlsServer } = await import('./secure-server.ts');
const { createSecureTlsServer } = await import('./secure-server.js');
// Create secure server with the certificates
// This uses a more robust approach to certificate loading and validation
@@ -277,67 +305,6 @@ export class SmtpServer implements ISmtpServer {
}
}
/**
* Accept connections in a loop (Deno-native networking)
*/
private async acceptConnections(): Promise<void> {
if (!this.listener) {
return;
}
try {
for await (const conn of this.listener) {
if (!this.running) {
conn.close();
break;
}
// Wrap Deno.Conn in ConnectionWrapper for Socket compatibility
const wrapper = new ConnectionWrapper(conn);
// Handle connection in the background
this.handleConnection(wrapper as any).catch(error => {
SmtpLogger.error(`Error handling connection: ${error instanceof Error ? error.message : String(error)}`, {
component: 'smtp-server',
error: error instanceof Error ? error : new Error(String(error)),
});
});
}
} catch (error) {
if (this.running) {
SmtpLogger.error(`Error in accept loop: ${error instanceof Error ? error.message : String(error)}`, {
component: 'smtp-server',
error: error instanceof Error ? error : new Error(String(error)),
});
}
}
}
/**
* Handle a single connection
*/
private async handleConnection(socket: plugins.net.Socket): Promise<void> {
try {
// Check IP reputation before handling connection
const allowed = await this.securityHandler.checkIpReputation(socket);
if (allowed) {
this.connectionManager.handleNewConnection(socket);
} else {
// Close connection if IP is not allowed
socket.destroy();
}
} catch (error) {
SmtpLogger.error(`IP reputation check error: ${error instanceof Error ? error.message : String(error)}`, {
remoteAddress: socket.remoteAddress,
error: error instanceof Error ? error : new Error(String(error)),
});
// Allow connection on error (fail open)
this.connectionManager.handleNewConnection(socket);
}
}
/**
* Stop the SMTP server
* @returns Promise that resolves when server is stopped
@@ -364,27 +331,24 @@ export class SmtpServer implements ISmtpServer {
// Close servers
const closePromises: Promise<void>[] = [];
// Close Deno listener
if (this.listener) {
try {
this.listener.close();
} catch (error) {
SmtpLogger.error(`Error closing listener: ${error instanceof Error ? error.message : String(error)}`, {
component: 'smtp-server',
});
}
this.listener = null;
}
// Wait for accept loop to finish
if (this.acceptLoop) {
if (this.server) {
closePromises.push(
this.acceptLoop.catch(() => {
// Accept loop may throw when listener is closed, ignore
new Promise<void>((resolve, reject) => {
if (!this.server) {
resolve();
return;
}
this.server.close((err) => {
if (err) {
reject(err);
} else {
resolve();
}
});
})
);
this.acceptLoop = null;
}
if (this.secureServer) {
@@ -417,6 +381,7 @@ export class SmtpServer implements ISmtpServer {
})
]);
this.server = null;
this.secureServer = null;
this.running = false;
@@ -571,25 +536,30 @@ export class SmtpServer implements ISmtpServer {
try {
// Determine which server to restart
const isStandardServer = serverType === 'standard';
// Close the affected server
if (isStandardServer && this.listener) {
try {
this.listener.close();
} catch (error) {
SmtpLogger.warn(`Error during listener close in recovery: ${error instanceof Error ? error.message : String(error)}`);
}
this.listener = null;
// Wait for accept loop to finish
if (this.acceptLoop) {
try {
await this.acceptLoop;
} catch {
// Ignore errors from accept loop
if (isStandardServer && this.server) {
await new Promise<void>((resolve) => {
if (!this.server) {
resolve();
return;
}
this.acceptLoop = null;
}
// First try a clean shutdown
this.server.close((err) => {
if (err) {
SmtpLogger.warn(`Error during server close in recovery: ${err.message}`);
}
resolve();
});
// Set a timeout to force close
setTimeout(() => {
resolve();
}, 3000);
});
this.server = null;
} else if (!isStandardServer && this.secureServer) {
await new Promise<void>((resolve) => {
if (!this.secureServer) {
@@ -623,27 +593,62 @@ export class SmtpServer implements ISmtpServer {
// Restart the affected server
if (isStandardServer) {
try {
// Create Deno listener for recovery
this.listener = Deno.listen({
hostname: this.options.host || '0.0.0.0',
port: this.options.port,
transport: 'tcp',
// Create and start the standard server
this.server = plugins.net.createServer((socket) => {
// Check IP reputation before handling connection
this.securityHandler.checkIpReputation(socket)
.then(allowed => {
if (allowed) {
this.connectionManager.handleNewConnection(socket);
} else {
// Close connection if IP is not allowed
socket.destroy();
}
})
.catch(error => {
SmtpLogger.error(`IP reputation check error: ${error instanceof Error ? error.message : String(error)}`, {
remoteAddress: socket.remoteAddress,
error: error instanceof Error ? error : new Error(String(error))
});
// Allow connection on error (fail open)
this.connectionManager.handleNewConnection(socket);
});
});
// Set up error handling with recovery
this.server.on('error', (err) => {
SmtpLogger.error(`SMTP server error after recovery: ${err.message}`, { error: err });
// Try to recover again if needed
if (this.shouldAttemptRecovery(err)) {
this.attemptServerRecovery('standard', err);
}
});
// Start listening again
await new Promise<void>((resolve, reject) => {
if (!this.server) {
reject(new Error('Server not initialized during recovery'));
return;
}
this.server.listen(this.options.port, this.options.host, () => {
SmtpLogger.info(`SMTP server recovered and listening on ${this.options.host || '0.0.0.0'}:${this.options.port}`);
resolve();
});
SmtpLogger.info(`SMTP server recovered and listening on ${this.options.host || '0.0.0.0'}:${this.options.port}`);
// Start accepting connections again
this.acceptLoop = this.acceptConnections();
} catch (listenError) {
SmtpLogger.error(`Failed to restart server during recovery: ${listenError instanceof Error ? listenError.message : String(listenError)}`);
throw listenError;
}
// Only use error event for startup issues during recovery
this.server.once('error', (err) => {
SmtpLogger.error(`Failed to restart server during recovery: ${err.message}`);
reject(err);
});
});
} else if (this.options.securePort && this.tlsHandler.isTlsEnabled()) {
// Try to recreate the secure server
try {
// Import the secure server creation utility
const { createSecureTlsServer } = await import('./secure-server.ts');
const { createSecureTlsServer } = await import('./secure-server.js');
// Create secure server with the certificates
this.secureServer = createSecureTlsServer({
@@ -779,7 +784,7 @@ export class SmtpServer implements ISmtpServer {
await Promise.all(destroyPromises);
// Destroy the adaptive logger singleton to clean up its timer
const { adaptiveLogger } = await import('./utils/adaptive-logging.ts');
const { adaptiveLogger } = await import('./utils/adaptive-logging.js');
if (adaptiveLogger && typeof adaptiveLogger.destroy === 'function') {
adaptiveLogger.destroy();
}

368
ts/mail/delivery/smtpserver/starttls-handler.ts
View File

@@ -1,18 +1,21 @@
/**
* STARTTLS Implementation using Deno Native TLS
* Uses Deno.startTls() for reliable TLS upgrades
* STARTTLS Implementation
* Provides an improved implementation for STARTTLS upgrades
*/
import * as plugins from '../../../plugins.ts';
import { SmtpLogger } from './utils/logging.ts';
import {
loadCertificatesFromString,
createTlsOptions,
type ICertificateData
} from './certificate-utils.ts';
import { getSocketDetails } from './utils/helpers.ts';
import { ConnectionWrapper } from './utils/connection-wrapper.ts';
import type { ISmtpSession, ISessionManager, IConnectionManager } from './interfaces.ts';
import { SmtpState } from '../interfaces.ts';
/**
* Perform STARTTLS using Deno's native TLS implementation
* This replaces the broken Node.js TLS compatibility layer
* Enhanced STARTTLS handler for more reliable TLS upgrades
*/
export async function performStartTLS(
socket: plugins.net.Socket,
@@ -23,174 +26,237 @@ export async function performStartTLS(
session?: ISmtpSession;
sessionManager?: ISessionManager;
connectionManager?: IConnectionManager;
onSuccess?: (tlsSocket: plugins.tls.TLSSocket | ConnectionWrapper) => void;
onSuccess?: (tlsSocket: plugins.tls.TLSSocket) => void;
onFailure?: (error: Error) => void;
updateSessionState?: (session: ISmtpSession, state: SmtpState) => void;
}
): Promise<plugins.tls.TLSSocket | ConnectionWrapper | undefined> {
return new Promise<plugins.tls.TLSSocket | ConnectionWrapper | undefined>(async (resolve) => {
): Promise<plugins.tls.TLSSocket | undefined> {
return new Promise<plugins.tls.TLSSocket | undefined>((resolve) => {
try {
const socketDetails = getSocketDetails(socket);
SmtpLogger.info('Starting Deno-native STARTTLS upgrade process', {
SmtpLogger.info('Starting enhanced STARTTLS upgrade process', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
// Check if this is a ConnectionWrapper (Deno.Conn based)
if (socket instanceof ConnectionWrapper) {
SmtpLogger.info('Using Deno-native STARTTLS implementation for ConnectionWrapper');
// Get the underlying Deno.Conn
const denoConn = socket.getDenoConn();
// Set up timeout for TLS handshake
const handshakeTimeout = 30000; // 30 seconds
const timeoutId = setTimeout(() => {
const error = new Error('TLS handshake timed out');
SmtpLogger.error(error.message, {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
if (options.onFailure) {
options.onFailure(error);
}
resolve(undefined);
}, handshakeTimeout);
try {
// Write cert and key to temporary files for Deno.startTls()
const tempDir = await Deno.makeTempDir();
const certFile = `${tempDir}/cert.pem`;
const keyFile = `${tempDir}/key.pem`;
try {
await Deno.writeTextFile(certFile, options.cert);
await Deno.writeTextFile(keyFile, options.key);
// Upgrade connection to TLS using Deno's native API
const tlsConn = await Deno.startTls(denoConn, {
hostname: 'localhost', // Server-side TLS doesn't need hostname validation
certFile,
keyFile,
alpnProtocols: ['smtp'],
});
clearTimeout(timeoutId);
SmtpLogger.info('TLS upgrade successful via Deno-native STARTTLS', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
// Replace the underlying connection in the wrapper
socket.replaceConnection(tlsConn);
// Update socket mapping in session manager
if (options.sessionManager) {
// Socket wrapper remains the same, just upgraded to TLS
const socketReplaced = options.sessionManager.replaceSocket(socket as any, socket as any);
if (!socketReplaced) {
SmtpLogger.warn('Socket already tracked in session manager', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
}
}
// Re-attach event handlers from connection manager if needed
if (options.connectionManager) {
try {
options.connectionManager.setupSocketEventHandlers(socket as any);
SmtpLogger.debug('Successfully re-attached connection manager event handlers to TLS socket', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
} catch (handlerError) {
SmtpLogger.error('Failed to re-attach event handlers to TLS socket after STARTTLS', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort,
error: handlerError instanceof Error ? handlerError : new Error(String(handlerError))
});
}
}
// Update session if provided
if (options.session) {
// Update session properties to indicate TLS is active
options.session.useTLS = true;
options.session.secure = true;
// Reset session state as required by RFC 3207
// After STARTTLS, client must issue a new EHLO
if (options.updateSessionState) {
options.updateSessionState(options.session, SmtpState.GREETING);
}
}
// Call success callback if provided
if (options.onSuccess) {
options.onSuccess(socket);
}
// Success - return the wrapper with upgraded TLS connection
resolve(socket);
} finally {
// Clean up temporary files
try {
await Deno.remove(tempDir, { recursive: true });
} catch {
// Ignore cleanup errors
}
}
} catch (tlsError) {
clearTimeout(timeoutId);
const error = tlsError instanceof Error ? tlsError : new Error(String(tlsError));
SmtpLogger.error(`Deno TLS upgrade failed: ${error.message}`, {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort,
error,
stack: error.stack
});
if (options.onFailure) {
options.onFailure(error);
}
resolve(undefined);
// Create a proper socket cleanup function
const cleanupSocket = () => {
// Remove all listeners to prevent memory leaks
socket.removeAllListeners('data');
socket.removeAllListeners('error');
socket.removeAllListeners('close');
socket.removeAllListeners('end');
socket.removeAllListeners('drain');
};
// Prepare the socket for TLS upgrade
socket.setNoDelay(true);
// Critical: make sure there's no pending data before TLS handshake
socket.pause();
// Add error handling for the base socket
const handleSocketError = (err: Error) => {
SmtpLogger.error(`Socket error during STARTTLS preparation: ${err.message}`, {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort,
error: err,
stack: err.stack
});
if (options.onFailure) {
options.onFailure(err);
}
} else {
// Fallback: This should not happen since all connections are now ConnectionWrapper
SmtpLogger.error('STARTTLS called on non-ConnectionWrapper socket - this should not happen', {
socketType: socket.constructor.name,
// Resolve with undefined to indicate failure
resolve(undefined);
};
socket.once('error', handleSocketError);
// Load certificates
let certificates: ICertificateData;
try {
certificates = loadCertificatesFromString({
key: options.key,
cert: options.cert,
ca: options.ca
});
} catch (certError) {
SmtpLogger.error(`Certificate error during STARTTLS: ${certError instanceof Error ? certError.message : String(certError)}`);
if (options.onFailure) {
options.onFailure(certError instanceof Error ? certError : new Error(String(certError)));
}
resolve(undefined);
return;
}
// Create TLS options optimized for STARTTLS
const tlsOptions = createTlsOptions(certificates, true);
// Create secure context
let secureContext;
try {
secureContext = plugins.tls.createSecureContext(tlsOptions);
} catch (contextError) {
SmtpLogger.error(`Failed to create secure context: ${contextError instanceof Error ? contextError.message : String(contextError)}`);
if (options.onFailure) {
options.onFailure(contextError instanceof Error ? contextError : new Error(String(contextError)));
}
resolve(undefined);
return;
}
// Log STARTTLS upgrade attempt
SmtpLogger.debug('Attempting TLS socket upgrade with options', {
minVersion: tlsOptions.minVersion,
maxVersion: tlsOptions.maxVersion,
handshakeTimeout: tlsOptions.handshakeTimeout
});
// Use a safer approach to create the TLS socket
const handshakeTimeout = 30000; // 30 seconds timeout for TLS handshake
let handshakeTimeoutId: NodeJS.Timeout | undefined;
// Create the TLS socket using a conservative approach for STARTTLS
const tlsSocket = new plugins.tls.TLSSocket(socket, {
isServer: true,
secureContext,
// Server-side options (simpler is more reliable for STARTTLS)
requestCert: false,
rejectUnauthorized: false
});
// Set up error handling for the TLS socket
tlsSocket.once('error', (err) => {
if (handshakeTimeoutId) {
clearTimeout(handshakeTimeoutId);
}
SmtpLogger.error(`TLS error during STARTTLS: ${err.message}`, {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort,
error: err,
stack: err.stack
});
// Clean up socket listeners
cleanupSocket();
if (options.onFailure) {
options.onFailure(err);
}
// Destroy the socket to ensure we don't have hanging connections
tlsSocket.destroy();
resolve(undefined);
});
// Set up handshake timeout manually for extra safety
handshakeTimeoutId = setTimeout(() => {
SmtpLogger.error('TLS handshake timed out', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
const error = new Error('STARTTLS requires ConnectionWrapper (Deno.Conn based socket)');
// Clean up socket listeners
cleanupSocket();
if (options.onFailure) {
options.onFailure(error);
options.onFailure(new Error('TLS handshake timed out'));
}
// Destroy the socket to ensure we don't have hanging connections
tlsSocket.destroy();
resolve(undefined);
}
}, handshakeTimeout);
// Set up handler for successful TLS negotiation
tlsSocket.once('secure', () => {
if (handshakeTimeoutId) {
clearTimeout(handshakeTimeoutId);
}
const protocol = tlsSocket.getProtocol();
const cipher = tlsSocket.getCipher();
SmtpLogger.info('TLS upgrade successful via STARTTLS', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort,
protocol: protocol || 'unknown',
cipher: cipher?.name || 'unknown'
});
// Update socket mapping in session manager
if (options.sessionManager) {
const socketReplaced = options.sessionManager.replaceSocket(socket, tlsSocket);
if (!socketReplaced) {
SmtpLogger.error('Failed to replace socket in session manager after STARTTLS', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
}
}
// Re-attach event handlers from connection manager
if (options.connectionManager) {
try {
options.connectionManager.setupSocketEventHandlers(tlsSocket);
SmtpLogger.debug('Successfully re-attached connection manager event handlers to TLS socket', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort
});
} catch (handlerError) {
SmtpLogger.error('Failed to re-attach event handlers to TLS socket after STARTTLS', {
remoteAddress: socketDetails.remoteAddress,
remotePort: socketDetails.remotePort,
error: handlerError instanceof Error ? handlerError : new Error(String(handlerError))
});
}
}
// Update session if provided
if (options.session) {
// Update session properties to indicate TLS is active
options.session.useTLS = true;
options.session.secure = true;
// Reset session state as required by RFC 3207
// After STARTTLS, client must issue a new EHLO
if (options.updateSessionState) {
options.updateSessionState(options.session, SmtpState.GREETING);
}
}
// Call success callback if provided
if (options.onSuccess) {
options.onSuccess(tlsSocket);
}
// Success - return the TLS socket
resolve(tlsSocket);
});
// Resume the socket after we've set up all handlers
// This allows the TLS handshake to proceed
socket.resume();
} catch (error) {
SmtpLogger.error(`Unexpected error in Deno-native STARTTLS: ${error instanceof Error ? error.message : String(error)}`, {
SmtpLogger.error(`Unexpected error in STARTTLS: ${error instanceof Error ? error.message : String(error)}`, {
error: error instanceof Error ? error : new Error(String(error)),
stack: error instanceof Error ? error.stack : 'No stack trace available'
});
if (options.onFailure) {
options.onFailure(error instanceof Error ? error : new Error(String(error)));
}
resolve(undefined);
}
});
}
}

67
ts/mail/delivery/smtpserver/tls-handler.ts
View File

@@ -110,84 +110,100 @@ export class TlsHandler implements ITlsHandler {
}
/**
* Upgrade a connection to TLS using Deno-native implementation
* Upgrade a connection to TLS
* @param socket - Client socket
*/
public async startTLS(socket: plugins.net.Socket): Promise<plugins.tls.TLSSocket | any> {
public async startTLS(socket: plugins.net.Socket): Promise<plugins.tls.TLSSocket> {
// Get the session for this socket
const session = this.smtpServer.getSessionManager().getSession(socket);
try {
// Use the unified STARTTLS implementation (Deno-native)
const { performStartTLS } = await import('./starttls-handler.ts');
SmtpLogger.info('Starting STARTTLS upgrade', {
remoteAddress: socket.remoteAddress,
remotePort: socket.remotePort
});
// Import the enhanced STARTTLS handler
// This uses a more robust approach to TLS upgrades
const { performStartTLS } = await import('./starttls-handler.js');
SmtpLogger.info('Using enhanced STARTTLS implementation');
// Use the enhanced STARTTLS handler with better error handling and socket management
const serverOptions = this.smtpServer.getOptions();
const tlsSocket = await performStartTLS(socket, {
key: serverOptions.key,
cert: serverOptions.cert,
ca: serverOptions.ca,
session,
session: session,
sessionManager: this.smtpServer.getSessionManager(),
connectionManager: this.smtpServer.getConnectionManager(),
// Callback for successful upgrade
onSuccess: (secureSocket) => {
SmtpLogger.info('TLS connection successfully established', {
SmtpLogger.info('TLS connection successfully established via enhanced STARTTLS', {
remoteAddress: secureSocket.remoteAddress,
remotePort: secureSocket.remotePort
remotePort: secureSocket.remotePort,
protocol: secureSocket.getProtocol() || 'unknown',
cipher: secureSocket.getCipher()?.name || 'unknown'
});
// Log security event
SmtpLogger.logSecurityEvent(
SecurityLogLevel.INFO,
SecurityEventType.TLS_NEGOTIATION,
'STARTTLS successful',
{},
'STARTTLS successful with enhanced implementation',
{
protocol: secureSocket.getProtocol(),
cipher: secureSocket.getCipher()?.name
},
secureSocket.remoteAddress,
undefined,
true
);
},
// Callback for failed upgrade
onFailure: (error) => {
SmtpLogger.error(`STARTTLS failed: ${error.message}`, {
SmtpLogger.error(`Enhanced STARTTLS failed: ${error.message}`, {
sessionId: session?.id,
remoteAddress: socket.remoteAddress,
error
});
// Log security event
SmtpLogger.logSecurityEvent(
SecurityLogLevel.ERROR,
SecurityEventType.TLS_NEGOTIATION,
'STARTTLS failed',
'Enhanced STARTTLS failed',
{ error: error.message },
socket.remoteAddress,
undefined,
false
);
},
// Function to update session state
updateSessionState: this.smtpServer.getSessionManager().updateSessionState?.bind(this.smtpServer.getSessionManager())
});
// If STARTTLS failed with the enhanced implementation, log the error
if (!tlsSocket) {
SmtpLogger.warn('Enhanced STARTTLS implementation failed to create TLS socket', {
sessionId: session?.id,
remoteAddress: socket.remoteAddress
});
throw new Error('Failed to create TLS socket');
}
return tlsSocket;
} catch (error) {
// Log STARTTLS failure
SmtpLogger.error(`Failed to upgrade connection to TLS: ${error instanceof Error ? error.message : String(error)}`, {
remoteAddress: socket.remoteAddress,
remotePort: socket.remotePort,
error: error instanceof Error ? error : new Error(String(error)),
stack: error instanceof Error ? error.stack : 'No stack trace available'
});
// Log security event
SmtpLogger.logSecurityEvent(
SecurityLogLevel.ERROR,
SecurityEventType.TLS_NEGOTIATION,
'Failed to upgrade connection to TLS',
{
{
error: error instanceof Error ? error.message : String(error),
stack: error instanceof Error ? error.stack : 'No stack trace available'
},
@@ -195,7 +211,8 @@ export class TlsHandler implements ITlsHandler {
undefined,
false
);
// Destroy the socket on error
socket.destroy();
throw error;
}

298
ts/mail/delivery/smtpserver/utils/connection-wrapper.ts
View File

@@ -1,298 +0,0 @@
/**
* Connection Wrapper Utility
* Wraps Deno.Conn to provide Node.js net.Socket-compatible interface
* This allows the SMTP server to use Deno's native networking while maintaining
* compatibility with existing Socket-based code
*/
import { EventEmitter } from '../../../../plugins.ts';
/**
* Wraps a Deno.Conn or Deno.TlsConn to provide a Node.js Socket-compatible interface
*/
export class ConnectionWrapper extends EventEmitter {
private conn: Deno.Conn | Deno.TlsConn;
private _destroyed = false;
private _reading = false;
private _remoteAddr: Deno.NetAddr;
private _localAddr: Deno.NetAddr;
constructor(conn: Deno.Conn | Deno.TlsConn) {
super();
this.conn = conn;
this._remoteAddr = conn.remoteAddr as Deno.NetAddr;
this._localAddr = conn.localAddr as Deno.NetAddr;
// Start reading from the connection
this._reading = true;
this._startReading();
}
/**
* Get remote address (Node.js net.Socket compatible)
*/
get remoteAddress(): string {
return this._remoteAddr.hostname;
}
/**
* Get remote port (Node.js net.Socket compatible)
*/
get remotePort(): number {
return this._remoteAddr.port;
}
/**
* Get local address (Node.js net.Socket compatible)
*/
get localAddress(): string {
return this._localAddr.hostname;
}
/**
* Get local port (Node.js net.Socket compatible)
*/
get localPort(): number {
return this._localAddr.port;
}
/**
* Check if connection is destroyed
*/
get destroyed(): boolean {
return this._destroyed;
}
/**
* Check ready state (Node.js compatible)
*/
get readyState(): string {
if (this._destroyed) {
return 'closed';
}
return 'open';
}
/**
* Check if writable (Node.js compatible)
*/
get writable(): boolean {
return !this._destroyed;
}
/**
* Check if this is a secure (TLS) connection
*/
get encrypted(): boolean {
return 'handshake' in this.conn; // TlsConn has handshake property
}
/**
* Write data to the connection (Node.js net.Socket compatible)
*/
write(data: string | Uint8Array, encoding?: string | ((err?: Error) => void), callback?: (err?: Error) => void): boolean {
// Handle overloaded signatures (encoding is optional)
if (typeof encoding === 'function') {
callback = encoding;
encoding = undefined;
}
if (this._destroyed) {
const error = new Error('Connection is destroyed');
if (callback) {
setTimeout(() => callback(error), 0);
}
return false;
}
const bytes = typeof data === 'string'
? new TextEncoder().encode(data)
: data;
// Use a promise-based approach that Node.js compatibility expects
// Write happens async but we return true immediately (buffered)
this.conn.write(bytes)
.then(() => {
if (callback) {
callback();
}
})
.catch((err) => {
const error = err instanceof Error ? err : new Error(String(err));
if (callback) {
callback(error);
} else {
this.emit('error', error);
}
});
return true;
}
/**
* End the connection (Node.js net.Socket compatible)
*/
end(data?: string | Uint8Array, encoding?: string, callback?: () => void): void {
if (data) {
this.write(data, encoding, () => {
this.destroy();
if (callback) callback();
});
} else {
this.destroy();
if (callback) callback();
}
}
/**
* Destroy the connection (Node.js net.Socket compatible)
*/
destroy(error?: Error): void {
if (this._destroyed) {
return;
}
this._destroyed = true;
this._reading = false;
try {
this.conn.close();
} catch (closeError) {
// Ignore close errors
}
if (error) {
this.emit('error', error);
}
this.emit('close', !!error);
}
/**
* Set TCP_NODELAY option (Node.js net.Socket compatible)
*/
setNoDelay(noDelay: boolean = true): this {
try {
// @ts-ignore - Deno.Conn has setNoDelay
if (typeof this.conn.setNoDelay === 'function') {
// @ts-ignore
this.conn.setNoDelay(noDelay);
}
} catch {
// Ignore if not supported
}
return this;
}
/**
* Set keep-alive option (Node.js net.Socket compatible)
*/
setKeepAlive(enable: boolean = true, initialDelay?: number): this {
try {
// @ts-ignore - Deno.Conn has setKeepAlive
if (typeof this.conn.setKeepAlive === 'function') {
// @ts-ignore
this.conn.setKeepAlive(enable);
}
} catch {
// Ignore if not supported
}
return this;
}
/**
* Set timeout (Node.js net.Socket compatible)
*/
setTimeout(timeout: number, callback?: () => void): this {
// Deno doesn't have built-in socket timeout, but we can implement it
// For now, just accept the call without error (most timeout handling is done elsewhere)
if (callback) {
// If callback provided, we could set up a timer, but for now just ignore
// The SMTP server handles timeouts at a higher level
}
return this;
}
/**
* Pause reading from the connection
*/
pause(): this {
this._reading = false;
return this;
}
/**
* Resume reading from the connection
*/
resume(): this {
if (!this._reading && !this._destroyed) {
this._reading = true;
this._startReading();
}
return this;
}
/**
* Get the underlying Deno.Conn
*/
getDenoConn(): Deno.Conn | Deno.TlsConn {
return this.conn;
}
/**
* Replace the underlying connection (for STARTTLS upgrade)
*/
replaceConnection(newConn: Deno.TlsConn): void {
this.conn = newConn;
this._remoteAddr = newConn.remoteAddr as Deno.NetAddr;
this._localAddr = newConn.localAddr as Deno.NetAddr;
// Restart reading from the new TLS connection
if (!this._destroyed) {
this._reading = true;
this._startReading();
}
}
/**
* Internal method to read data from the connection
*/
private async _startReading(): Promise<void> {
if (!this._reading || this._destroyed) {
return;
}
try {
const buffer = new Uint8Array(4096);
while (this._reading && !this._destroyed) {
const n = await this.conn.read(buffer);
if (n === null) {
// EOF
this._destroyed = true;
this.emit('end');
this.emit('close', false);
break;
}
const data = buffer.subarray(0, n);
this.emit('data', data);
}
} catch (error) {
if (!this._destroyed) {
this._destroyed = true;
this.emit('error', error instanceof Error ? error : new Error(String(error)));
this.emit('close', true);
}
}
}
/**
* Remove all listeners (cleanup helper)
*/
removeAllListeners(event?: string): this {
super.removeAllListeners(event);
return this;
}
}

19
ts/mail/index.ts Normal file
View File

@@ -0,0 +1,19 @@
// Export all mail modules for simplified imports
export * from './routing/index.ts';
export * from './security/index.ts';
// Make the core and delivery modules accessible
import * as Core from './core/index.ts';
import * as Delivery from './delivery/index.ts';
export { Core, Delivery };
// For direct imports
import { Email } from './core/classes.email.ts';
import { DcRouter } from '../classes.dcrouter.ts';
// Re-export commonly used classes
export {
Email,
DcRouter
};

2
ts/mail/routing/classes.dns.manager.ts
View File

@@ -1,7 +1,7 @@
import * as plugins from '../../plugins.ts';
import type { IEmailDomainConfig } from './interfaces.ts';
import { logger } from '../../logger.ts';
import type { DcRouter } from '../../classes.mailer.ts';
import type { DcRouter } from '../../classes.dcrouter.ts';
import type { StorageManager } from '../../storage/index.ts';
/**

2
ts/mail/routing/classes.dnsmanager.ts
View File

@@ -416,7 +416,7 @@ export class DNSManager {
*/
public async saveDnsRecommendations(domain: string, records: IDnsRecord[]): Promise<void> {
try {
const filePath = plugins.path.join(paths.dnsRecordsDir, `${domain}.recommendations.tson`);
const filePath = plugins.path.join(paths.dnsRecordsDir, `${domain}.recommendations.json`);
plugins.smartfile.memory.toFsSync(JSON.stringify(records, null, 2), filePath);
console.log(`DNS recommendations for ${domain} saved to ${filePath}`);
} catch (error) {

7
ts/mail/routing/classes.email.router.ts
View File

@@ -1,11 +1,12 @@
import * as plugins from '../../plugins.ts';
import { EventEmitter } from 'node:events';
import type { IEmailRoute, IEmailMatch, IEmailAction, IEmailContext } from './interfaces.ts';
import type { Email } from '../core/classes.email.ts';
/**
* Email router that evaluates routes and determines actions
*/
export class EmailRouter extends plugins.EventEmitter {
export class EmailRouter extends EventEmitter {
private routes: IEmailRoute[];
private patternCache: Map<string, boolean> = new Map();
private storageManager?: any; // StorageManager instance
@@ -407,7 +408,7 @@ export class EmailRouter extends plugins.EventEmitter {
}
const routesData = JSON.stringify(this.routes, null, 2);
await this.storageManager.set('/email/routes/config.tson', routesData);
await this.storageManager.set('/email/routes/config.json', routesData);
this.emit('routesPersisted', this.routes.length);
} catch (error) {
@@ -430,7 +431,7 @@ export class EmailRouter extends plugins.EventEmitter {
}
try {
const routesData = await this.storageManager.get('/email/routes/config.tson');
const routesData = await this.storageManager.get('/email/routes/config.json');
if (!routesData) {
return [];

5
ts/mail/routing/classes.unified.email.server.ts
View File

@@ -1,5 +1,6 @@
import * as plugins from '../../plugins.ts';
import * as paths from '../../paths.ts';
import { EventEmitter } from 'events';
import { logger } from '../../logger.ts';
import {
SecurityLogger,
@@ -28,7 +29,7 @@ import { UnifiedDeliveryQueue, type IQueueOptions } from '../delivery/classes.de
import { UnifiedRateLimiter, type IHierarchicalRateLimits } from '../delivery/classes.unified.rate.limiter.ts';
import { SmtpState } from '../delivery/interfaces.ts';
import type { EmailProcessingMode, ISmtpSession as IBaseSmtpSession } from '../delivery/interfaces.ts';
import type { DcRouter } from '../../classes.mailer.ts';
import type { DcRouter } from '../../classes.dcrouter.ts';
/**
* Extended SMTP session interface with route information
@@ -153,7 +154,7 @@ export interface IServerStats {
/**
* Unified email server that handles all email traffic with pattern-based routing
*/
export class UnifiedEmailServer extends plugins.EventEmitter {
export class UnifiedEmailServer extends EventEmitter {
private dcRouter: DcRouter;
private options: IUnifiedEmailServerOptions;
private emailRouter: EmailRouter;

2
ts/mail/security/classes.dkimcreator.ts
View File

@@ -47,7 +47,7 @@ export class DKIMCreator {
await this.createAndStoreDKIMKeys(domainArg);
const dnsValue = await this.getDNSRecordForDomain(domainArg);
plugins.smartfile.fs.ensureDirSync(paths.dnsRecordsDir);
plugins.smartfile.memory.toFsSync(JSON.stringify(dnsValue, null, 2), plugins.path.join(paths.dnsRecordsDir, `${domainArg}.dkimrecord.tson`));
plugins.smartfile.memory.toFsSync(JSON.stringify(dnsValue, null, 2), plugins.path.join(paths.dnsRecordsDir, `${domainArg}.dkimrecord.json`));
}
}

27
ts/paths.ts
View File

@@ -1,27 +0,0 @@
/**
* Paths module
* Project paths for mailer
*/
import * as plugins from './plugins.ts';
// Get package directory (where the script is run from)
export const packageDir = Deno.cwd();
// Config directory
export const configDir = plugins.path.join(Deno.env.get('HOME') || '/root', '.mailer');
// Data directory
export const dataDir = plugins.path.join(configDir, 'data');
// Logs directory
export const logsDir = plugins.path.join(configDir, 'logs');
// DKIM keys directory
export const dkimKeysDir = plugins.path.join(configDir, 'dkim-keys');
// Keys directory (alias for compatibility)
export const keysDir = dkimKeysDir;
// DNS records directory
export const dnsRecordsDir = plugins.path.join(configDir, 'dns-records');

112
ts/plugins.ts
View File

@@ -1,51 +1,95 @@
/**
* Plugin dependencies for the mailer package
* Imports both Deno standard library and Node.js compatibility
*/
// node native
import * as dns from 'dns';
import * as fs from 'fs';
import * as crypto from 'crypto';
import * as http from 'http';
import * as net from 'net';
import * as os from 'os';
import * as path from 'path';
import * as tls from 'tls';
import * as util from 'util';
// Deno standard library
export * as path from '@std/path';
export * as colors from '@std/fmt/colors';
export * as cli from '@std/cli';
export { serveDir } from '@std/http/file-server';
export * as denoCrypto from '@std/crypto';
export {
dns,
fs,
crypto,
http,
net,
os,
path,
tls,
util,
}
// Node.js built-in modules (needed for SMTP and email processing)
import { EventEmitter } from 'node:events';
import * as net from 'node:net';
import * as tls from 'node:tls';
import * as dns from 'node:dns';
import * as fs from 'node:fs';
import * as os from 'node:os';
import * as process from 'node:process';
import * as buffer from 'node:buffer';
import * as util from 'node:util';
import * as crypto from 'node:crypto';
// @serve.zone scope
import * as servezoneInterfaces from '@serve.zone/interfaces';
export { EventEmitter, net, tls, dns, fs, os, process, buffer, util, crypto };
export const Buffer = buffer.Buffer;
export {
servezoneInterfaces
}
// Cloudflare API client
import * as cloudflareImport from '@apiclient.xyz/cloudflare';
export const cloudflare = cloudflareImport;
// @api.global scope
import * as typedrequest from '@api.global/typedrequest';
import * as typedserver from '@api.global/typedserver';
import * as typedsocket from '@api.global/typedsocket';
// @push.rocks packages
import * as smartfile from '@push.rocks/smartfile';
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 * 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 smartrx from '@push.rocks/smartrx';
import * as smartunique from '@push.rocks/smartunique';
export { smartfile, smartdns, smartmail };
export { projectinfo, qenv, smartacme, smartdata, smartdns, smartfile, smartguard, smartjwt, smartlog, smartmail, smartmetrics, smartnetwork, smartpath, smartproxy, smartpromise, smartrequest, smartrule, smartrx, smartunique };
// @tsclass packages
// 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';
export { tsclass };
export {
tsclass,
}
// Third-party libraries
// third party
import * as mailauth from 'mailauth';
import { dkimSign } from 'mailauth/lib/dkim/sign.js';
import mailparser from 'mailparser';
import * as uuid from 'uuid';
import * as ip from 'ip';
import { LRUCache } from 'lru-cache';
export { mailauth, dkimSign, uuid, ip, LRUCache };
export {
mailauth,
dkimSign,
mailparser,
uuid,
ip,
}

23
ts/security/classes.ipreputationchecker.ts
View File

@@ -1,23 +0,0 @@
/**
* IP Reputation Checker
* Checks IP addresses against reputation databases
*/
export interface IIpReputationResult {
ip: string;
score: number;
isBlacklisted: boolean;
sources: string[];
}
export class IPReputationChecker {
public async checkReputation(ip: string): Promise<IIpReputationResult> {
// Placeholder implementation
return {
ip,
score: 100,
isBlacklisted: false,
sources: [],
};
}
}

33
ts/security/index.ts
View File

@@ -1,33 +0,0 @@
/**
* Security module stub
* Security logging and IP reputation checking
*/
export enum SecurityLogLevel {
DEBUG = 'debug',
INFO = 'info',
WARNING = 'warning',
ERROR = 'error',
CRITICAL = 'critical',
}
export enum SecurityEventType {
AUTH_SUCCESS = 'auth_success',
AUTH_FAILURE = 'auth_failure',
RATE_LIMIT = 'rate_limit',
SPAM_DETECTED = 'spam_detected',
MALWARE_DETECTED = 'malware_detected',
}
export class SecurityLogger {
log(level: SecurityLogLevel, eventType: SecurityEventType, message: string, metadata?: any): void {
console.log(`[SECURITY] [${level}] [${eventType}] ${message}`, metadata || '');
}
}
export class IPReputationChecker {
async checkReputation(ip: string): Promise<{ safe: boolean; score: number }> {
// Stub: always return safe
return { safe: true, score: 100 };
}
}

22
ts/storage/index.ts
View File

@@ -1,22 +0,0 @@
/**
* Storage module stub
* Simplified storage manager for mailer
*/
export interface IStorageOptions {
dataDir?: string;
}
export class StorageManager {
constructor(options?: IStorageOptions) {
// Stub implementation
}
async get(key: string): Promise<any> {
return null;
}
async set(key: string, value: any): Promise<void> {
// Stub implementation
}
}