@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/security/classes.spfverifier.js

@@ -0,0 +1,492 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
+/**
+ * SPF result qualifiers
+ */
+export var SpfQualifier;
+(function (SpfQualifier) {
+    SpfQualifier["PASS"] = "+";
+    SpfQualifier["NEUTRAL"] = "?";
+    SpfQualifier["SOFTFAIL"] = "~";
+    SpfQualifier["FAIL"] = "-";
+})(SpfQualifier || (SpfQualifier = {}));
+/**
+ * SPF mechanism types
+ */
+export var SpfMechanismType;
+(function (SpfMechanismType) {
+    SpfMechanismType["ALL"] = "all";
+    SpfMechanismType["INCLUDE"] = "include";
+    SpfMechanismType["A"] = "a";
+    SpfMechanismType["MX"] = "mx";
+    SpfMechanismType["IP4"] = "ip4";
+    SpfMechanismType["IP6"] = "ip6";
+    SpfMechanismType["EXISTS"] = "exists";
+    SpfMechanismType["REDIRECT"] = "redirect";
+    SpfMechanismType["EXP"] = "exp";
+})(SpfMechanismType || (SpfMechanismType = {}));
+/**
+ * Maximum lookup limit for SPF records (prevent infinite loops)
+ */
+const MAX_SPF_LOOKUPS = 10;
+/**
+ * Class for verifying SPF records
+ */
+export class SpfVerifier {
+    constructor(dnsManager) {
+        this.lookupCount = 0;
+        this.dnsManager = dnsManager;
+    }
+    /**
+     * Parse SPF record from TXT record
+     * @param record SPF TXT record
+     * @returns Parsed SPF record or null if invalid
+     */
+    parseSpfRecord(record) {
+        if (!record.startsWith('v=spf1')) {
+            return null;
+        }
+        try {
+            const spfRecord = {
+                version: 'spf1',
+                mechanisms: [],
+                modifiers: {}
+            };
+            // Split into terms
+            const terms = record.split(' ').filter(term => term.length > 0);
+            // Skip version term
+            for (let i = 1; i < terms.length; i++) {
+                const term = terms[i];
+                // Check if it's a modifier (name=value)
+                if (term.includes('=')) {
+                    const [name, value] = term.split('=');
+                    spfRecord.modifiers[name] = value;
+                    continue;
+                }
+                // Parse as mechanism
+                let qualifier = SpfQualifier.PASS; // Default is +
+                let mechanismText = term;
+                // Check for qualifier
+                if (term.startsWith('+') || term.startsWith('-') ||
+                    term.startsWith('~') || term.startsWith('?')) {
+                    qualifier = term[0];
+                    mechanismText = term.substring(1);
+                }
+                // Parse mechanism type and value
+                const colonIndex = mechanismText.indexOf(':');
+                let type;
+                let value;
+                if (colonIndex !== -1) {
+                    type = mechanismText.substring(0, colonIndex);
+                    value = mechanismText.substring(colonIndex + 1);
+                }
+                else {
+                    type = mechanismText;
+                }
+                spfRecord.mechanisms.push({ qualifier, type, value });
+            }
+            return spfRecord;
+        }
+        catch (error) {
+            logger.log('error', `Error parsing SPF record: ${error.message}`, {
+                record,
+                error: error.message
+            });
+            return null;
+        }
+    }
+    /**
+     * Check if IP is in CIDR range
+     * @param ip IP address to check
+     * @param cidr CIDR range
+     * @returns Whether the IP is in the CIDR range
+     */
+    isIpInCidr(ip, cidr) {
+        try {
+            const ipAddress = plugins.ip.Address4.parse(ip);
+            return ipAddress.isInSubnet(new plugins.ip.Address4(cidr));
+        }
+        catch (error) {
+            // Try IPv6
+            try {
+                const ipAddress = plugins.ip.Address6.parse(ip);
+                return ipAddress.isInSubnet(new plugins.ip.Address6(cidr));
+            }
+            catch (e) {
+                return false;
+            }
+        }
+    }
+    /**
+     * Check if a domain has the specified IP in its A or AAAA records
+     * @param domain Domain to check
+     * @param ip IP address to check
+     * @returns Whether the domain resolves to the IP
+     */
+    async isDomainResolvingToIp(domain, ip) {
+        try {
+            // First try IPv4
+            const ipv4Addresses = await plugins.dns.promises.resolve4(domain);
+            if (ipv4Addresses.includes(ip)) {
+                return true;
+            }
+            // Then try IPv6
+            const ipv6Addresses = await plugins.dns.promises.resolve6(domain);
+            if (ipv6Addresses.includes(ip)) {
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Verify SPF for a given email with IP and helo domain
+     * @param email Email to verify
+     * @param ip Sender IP address
+     * @param heloDomain HELO/EHLO domain used by sender
+     * @returns SPF verification result
+     */
+    async verify(email, ip, heloDomain) {
+        const securityLogger = SecurityLogger.getInstance();
+        // Reset lookup count
+        this.lookupCount = 0;
+        // Get domain from envelope from (return-path)
+        const domain = email.getEnvelopeFrom().split('@')[1] || '';
+        if (!domain) {
+            return {
+                result: 'permerror',
+                explanation: 'No envelope from domain',
+                domain: '',
+                ip
+            };
+        }
+        try {
+            // Look up SPF record
+            const spfVerificationResult = this.dnsManager ?
+                await this.dnsManager.verifySpfRecord(domain) :
+                { found: false, valid: false, error: 'DNS Manager not available' };
+            if (!spfVerificationResult.found) {
+                return {
+                    result: 'none',
+                    explanation: 'No SPF record found',
+                    domain,
+                    ip
+                };
+            }
+            if (!spfVerificationResult.valid) {
+                return {
+                    result: 'permerror',
+                    explanation: 'Invalid SPF record',
+                    domain,
+                    ip,
+                    record: spfVerificationResult.value
+                };
+            }
+            // Parse SPF record
+            const spfRecord = this.parseSpfRecord(spfVerificationResult.value);
+            if (!spfRecord) {
+                return {
+                    result: 'permerror',
+                    explanation: 'Failed to parse SPF record',
+                    domain,
+                    ip,
+                    record: spfVerificationResult.value
+                };
+            }
+            // Check SPF record
+            const result = await this.checkSpfRecord(spfRecord, domain, ip);
+            // Log the result
+            const spfLogLevel = result.result === 'pass' ?
+                SecurityLogLevel.INFO :
+                (result.result === 'fail' ? SecurityLogLevel.WARN : SecurityLogLevel.INFO);
+            securityLogger.logEvent({
+                level: spfLogLevel,
+                type: SecurityEventType.SPF,
+                message: `SPF ${result.result} for ${domain} from IP ${ip}`,
+                domain,
+                details: {
+                    ip,
+                    heloDomain,
+                    result: result.result,
+                    explanation: result.explanation,
+                    record: spfVerificationResult.value
+                },
+                success: result.result === 'pass'
+            });
+            return {
+                ...result,
+                domain,
+                ip,
+                record: spfVerificationResult.value
+            };
+        }
+        catch (error) {
+            // Log error
+            logger.log('error', `SPF verification error: ${error.message}`, {
+                domain,
+                ip,
+                error: error.message
+            });
+            securityLogger.logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.SPF,
+                message: `SPF verification error for ${domain}`,
+                domain,
+                details: {
+                    ip,
+                    error: error.message
+                },
+                success: false
+            });
+            return {
+                result: 'temperror',
+                explanation: `Error verifying SPF: ${error.message}`,
+                domain,
+                ip,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Check SPF record against IP address
+     * @param spfRecord Parsed SPF record
+     * @param domain Domain being checked
+     * @param ip IP address to check
+     * @returns SPF result
+     */
+    async checkSpfRecord(spfRecord, domain, ip) {
+        // Check for 'redirect' modifier
+        if (spfRecord.modifiers.redirect) {
+            this.lookupCount++;
+            if (this.lookupCount > MAX_SPF_LOOKUPS) {
+                return {
+                    result: 'permerror',
+                    explanation: 'Too many DNS lookups',
+                    domain,
+                    ip
+                };
+            }
+            // Handle redirect
+            const redirectDomain = spfRecord.modifiers.redirect;
+            const redirectResult = this.dnsManager ?
+                await this.dnsManager.verifySpfRecord(redirectDomain) :
+                { found: false, valid: false, error: 'DNS Manager not available' };
+            if (!redirectResult.found || !redirectResult.valid) {
+                return {
+                    result: 'permerror',
+                    explanation: `Invalid redirect to ${redirectDomain}`,
+                    domain,
+                    ip
+                };
+            }
+            const redirectRecord = this.parseSpfRecord(redirectResult.value);
+            if (!redirectRecord) {
+                return {
+                    result: 'permerror',
+                    explanation: `Failed to parse redirect record from ${redirectDomain}`,
+                    domain,
+                    ip
+                };
+            }
+            return this.checkSpfRecord(redirectRecord, redirectDomain, ip);
+        }
+        // Check each mechanism in order
+        for (const mechanism of spfRecord.mechanisms) {
+            let matched = false;
+            switch (mechanism.type) {
+                case SpfMechanismType.ALL:
+                    matched = true;
+                    break;
+                case SpfMechanismType.IP4:
+                    if (mechanism.value) {
+                        matched = this.isIpInCidr(ip, mechanism.value);
+                    }
+                    break;
+                case SpfMechanismType.IP6:
+                    if (mechanism.value) {
+                        matched = this.isIpInCidr(ip, mechanism.value);
+                    }
+                    break;
+                case SpfMechanismType.A:
+                    this.lookupCount++;
+                    if (this.lookupCount > MAX_SPF_LOOKUPS) {
+                        return {
+                            result: 'permerror',
+                            explanation: 'Too many DNS lookups',
+                            domain,
+                            ip
+                        };
+                    }
+                    // Check if domain has A/AAAA record matching IP
+                    const checkDomain = mechanism.value || domain;
+                    matched = await this.isDomainResolvingToIp(checkDomain, ip);
+                    break;
+                case SpfMechanismType.MX:
+                    this.lookupCount++;
+                    if (this.lookupCount > MAX_SPF_LOOKUPS) {
+                        return {
+                            result: 'permerror',
+                            explanation: 'Too many DNS lookups',
+                            domain,
+                            ip
+                        };
+                    }
+                    // Check MX records
+                    const mxDomain = mechanism.value || domain;
+                    try {
+                        const mxRecords = await plugins.dns.promises.resolveMx(mxDomain);
+                        for (const mx of mxRecords) {
+                            // Check if this MX record's IP matches
+                            const mxMatches = await this.isDomainResolvingToIp(mx.exchange, ip);
+                            if (mxMatches) {
+                                matched = true;
+                                break;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // No MX records or error
+                        matched = false;
+                    }
+                    break;
+                case SpfMechanismType.INCLUDE:
+                    if (!mechanism.value) {
+                        continue;
+                    }
+                    this.lookupCount++;
+                    if (this.lookupCount > MAX_SPF_LOOKUPS) {
+                        return {
+                            result: 'permerror',
+                            explanation: 'Too many DNS lookups',
+                            domain,
+                            ip
+                        };
+                    }
+                    // Check included domain's SPF record
+                    const includeDomain = mechanism.value;
+                    const includeResult = this.dnsManager ?
+                        await this.dnsManager.verifySpfRecord(includeDomain) :
+                        { found: false, valid: false, error: 'DNS Manager not available' };
+                    if (!includeResult.found || !includeResult.valid) {
+                        continue; // Skip this mechanism
+                    }
+                    const includeRecord = this.parseSpfRecord(includeResult.value);
+                    if (!includeRecord) {
+                        continue; // Skip this mechanism
+                    }
+                    // Recursively check the included SPF record
+                    const includeCheck = await this.checkSpfRecord(includeRecord, includeDomain, ip);
+                    // Include mechanism matches if the result is "pass"
+                    matched = includeCheck.result === 'pass';
+                    break;
+                case SpfMechanismType.EXISTS:
+                    if (!mechanism.value) {
+                        continue;
+                    }
+                    this.lookupCount++;
+                    if (this.lookupCount > MAX_SPF_LOOKUPS) {
+                        return {
+                            result: 'permerror',
+                            explanation: 'Too many DNS lookups',
+                            domain,
+                            ip
+                        };
+                    }
+                    // Check if domain exists (has any A record)
+                    try {
+                        await plugins.dns.promises.resolve(mechanism.value, 'A');
+                        matched = true;
+                    }
+                    catch (error) {
+                        matched = false;
+                    }
+                    break;
+            }
+            // If this mechanism matched, return its result
+            if (matched) {
+                switch (mechanism.qualifier) {
+                    case SpfQualifier.PASS:
+                        return {
+                            result: 'pass',
+                            explanation: `Matched ${mechanism.type}${mechanism.value ? ':' + mechanism.value : ''}`,
+                            domain,
+                            ip
+                        };
+                    case SpfQualifier.FAIL:
+                        return {
+                            result: 'fail',
+                            explanation: `Matched ${mechanism.type}${mechanism.value ? ':' + mechanism.value : ''}`,
+                            domain,
+                            ip
+                        };
+                    case SpfQualifier.SOFTFAIL:
+                        return {
+                            result: 'softfail',
+                            explanation: `Matched ${mechanism.type}${mechanism.value ? ':' + mechanism.value : ''}`,
+                            domain,
+                            ip
+                        };
+                    case SpfQualifier.NEUTRAL:
+                        return {
+                            result: 'neutral',
+                            explanation: `Matched ${mechanism.type}${mechanism.value ? ':' + mechanism.value : ''}`,
+                            domain,
+                            ip
+                        };
+                }
+            }
+        }
+        // If no mechanism matched, default to neutral
+        return {
+            result: 'neutral',
+            explanation: 'No matching mechanism found',
+            domain,
+            ip
+        };
+    }
+    /**
+     * Check if email passes SPF verification
+     * @param email Email to verify
+     * @param ip Sender IP address
+     * @param heloDomain HELO/EHLO domain used by sender
+     * @returns Whether email passes SPF
+     */
+    async verifyAndApply(email, ip, heloDomain) {
+        const result = await this.verify(email, ip, heloDomain);
+        // Add headers
+        email.headers['Received-SPF'] = `${result.result} (${result.domain}: ${result.explanation}) client-ip=${ip}; envelope-from=${email.getEnvelopeFrom()}; helo=${heloDomain};`;
+        // Apply policy based on result
+        switch (result.result) {
+            case 'fail':
+                // Fail - mark as spam
+                email.mightBeSpam = true;
+                logger.log('warn', `SPF failed for ${result.domain} from ${ip}: ${result.explanation}`);
+                return false;
+            case 'softfail':
+                // Soft fail - accept but mark as suspicious
+                email.mightBeSpam = true;
+                logger.log('info', `SPF softfailed for ${result.domain} from ${ip}: ${result.explanation}`);
+                return true;
+            case 'neutral':
+            case 'none':
+                // Neutral or none - accept but note in headers
+                logger.log('info', `SPF ${result.result} for ${result.domain} from ${ip}: ${result.explanation}`);
+                return true;
+            case 'pass':
+                // Pass - accept
+                logger.log('info', `SPF passed for ${result.domain} from ${ip}: ${result.explanation}`);
+                return true;
+            case 'temperror':
+            case 'permerror':
+                // Temporary or permanent error - log but accept
+                logger.log('error', `SPF error for ${result.domain} from ${ip}: ${result.explanation}`);
+                return true;
+            default:
+                return true;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.spfverifier.js","sourceRoot":"","sources":["../../../ts/mail/security/classes.spfverifier.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+export * from './classes.dkimcreator.js';
+export * from './classes.dkimverifier.js';
+export * from './classes.dmarcverifier.js';
+export * from './classes.spfverifier.js';

package/dist_ts/mail/security/index.js

@@ -0,0 +1,6 @@
+// Email security components
+export * from './classes.dkimcreator.js';
+export * from './classes.dkimverifier.js';
+export * from './classes.dmarcverifier.js';
+export * from './classes.spfverifier.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9tYWlsL3NlY3VyaXR5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRCQUE0QjtBQUM1QixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDBCQUEwQixDQUFDIn0=

package/dist_ts/opsserver/classes.opsserver.d.ts

@@ -0,0 +1,14 @@
+import type DcRouter from '../classes.dcrouter.js';
+import * as plugins from '../plugins.js';
+export declare class OpsServer {
+    dcRouterRef: DcRouter;
+    server: plugins.typedserver.utilityservers.UtilityWebsiteServer;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(dcRouterRefArg: DcRouter);
+    start(): Promise<void>;
+    /**
+     * Set up all TypedRequest handlers
+     */
+    private setupHandlers;
+    stop(): Promise<void>;
+}

package/dist_ts/opsserver/classes.opsserver.js

@@ -0,0 +1,37 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+export class OpsServer {
+    constructor(dcRouterRefArg) {
+        // TypedRouter for OpsServer-specific handlers
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        this.dcRouterRef = dcRouterRefArg;
+        // Add our typedrouter to the dcRouter's main typedrouter
+        this.dcRouterRef.typedrouter.addTypedRouter(this.typedrouter);
+    }
+    async start() {
+        this.server = new plugins.typedserver.utilityservers.UtilityWebsiteServer({
+            domain: 'localhost',
+            feedMetadata: null,
+            serveDir: paths.distServe,
+        });
+        // The server has a built-in typedrouter at /typedrequest
+        // Add the main dcRouter typedrouter to the server's typedrouter
+        this.server.typedrouter.addTypedRouter(this.dcRouterRef.typedrouter);
+        // Set up handlers
+        this.setupHandlers();
+        await this.server.start(3000);
+    }
+    /**
+     * Set up all TypedRequest handlers
+     */
+    setupHandlers() {
+        // Handler setup will be implemented next
+        // For now, just a placeholder to ensure the structure is correct
+    }
+    async stop() {
+        if (this.server) {
+            await this.server.stop();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5vcHNzZXJ2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9vcHNzZXJ2ZXIvY2xhc3Nlcy5vcHNzZXJ2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxLQUFLLEtBQUssTUFBTSxhQUFhLENBQUM7QUFFckMsTUFBTSxPQUFPLFNBQVM7SUFPcEIsWUFBWSxjQUF3QjtRQUhwQyw4Q0FBOEM7UUFDdkMsZ0JBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7UUFHMUQsSUFBSSxDQUFDLFdBQVcsR0FBRyxjQUFjLENBQUM7UUFFbEMseURBQXlEO1FBQ3pELElBQUksQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUVNLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQUMsV0FBVyxDQUFDLGNBQWMsQ0FBQyxvQkFBb0IsQ0FBQztZQUN4RSxNQUFNLEVBQUUsV0FBVztZQUNuQixZQUFZLEVBQUUsSUFBSTtZQUNsQixRQUFRLEVBQUUsS0FBSyxDQUFDLFNBQVM7U0FDMUIsQ0FBQyxDQUFDO1FBRUgseURBQXlEO1FBQ3pELGdFQUFnRTtRQUNoRSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUVyRSxrQkFBa0I7UUFDbEIsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBRXJCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDaEMsQ0FBQztJQUVEOztPQUVHO0lBQ0ssYUFBYTtRQUNuQix5Q0FBeUM7UUFDekMsaUVBQWlFO0lBQ25FLENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSTtRQUNmLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2hCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUMzQixDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/opsserver/index.d.ts

@@ -0,0 +1 @@
+export * from './classes.opsserver.js';

package/dist_ts/opsserver/index.js

@@ -0,0 +1,2 @@
+export * from './classes.opsserver.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9vcHNzZXJ2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQyJ9

package/dist_ts/paths.d.ts

@@ -0,0 +1,14 @@
+export declare const baseDir: string;
+export declare const packageDir: string;
+export declare const distServe: string;
+export declare const dataDir: string;
+export declare const keysDir: string;
+export declare const dnsRecordsDir: string;
+export declare const sentEmailsDir: string;
+export declare const receivedEmailsDir: string;
+export declare const failedEmailsDir: string;
+export declare const logsDir: string;
+export declare const emailTemplatesDir: string;
+export declare const MtaAttachmentsDir: string;
+export declare const configPath: string;
+export declare function ensureDirectories(): void;

package/dist_ts/paths.js

@@ -0,0 +1,39 @@
+import * as plugins from './plugins.js';
+// Base directories
+export const baseDir = process.cwd();
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+export const distServe = plugins.path.join(packageDir, './dist_serve');
+// Configure data directory with environment variable or default to .nogit/data
+const DEFAULT_DATA_PATH = '.nogit/data';
+export const dataDir = process.env.DATA_DIR
+    ? process.env.DATA_DIR
+    : plugins.path.join(baseDir, DEFAULT_DATA_PATH);
+// MTA directories 
+export const keysDir = plugins.path.join(dataDir, 'keys');
+export const dnsRecordsDir = plugins.path.join(dataDir, 'dns');
+export const sentEmailsDir = plugins.path.join(dataDir, 'emails', 'sent');
+export const receivedEmailsDir = plugins.path.join(dataDir, 'emails', 'received');
+export const failedEmailsDir = plugins.path.join(dataDir, 'emails', 'failed'); // For failed emails
+export const logsDir = plugins.path.join(dataDir, 'logs'); // For logs
+// Email template directories
+export const emailTemplatesDir = plugins.path.join(dataDir, 'templates', 'email');
+export const MtaAttachmentsDir = plugins.path.join(dataDir, 'attachments'); // For email attachments
+// Configuration path
+export const configPath = process.env.CONFIG_PATH
+    ? process.env.CONFIG_PATH
+    : plugins.path.join(baseDir, 'config.json');
+// Create directories if they don't exist
+export function ensureDirectories() {
+    // Ensure data directories
+    plugins.smartfile.fs.ensureDirSync(dataDir);
+    plugins.smartfile.fs.ensureDirSync(keysDir);
+    plugins.smartfile.fs.ensureDirSync(dnsRecordsDir);
+    plugins.smartfile.fs.ensureDirSync(sentEmailsDir);
+    plugins.smartfile.fs.ensureDirSync(receivedEmailsDir);
+    plugins.smartfile.fs.ensureDirSync(failedEmailsDir);
+    plugins.smartfile.fs.ensureDirSync(logsDir);
+    // Ensure email template directories
+    plugins.smartfile.fs.ensureDirSync(emailTemplatesDir);
+    plugins.smartfile.fs.ensureDirSync(MtaAttachmentsDir);
+}
+//# sourceMappingURL=data:application/json;base64,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