@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/core/events/index.js

@@ -0,0 +1,5 @@
+export {};
+/**
+ * Common event definitions
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL2V2ZW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7O0dBRUcifQ==

package/dist_ts/core/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core functionality module
+ */
+export * from './models/index.js';
+export * from './utils/index.js';
+export * from './events/index.js';

package/dist_ts/core/index.js

@@ -0,0 +1,8 @@
+/**
+ * Core functionality module
+ */
+// Export submodules
+export * from './models/index.js';
+export * from './utils/index.js';
+export * from './events/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb3JlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsb0JBQW9CO0FBQ3BCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG1CQUFtQixDQUFDIn0=

package/dist_ts/core/models/common-types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared types for certificate management and domain options
+ */
+/**
+ * Domain forwarding configuration
+ */
+export interface IForwardConfig {
+    ip: string;
+    port: number;
+}
+/**
+ * Domain configuration options
+ */
+export interface IDomainOptions {
+    domainName: string;
+    sslRedirect: boolean;
+    acmeMaintenance: boolean;
+    forward?: IForwardConfig;
+    acmeForward?: IForwardConfig;
+}
+/**
+ * Certificate data that can be emitted via events or set from outside
+ */
+export interface ICertificateData {
+    domain: string;
+    certificate: string;
+    privateKey: string;
+    expiryDate: Date;
+}
+/**
+ * Events emitted by the Port80Handler
+ */
+export declare enum Port80HandlerEvents {
+    CERTIFICATE_ISSUED = "certificate-issued",
+    CERTIFICATE_RENEWED = "certificate-renewed",
+    CERTIFICATE_FAILED = "certificate-failed",
+    CERTIFICATE_EXPIRING = "certificate-expiring",
+    MANAGER_STARTED = "manager-started",
+    MANAGER_STOPPED = "manager-stopped",
+    REQUEST_FORWARDED = "request-forwarded"
+}
+/**
+ * Certificate failure payload type
+ */
+export interface ICertificateFailure {
+    domain: string;
+    error: string;
+    isRenewal: boolean;
+}
+/**
+ * Certificate expiry payload type
+ */
+export interface ICertificateExpiring {
+    domain: string;
+    expiryDate: Date;
+    daysRemaining: number;
+}
+/**
+ * Forwarding configuration for specific domains in ACME setup
+ */
+export interface IDomainForwardConfig {
+    domain: string;
+    forwardConfig?: IForwardConfig;
+    acmeForwardConfig?: IForwardConfig;
+    sslRedirect?: boolean;
+}
+/**
+ * Unified ACME configuration options used across proxies and handlers
+ */
+export interface IAcmeOptions {
+    accountEmail?: string;
+    enabled?: boolean;
+    port?: number;
+    useProduction?: boolean;
+    httpsRedirectPort?: number;
+    renewThresholdDays?: number;
+    renewCheckIntervalHours?: number;
+    autoRenew?: boolean;
+    certificateStore?: string;
+    skipConfiguredCerts?: boolean;
+    domainForwards?: IDomainForwardConfig[];
+}

package/dist_ts/core/models/common-types.js

@@ -0,0 +1,15 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Events emitted by the Port80Handler
+ */
+export var Port80HandlerEvents;
+(function (Port80HandlerEvents) {
+    Port80HandlerEvents["CERTIFICATE_ISSUED"] = "certificate-issued";
+    Port80HandlerEvents["CERTIFICATE_RENEWED"] = "certificate-renewed";
+    Port80HandlerEvents["CERTIFICATE_FAILED"] = "certificate-failed";
+    Port80HandlerEvents["CERTIFICATE_EXPIRING"] = "certificate-expiring";
+    Port80HandlerEvents["MANAGER_STARTED"] = "manager-started";
+    Port80HandlerEvents["MANAGER_STOPPED"] = "manager-stopped";
+    Port80HandlerEvents["REQUEST_FORWARDED"] = "request-forwarded";
+})(Port80HandlerEvents || (Port80HandlerEvents = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLXR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvY29yZS9tb2RlbHMvY29tbW9uLXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFtQzVDOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksbUJBUVg7QUFSRCxXQUFZLG1CQUFtQjtJQUM3QixnRUFBeUMsQ0FBQTtJQUN6QyxrRUFBMkMsQ0FBQTtJQUMzQyxnRUFBeUMsQ0FBQTtJQUN6QyxvRUFBNkMsQ0FBQTtJQUM3QywwREFBbUMsQ0FBQTtJQUNuQywwREFBbUMsQ0FBQTtJQUNuQyw4REFBdUMsQ0FBQTtBQUN6QyxDQUFDLEVBUlcsbUJBQW1CLEtBQW5CLG1CQUFtQixRQVE5QiJ9

package/dist_ts/core/models/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Core data models and interfaces
+ */
+export * from './common-types.js';

package/dist_ts/core/models/index.js

@@ -0,0 +1,5 @@
+/**
+ * Core data models and interfaces
+ */
+export * from './common-types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsbUJBQW1CLENBQUMifQ==

package/dist_ts/core/utils/event-utils.d.ts

@@ -0,0 +1,15 @@
+import type { Port80Handler } from '../../http/port80/port80-handler.js';
+import type { ICertificateData, ICertificateFailure, ICertificateExpiring } from '../models/common-types.js';
+/**
+ * Subscribers callback definitions for Port80Handler events
+ */
+export interface IPort80HandlerSubscribers {
+    onCertificateIssued?: (data: ICertificateData) => void;
+    onCertificateRenewed?: (data: ICertificateData) => void;
+    onCertificateFailed?: (data: ICertificateFailure) => void;
+    onCertificateExpiring?: (data: ICertificateExpiring) => void;
+}
+/**
+ * Subscribes to Port80Handler events based on provided callbacks
+ */
+export declare function subscribeToPort80Handler(handler: Port80Handler, subscribers: IPort80HandlerSubscribers): void;

package/dist_ts/core/utils/event-utils.js

@@ -0,0 +1,19 @@
+import { Port80HandlerEvents } from '../models/common-types.js';
+/**
+ * Subscribes to Port80Handler events based on provided callbacks
+ */
+export function subscribeToPort80Handler(handler, subscribers) {
+    if (subscribers.onCertificateIssued) {
+        handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, subscribers.onCertificateIssued);
+    }
+    if (subscribers.onCertificateRenewed) {
+        handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, subscribers.onCertificateRenewed);
+    }
+    if (subscribers.onCertificateFailed) {
+        handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, subscribers.onCertificateFailed);
+    }
+    if (subscribers.onCertificateExpiring) {
+        handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, subscribers.onCertificateExpiring);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3V0aWxzL2V2ZW50LXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBYWhFOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHdCQUF3QixDQUN0QyxPQUFzQixFQUN0QixXQUFzQztJQUV0QyxJQUFJLFdBQVcsQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO1FBQ3BDLE9BQU8sQ0FBQyxFQUFFLENBQUMsbUJBQW1CLENBQUMsa0JBQWtCLEVBQUUsV0FBVyxDQUFDLG1CQUFtQixDQUFDLENBQUM7SUFDdEYsQ0FBQztJQUNELElBQUksV0FBVyxDQUFDLG9CQUFvQixFQUFFLENBQUM7UUFDckMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQyxtQkFBbUIsRUFBRSxXQUFXLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUN4RixDQUFDO0lBQ0QsSUFBSSxXQUFXLENBQUMsbUJBQW1CLEVBQUUsQ0FBQztRQUNwQyxPQUFPLENBQUMsRUFBRSxDQUFDLG1CQUFtQixDQUFDLGtCQUFrQixFQUFFLFdBQVcsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO0lBQ3RGLENBQUM7SUFDRCxJQUFJLFdBQVcsQ0FBQyxxQkFBcUIsRUFBRSxDQUFDO1FBQ3RDLE9BQU8sQ0FBQyxFQUFFLENBQUMsbUJBQW1CLENBQUMsb0JBQW9CLEVBQUUsV0FBVyxDQUFDLHFCQUFxQixDQUFDLENBQUM7SUFDMUYsQ0FBQztBQUNILENBQUMifQ==

package/dist_ts/core/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core utility functions
+ */
+export * from './event-utils.js';
+export * from './validation-utils.js';
+export * from './ip-utils.js';

package/dist_ts/core/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * Core utility functions
+ */
+export * from './event-utils.js';
+export * from './validation-utils.js';
+export * from './ip-utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZUFBZSxDQUFDIn0=

package/dist_ts/core/utils/ip-utils.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Utility class for IP address operations
+ */
+export declare class IpUtils {
+    /**
+     * Check if the IP matches any of the glob patterns
+     *
+     * This method checks IP addresses against glob patterns and handles IPv4/IPv6 normalization.
+     * It's used to implement IP filtering based on security configurations.
+     *
+     * @param ip - The IP address to check
+     * @param patterns - Array of glob patterns
+     * @returns true if IP matches any pattern, false otherwise
+     */
+    static isGlobIPMatch(ip: string, patterns: string[]): boolean;
+    /**
+     * Normalize IP addresses for consistent comparison
+     *
+     * @param ip The IP address to normalize
+     * @returns Array of normalized IP forms
+     */
+    static normalizeIP(ip: string): string[];
+    /**
+     * Check if an IP is authorized using security rules
+     *
+     * @param ip - The IP address to check
+     * @param allowedIPs - Array of allowed IP patterns
+     * @param blockedIPs - Array of blocked IP patterns
+     * @returns true if IP is authorized, false if blocked
+     */
+    static isIPAuthorized(ip: string, allowedIPs?: string[], blockedIPs?: string[]): boolean;
+    /**
+     * Check if an IP address is a private network address
+     *
+     * @param ip The IP address to check
+     * @returns true if the IP is a private network address, false otherwise
+     */
+    static isPrivateIP(ip: string): boolean;
+    /**
+     * Check if an IP address is a public network address
+     *
+     * @param ip The IP address to check
+     * @returns true if the IP is a public network address, false otherwise
+     */
+    static isPublicIP(ip: string): boolean;
+    /**
+     * Convert a subnet CIDR to an IP range for filtering
+     *
+     * @param cidr The CIDR notation (e.g., "192.168.1.0/24")
+     * @returns Array of glob patterns that match the CIDR range
+     */
+    static cidrToGlobPatterns(cidr: string): string[];
+}

package/dist_ts/core/utils/ip-utils.js

@@ -0,0 +1,153 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Utility class for IP address operations
+ */
+export class IpUtils {
+    /**
+     * Check if the IP matches any of the glob patterns
+     *
+     * This method checks IP addresses against glob patterns and handles IPv4/IPv6 normalization.
+     * It's used to implement IP filtering based on security configurations.
+     *
+     * @param ip - The IP address to check
+     * @param patterns - Array of glob patterns
+     * @returns true if IP matches any pattern, false otherwise
+     */
+    static isGlobIPMatch(ip, patterns) {
+        if (!ip || !patterns || patterns.length === 0)
+            return false;
+        // Normalize the IP being checked
+        const normalizedIPVariants = this.normalizeIP(ip);
+        if (normalizedIPVariants.length === 0)
+            return false;
+        // Normalize the pattern IPs for consistent comparison
+        const expandedPatterns = patterns.flatMap(pattern => this.normalizeIP(pattern));
+        // Check for any match between normalized IP variants and patterns
+        return normalizedIPVariants.some((ipVariant) => expandedPatterns.some((pattern) => plugins.minimatch(ipVariant, pattern)));
+    }
+    /**
+     * Normalize IP addresses for consistent comparison
+     *
+     * @param ip The IP address to normalize
+     * @returns Array of normalized IP forms
+     */
+    static normalizeIP(ip) {
+        if (!ip)
+            return [];
+        // Handle IPv4-mapped IPv6 addresses (::ffff:127.0.0.1)
+        if (ip.startsWith('::ffff:')) {
+            const ipv4 = ip.slice(7);
+            return [ip, ipv4];
+        }
+        // Handle IPv4 addresses by also checking IPv4-mapped form
+        if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
+            return [ip, `::ffff:${ip}`];
+        }
+        return [ip];
+    }
+    /**
+     * Check if an IP is authorized using security rules
+     *
+     * @param ip - The IP address to check
+     * @param allowedIPs - Array of allowed IP patterns
+     * @param blockedIPs - Array of blocked IP patterns
+     * @returns true if IP is authorized, false if blocked
+     */
+    static isIPAuthorized(ip, allowedIPs = [], blockedIPs = []) {
+        // Skip IP validation if no rules are defined
+        if (!ip || (allowedIPs.length === 0 && blockedIPs.length === 0)) {
+            return true;
+        }
+        // First check if IP is blocked - blocked IPs take precedence
+        if (blockedIPs.length > 0 && this.isGlobIPMatch(ip, blockedIPs)) {
+            return false;
+        }
+        // Then check if IP is allowed (if no allowed IPs are specified, all non-blocked IPs are allowed)
+        return allowedIPs.length === 0 || this.isGlobIPMatch(ip, allowedIPs);
+    }
+    /**
+     * Check if an IP address is a private network address
+     *
+     * @param ip The IP address to check
+     * @returns true if the IP is a private network address, false otherwise
+     */
+    static isPrivateIP(ip) {
+        if (!ip)
+            return false;
+        // Handle IPv4-mapped IPv6 addresses
+        if (ip.startsWith('::ffff:')) {
+            ip = ip.slice(7);
+        }
+        // Check IPv4 private ranges
+        if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
+            const parts = ip.split('.').map(Number);
+            // Check common private ranges
+            // 10.0.0.0/8
+            if (parts[0] === 10)
+                return true;
+            // 172.16.0.0/12
+            if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31)
+                return true;
+            // 192.168.0.0/16
+            if (parts[0] === 192 && parts[1] === 168)
+                return true;
+            // 127.0.0.0/8 (localhost)
+            if (parts[0] === 127)
+                return true;
+            return false;
+        }
+        // IPv6 local addresses
+        return ip === '::1' || ip.startsWith('fc00:') || ip.startsWith('fd00:') || ip.startsWith('fe80:');
+    }
+    /**
+     * Check if an IP address is a public network address
+     *
+     * @param ip The IP address to check
+     * @returns true if the IP is a public network address, false otherwise
+     */
+    static isPublicIP(ip) {
+        return !this.isPrivateIP(ip);
+    }
+    /**
+     * Convert a subnet CIDR to an IP range for filtering
+     *
+     * @param cidr The CIDR notation (e.g., "192.168.1.0/24")
+     * @returns Array of glob patterns that match the CIDR range
+     */
+    static cidrToGlobPatterns(cidr) {
+        if (!cidr || !cidr.includes('/'))
+            return [];
+        const [ipPart, prefixPart] = cidr.split('/');
+        const prefix = parseInt(prefixPart, 10);
+        if (isNaN(prefix) || prefix < 0 || prefix > 32)
+            return [];
+        // For IPv4 only for now
+        if (!/^\d{1,3}(\.\d{1,3}){3}$/.test(ipPart))
+            return [];
+        const ipParts = ipPart.split('.').map(Number);
+        const fullMask = Math.pow(2, 32 - prefix) - 1;
+        // Convert IP to a numeric value
+        const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
+        // Calculate network address (IP & ~fullMask)
+        const networkNum = ipNum & ~fullMask;
+        // For large ranges, return wildcard patterns
+        if (prefix <= 8) {
+            return [`${(networkNum >>> 24) & 255}.*.*.*`];
+        }
+        else if (prefix <= 16) {
+            return [`${(networkNum >>> 24) & 255}.${(networkNum >>> 16) & 255}.*.*`];
+        }
+        else if (prefix <= 24) {
+            return [`${(networkNum >>> 24) & 255}.${(networkNum >>> 16) & 255}.${(networkNum >>> 8) & 255}.*`];
+        }
+        // For small ranges, create individual IP patterns
+        const patterns = [];
+        const maxAddresses = Math.min(256, Math.pow(2, 32 - prefix));
+        for (let i = 0; i < maxAddresses; i++) {
+            const currentIpNum = networkNum + i;
+            patterns.push(`${(currentIpNum >>> 24) & 255}.${(currentIpNum >>> 16) & 255}.${(currentIpNum >>> 8) & 255}.${currentIpNum & 255}`);
+        }
+        return patterns;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/utils/validation-utils.d.ts

@@ -0,0 +1,61 @@
+import type { IDomainOptions, IAcmeOptions } from '../models/common-types.js';
+/**
+ * Collection of validation utilities for configuration and domain options
+ */
+export declare class ValidationUtils {
+    /**
+     * Validates domain configuration options
+     *
+     * @param domainOptions The domain options to validate
+     * @returns An object with validation result and error message if invalid
+     */
+    static validateDomainOptions(domainOptions: IDomainOptions): {
+        isValid: boolean;
+        error?: string;
+    };
+    /**
+     * Validates ACME configuration options
+     *
+     * @param acmeOptions The ACME options to validate
+     * @returns An object with validation result and error message if invalid
+     */
+    static validateAcmeOptions(acmeOptions: IAcmeOptions): {
+        isValid: boolean;
+        error?: string;
+    };
+    /**
+     * Validates a port number
+     *
+     * @param port The port to validate
+     * @returns true if the port is valid, false otherwise
+     */
+    static isValidPort(port: number): boolean;
+    /**
+     * Validates a domain name
+     *
+     * @param domain The domain name to validate
+     * @returns true if the domain name is valid, false otherwise
+     */
+    static isValidDomainName(domain: string): boolean;
+    /**
+     * Validates an email address
+     *
+     * @param email The email to validate
+     * @returns true if the email is valid, false otherwise
+     */
+    static isValidEmail(email: string): boolean;
+    /**
+     * Validates a certificate format (PEM)
+     *
+     * @param cert The certificate content to validate
+     * @returns true if the certificate appears to be in PEM format, false otherwise
+     */
+    static isValidCertificate(cert: string): boolean;
+    /**
+     * Validates a private key format (PEM)
+     *
+     * @param key The private key content to validate
+     * @returns true if the key appears to be in PEM format, false otherwise
+     */
+    static isValidPrivateKey(key: string): boolean;
+}

package/dist_ts/core/utils/validation-utils.js

@@ -0,0 +1,149 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Collection of validation utilities for configuration and domain options
+ */
+export class ValidationUtils {
+    /**
+     * Validates domain configuration options
+     *
+     * @param domainOptions The domain options to validate
+     * @returns An object with validation result and error message if invalid
+     */
+    static validateDomainOptions(domainOptions) {
+        if (!domainOptions) {
+            return { isValid: false, error: 'Domain options cannot be null or undefined' };
+        }
+        if (!domainOptions.domainName) {
+            return { isValid: false, error: 'Domain name is required' };
+        }
+        // Check domain pattern
+        if (!this.isValidDomainName(domainOptions.domainName)) {
+            return { isValid: false, error: `Invalid domain name: ${domainOptions.domainName}` };
+        }
+        // Validate forward config if provided
+        if (domainOptions.forward) {
+            if (!domainOptions.forward.ip) {
+                return { isValid: false, error: 'Forward IP is required when forward is specified' };
+            }
+            if (!domainOptions.forward.port) {
+                return { isValid: false, error: 'Forward port is required when forward is specified' };
+            }
+            if (!this.isValidPort(domainOptions.forward.port)) {
+                return { isValid: false, error: `Invalid forward port: ${domainOptions.forward.port}` };
+            }
+        }
+        // Validate ACME forward config if provided
+        if (domainOptions.acmeForward) {
+            if (!domainOptions.acmeForward.ip) {
+                return { isValid: false, error: 'ACME forward IP is required when acmeForward is specified' };
+            }
+            if (!domainOptions.acmeForward.port) {
+                return { isValid: false, error: 'ACME forward port is required when acmeForward is specified' };
+            }
+            if (!this.isValidPort(domainOptions.acmeForward.port)) {
+                return { isValid: false, error: `Invalid ACME forward port: ${domainOptions.acmeForward.port}` };
+            }
+        }
+        return { isValid: true };
+    }
+    /**
+     * Validates ACME configuration options
+     *
+     * @param acmeOptions The ACME options to validate
+     * @returns An object with validation result and error message if invalid
+     */
+    static validateAcmeOptions(acmeOptions) {
+        if (!acmeOptions) {
+            return { isValid: false, error: 'ACME options cannot be null or undefined' };
+        }
+        if (acmeOptions.enabled) {
+            if (!acmeOptions.accountEmail) {
+                return { isValid: false, error: 'Account email is required when ACME is enabled' };
+            }
+            if (!this.isValidEmail(acmeOptions.accountEmail)) {
+                return { isValid: false, error: `Invalid email: ${acmeOptions.accountEmail}` };
+            }
+            if (acmeOptions.port && !this.isValidPort(acmeOptions.port)) {
+                return { isValid: false, error: `Invalid ACME port: ${acmeOptions.port}` };
+            }
+            if (acmeOptions.httpsRedirectPort && !this.isValidPort(acmeOptions.httpsRedirectPort)) {
+                return { isValid: false, error: `Invalid HTTPS redirect port: ${acmeOptions.httpsRedirectPort}` };
+            }
+            if (acmeOptions.renewThresholdDays && acmeOptions.renewThresholdDays < 1) {
+                return { isValid: false, error: 'Renew threshold days must be greater than 0' };
+            }
+            if (acmeOptions.renewCheckIntervalHours && acmeOptions.renewCheckIntervalHours < 1) {
+                return { isValid: false, error: 'Renew check interval hours must be greater than 0' };
+            }
+        }
+        return { isValid: true };
+    }
+    /**
+     * Validates a port number
+     *
+     * @param port The port to validate
+     * @returns true if the port is valid, false otherwise
+     */
+    static isValidPort(port) {
+        return typeof port === 'number' && port > 0 && port <= 65535 && Number.isInteger(port);
+    }
+    /**
+     * Validates a domain name
+     *
+     * @param domain The domain name to validate
+     * @returns true if the domain name is valid, false otherwise
+     */
+    static isValidDomainName(domain) {
+        if (!domain || typeof domain !== 'string') {
+            return false;
+        }
+        // Wildcard domain check (*.example.com)
+        if (domain.startsWith('*.')) {
+            domain = domain.substring(2);
+        }
+        // Simple domain validation pattern
+        const domainPattern = /^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+        return domainPattern.test(domain);
+    }
+    /**
+     * Validates an email address
+     *
+     * @param email The email to validate
+     * @returns true if the email is valid, false otherwise
+     */
+    static isValidEmail(email) {
+        if (!email || typeof email !== 'string') {
+            return false;
+        }
+        // Basic email validation pattern
+        const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailPattern.test(email);
+    }
+    /**
+     * Validates a certificate format (PEM)
+     *
+     * @param cert The certificate content to validate
+     * @returns true if the certificate appears to be in PEM format, false otherwise
+     */
+    static isValidCertificate(cert) {
+        if (!cert || typeof cert !== 'string') {
+            return false;
+        }
+        return cert.includes('-----BEGIN CERTIFICATE-----') &&
+            cert.includes('-----END CERTIFICATE-----');
+    }
+    /**
+     * Validates a private key format (PEM)
+     *
+     * @param key The private key content to validate
+     * @returns true if the key appears to be in PEM format, false otherwise
+     */
+    static isValidPrivateKey(key) {
+        if (!key || typeof key !== 'string') {
+            return false;
+        }
+        return key.includes('-----BEGIN PRIVATE KEY-----') &&
+            key.includes('-----END PRIVATE KEY-----');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/forwarding/config/domain-config.d.ts

@@ -0,0 +1,12 @@
+import type { IForwardConfig } from './forwarding-types.js';
+/**
+ * Domain configuration with unified forwarding configuration
+ */
+export interface IDomainConfig {
+    domains: string[];
+    forwarding: IForwardConfig;
+}
+/**
+ * Helper function to create a domain configuration
+ */
+export declare function createDomainConfig(domains: string | string[], forwarding: IForwardConfig): IDomainConfig;

package/dist_ts/forwarding/config/domain-config.js

@@ -0,0 +1,12 @@
+/**
+ * Helper function to create a domain configuration
+ */
+export function createDomainConfig(domains, forwarding) {
+    // Normalize domains to an array
+    const domainArray = Array.isArray(domains) ? domains : [domains];
+    return {
+        domains: domainArray,
+        forwarding
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9tYWluLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ZvcndhcmRpbmcvY29uZmlnL2RvbWFpbi1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBYUE7O0dBRUc7QUFDSCxNQUFNLFVBQVUsa0JBQWtCLENBQ2hDLE9BQTBCLEVBQzFCLFVBQTBCO0lBRTFCLGdDQUFnQztJQUNoQyxNQUFNLFdBQVcsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFakUsT0FBTztRQUNMLE9BQU8sRUFBRSxXQUFXO1FBQ3BCLFVBQVU7S0FDWCxDQUFDO0FBQ0osQ0FBQyJ9