@push.rocks/smartproxy 19.3.2 → 19.3.3

package/dist_ts/proxies/smart-proxy/domain-config-manager.d.ts

@@ -1,110 +0,0 @@
-import type { IDomainConfig, ISmartProxyOptions } from './models/interfaces.js';
-import type { TForwardingType } from '../../forwarding/config/forwarding-types.js';
-import type { ForwardingHandler } from '../../forwarding/handlers/base-handler.js';
-import { RouteManager } from './route-manager.js';
-/**
- * Manages domain configurations and target selection
- */
-export declare class DomainConfigManager {
-    private settings;
-    private domainTargetIndices;
-    private forwardingHandlers;
-    private derivedDomainConfigs;
-    private routeManager?;
-    constructor(settings: ISmartProxyOptions);
-    /**
-     * Set the route manager reference for route-based queries
-     */
-    setRouteManager(routeManager: RouteManager): void;
-    /**
-     * Generate domain configs from routes
-     */
-    generateDomainConfigsFromRoutes(): void;
-    /**
-     * Convert a route to a domain config
-     */
-    private routeToDomainConfig;
-    /**
-     * Updates the domain configurations
-     */
-    updateDomainConfigs(newDomainConfigs: IDomainConfig[]): void;
-    /**
-     * Get all domain configurations
-     */
-    getDomainConfigs(): IDomainConfig[];
-    /**
-     * Find domain config matching a server name
-     */
-    findDomainConfig(serverName: string): IDomainConfig | undefined;
-    /**
-     * Find domain config for a specific port
-     */
-    findDomainConfigForPort(port: number): IDomainConfig | undefined;
-    /**
-     * Check if a port is within any of the given ranges
-     */
-    isPortInRanges(port: number, ranges: Array<{
-        from: number;
-        to: number;
-    }>): boolean;
-    /**
-     * Get target IP with round-robin support
-     */
-    getTargetIP(domainConfig: IDomainConfig): string;
-    /**
-     * Get target host with round-robin support (for tests)
-     * This is just an alias for getTargetIP for easier test compatibility
-     */
-    getTargetHost(domainConfig: IDomainConfig): string;
-    /**
-     * Get target port from domain config
-     */
-    getTargetPort(domainConfig: IDomainConfig, defaultPort: number): number;
-    /**
-     * Checks if a domain should use NetworkProxy
-     */
-    shouldUseNetworkProxy(domainConfig: IDomainConfig): boolean;
-    /**
-     * Gets the NetworkProxy port for a domain
-     */
-    getNetworkProxyPort(domainConfig: IDomainConfig): number | undefined;
-    /**
-     * Get effective allowed and blocked IPs for a domain
-     *
-     * This method combines domain-specific security rules from the forwarding configuration
-     * with global security defaults when necessary.
-     */
-    getEffectiveIPRules(domainConfig: IDomainConfig): {
-        allowedIPs: string[];
-        blockedIPs: string[];
-    };
-    /**
-     * Get connection timeout for a domain
-     */
-    getConnectionTimeout(domainConfig?: IDomainConfig): number;
-    /**
-     * Creates a forwarding handler for a domain configuration
-     */
-    private createForwardingHandler;
-    /**
-     * Gets a forwarding handler for a domain config
-     * If no handler exists, creates one
-     */
-    getForwardingHandler(domainConfig: IDomainConfig): ForwardingHandler;
-    /**
-     * Gets the forwarding type for a domain config
-     */
-    getForwardingType(domainConfig?: IDomainConfig): TForwardingType | undefined;
-    /**
-     * Checks if the forwarding type requires TLS termination
-     */
-    requiresTlsTermination(domainConfig?: IDomainConfig): boolean;
-    /**
-     * Checks if the forwarding type supports HTTP
-     */
-    supportsHttp(domainConfig?: IDomainConfig): boolean;
-    /**
-     * Checks if HTTP requests should be redirected to HTTPS
-     */
-    shouldRedirectToHttps(domainConfig?: IDomainConfig): boolean;
-}

package/dist_ts/proxies/smart-proxy/domain-config-manager.js

@@ -1,386 +0,0 @@
-import * as plugins from '../../plugins.js';
-import { ForwardingHandlerFactory } from '../../forwarding/factory/forwarding-factory.js';
-import { RouteManager } from './route-manager.js';
-/**
- * Manages domain configurations and target selection
- */
-export class DomainConfigManager {
-    constructor(settings) {
-        this.settings = settings;
-        // Track round-robin indices for domain configs
-        this.domainTargetIndices = new Map();
-        // Cache forwarding handlers for each domain config
-        this.forwardingHandlers = new Map();
-        // Store derived domain configs from routes
-        this.derivedDomainConfigs = [];
-        // Initialize with derived domain configs if using route-based configuration
-        if (settings.routes && !settings.domainConfigs) {
-            this.generateDomainConfigsFromRoutes();
-        }
-    }
-    /**
-     * Set the route manager reference for route-based queries
-     */
-    setRouteManager(routeManager) {
-        this.routeManager = routeManager;
-        // Regenerate domain configs from routes if needed
-        if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
-            this.generateDomainConfigsFromRoutes();
-        }
-    }
-    /**
-     * Generate domain configs from routes
-     */
-    generateDomainConfigsFromRoutes() {
-        this.derivedDomainConfigs = [];
-        if (!this.settings.routes)
-            return;
-        for (const route of this.settings.routes) {
-            if (route.action.type !== 'forward' || !route.match.domains)
-                continue;
-            // Convert route to domain config
-            const domainConfig = this.routeToDomainConfig(route);
-            if (domainConfig) {
-                this.derivedDomainConfigs.push(domainConfig);
-            }
-        }
-    }
-    /**
-     * Convert a route to a domain config
-     */
-    routeToDomainConfig(route) {
-        if (route.action.type !== 'forward' || !route.action.target)
-            return null;
-        // Get domains from route
-        const domains = Array.isArray(route.match.domains) ?
-            route.match.domains :
-            (route.match.domains ? [route.match.domains] : []);
-        if (domains.length === 0)
-            return null;
-        // Determine forwarding type based on TLS mode
-        let forwardingType = 'http-only';
-        if (route.action.tls) {
-            switch (route.action.tls.mode) {
-                case 'passthrough':
-                    forwardingType = 'https-passthrough';
-                    break;
-                case 'terminate':
-                    forwardingType = 'https-terminate-to-http';
-                    break;
-                case 'terminate-and-reencrypt':
-                    forwardingType = 'https-terminate-to-https';
-                    break;
-            }
-        }
-        // Create domain config
-        return {
-            domains,
-            forwarding: {
-                type: forwardingType,
-                target: {
-                    host: route.action.target.host,
-                    port: route.action.target.port
-                },
-                security: route.action.security ? {
-                    allowedIps: route.action.security.allowedIps,
-                    blockedIps: route.action.security.blockedIps,
-                    maxConnections: route.action.security.maxConnections
-                } : undefined,
-                https: route.action.tls && route.action.tls.certificate !== 'auto' ? {
-                    customCert: route.action.tls.certificate
-                } : undefined,
-                advanced: route.action.advanced
-            }
-        };
-    }
-    /**
-     * Updates the domain configurations
-     */
-    updateDomainConfigs(newDomainConfigs) {
-        // If we're using domainConfigs property, update it
-        if (this.settings.domainConfigs) {
-            this.settings.domainConfigs = newDomainConfigs;
-        }
-        else {
-            // Otherwise update our derived configs
-            this.derivedDomainConfigs = newDomainConfigs;
-        }
-        // Reset target indices for removed configs
-        const currentConfigSet = new Set(newDomainConfigs);
-        for (const [config] of this.domainTargetIndices) {
-            if (!currentConfigSet.has(config)) {
-                this.domainTargetIndices.delete(config);
-            }
-        }
-        // Clear handlers for removed configs and create handlers for new configs
-        const handlersToRemove = [];
-        for (const [config] of this.forwardingHandlers) {
-            if (!currentConfigSet.has(config)) {
-                handlersToRemove.push(config);
-            }
-        }
-        // Remove handlers that are no longer needed
-        for (const config of handlersToRemove) {
-            this.forwardingHandlers.delete(config);
-        }
-        // Create handlers for new configs
-        for (const config of newDomainConfigs) {
-            if (!this.forwardingHandlers.has(config)) {
-                try {
-                    const handler = this.createForwardingHandler(config);
-                    this.forwardingHandlers.set(config, handler);
-                }
-                catch (err) {
-                    console.log(`Error creating forwarding handler for domain ${config.domains.join(', ')}: ${err}`);
-                }
-            }
-        }
-    }
-    /**
-     * Get all domain configurations
-     */
-    getDomainConfigs() {
-        // Use domainConfigs from settings if available, otherwise use derived configs
-        return this.settings.domainConfigs || this.derivedDomainConfigs;
-    }
-    /**
-     * Find domain config matching a server name
-     */
-    findDomainConfig(serverName) {
-        if (!serverName)
-            return undefined;
-        // Get domain configs from the appropriate source
-        const domainConfigs = this.getDomainConfigs();
-        // Check for direct match
-        for (const config of domainConfigs) {
-            if (config.domains.some(d => plugins.minimatch(serverName, d))) {
-                return config;
-            }
-        }
-        // No match found
-        return undefined;
-    }
-    /**
-     * Find domain config for a specific port
-     */
-    findDomainConfigForPort(port) {
-        // Get domain configs from the appropriate source
-        const domainConfigs = this.getDomainConfigs();
-        // Check if any domain config has a matching port range
-        for (const domain of domainConfigs) {
-            const portRanges = domain.forwarding?.advanced?.portRanges;
-            if (portRanges && portRanges.length > 0 && this.isPortInRanges(port, portRanges)) {
-                return domain;
-            }
-        }
-        // If we're in route-based mode, also check routes for this port
-        if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
-            const routesForPort = this.settings.routes.filter(route => {
-                // Check if this port is in the route's ports
-                if (typeof route.match.ports === 'number') {
-                    return route.match.ports === port;
-                }
-                else if (Array.isArray(route.match.ports)) {
-                    return route.match.ports.some(p => {
-                        if (typeof p === 'number') {
-                            return p === port;
-                        }
-                        else if (p.from && p.to) {
-                            return port >= p.from && port <= p.to;
-                        }
-                        return false;
-                    });
-                }
-                return false;
-            });
-            // If we found any routes for this port, convert the first one to a domain config
-            if (routesForPort.length > 0 && routesForPort[0].action.type === 'forward') {
-                const domainConfig = this.routeToDomainConfig(routesForPort[0]);
-                if (domainConfig) {
-                    return domainConfig;
-                }
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Check if a port is within any of the given ranges
-     */
-    isPortInRanges(port, ranges) {
-        return ranges.some((range) => port >= range.from && port <= range.to);
-    }
-    /**
-     * Get target IP with round-robin support
-     */
-    getTargetIP(domainConfig) {
-        const targetHosts = Array.isArray(domainConfig.forwarding.target.host)
-            ? domainConfig.forwarding.target.host
-            : [domainConfig.forwarding.target.host];
-        if (targetHosts.length > 0) {
-            const currentIndex = this.domainTargetIndices.get(domainConfig) || 0;
-            const ip = targetHosts[currentIndex % targetHosts.length];
-            this.domainTargetIndices.set(domainConfig, currentIndex + 1);
-            return ip;
-        }
-        return this.settings.targetIP || 'localhost';
-    }
-    /**
-     * Get target host with round-robin support (for tests)
-     * This is just an alias for getTargetIP for easier test compatibility
-     */
-    getTargetHost(domainConfig) {
-        return this.getTargetIP(domainConfig);
-    }
-    /**
-     * Get target port from domain config
-     */
-    getTargetPort(domainConfig, defaultPort) {
-        return domainConfig.forwarding.target.port || defaultPort;
-    }
-    /**
-     * Checks if a domain should use NetworkProxy
-     */
-    shouldUseNetworkProxy(domainConfig) {
-        const forwardingType = this.getForwardingType(domainConfig);
-        return forwardingType === 'https-terminate-to-http' ||
-            forwardingType === 'https-terminate-to-https';
-    }
-    /**
-     * Gets the NetworkProxy port for a domain
-     */
-    getNetworkProxyPort(domainConfig) {
-        // First check if we should use NetworkProxy at all
-        if (!this.shouldUseNetworkProxy(domainConfig)) {
-            return undefined;
-        }
-        return domainConfig.forwarding.advanced?.networkProxyPort || this.settings.networkProxyPort;
-    }
-    /**
-     * Get effective allowed and blocked IPs for a domain
-     *
-     * This method combines domain-specific security rules from the forwarding configuration
-     * with global security defaults when necessary.
-     */
-    getEffectiveIPRules(domainConfig) {
-        // Start with empty arrays
-        const allowedIPs = [];
-        const blockedIPs = [];
-        // Add IPs from forwarding security settings if available
-        if (domainConfig.forwarding?.security?.allowedIps) {
-            allowedIPs.push(...domainConfig.forwarding.security.allowedIps);
-        }
-        else {
-            // If no allowed IPs are specified in forwarding config and global defaults exist, use them
-            if (this.settings.defaultAllowedIPs && this.settings.defaultAllowedIPs.length > 0) {
-                allowedIPs.push(...this.settings.defaultAllowedIPs);
-            }
-            else {
-                // Default to allow all if no specific rules
-                allowedIPs.push('*');
-            }
-        }
-        // Add blocked IPs from forwarding security settings if available
-        if (domainConfig.forwarding?.security?.blockedIps) {
-            blockedIPs.push(...domainConfig.forwarding.security.blockedIps);
-        }
-        // Always add global blocked IPs, even if domain has its own rules
-        // This ensures that global blocks take precedence
-        if (this.settings.defaultBlockedIPs && this.settings.defaultBlockedIPs.length > 0) {
-            // Add only unique IPs that aren't already in the list
-            for (const ip of this.settings.defaultBlockedIPs) {
-                if (!blockedIPs.includes(ip)) {
-                    blockedIPs.push(ip);
-                }
-            }
-        }
-        return {
-            allowedIPs,
-            blockedIPs
-        };
-    }
-    /**
-     * Get connection timeout for a domain
-     */
-    getConnectionTimeout(domainConfig) {
-        if (domainConfig?.forwarding.advanced?.timeout) {
-            return domainConfig.forwarding.advanced.timeout;
-        }
-        return this.settings.maxConnectionLifetime || 86400000; // 24 hours default
-    }
-    /**
-     * Creates a forwarding handler for a domain configuration
-     */
-    createForwardingHandler(domainConfig) {
-        // Create a new handler using the factory
-        const handler = ForwardingHandlerFactory.createHandler(domainConfig.forwarding);
-        // Initialize the handler
-        handler.initialize().catch(err => {
-            console.log(`Error initializing forwarding handler for ${domainConfig.domains.join(', ')}: ${err}`);
-        });
-        return handler;
-    }
-    /**
-     * Gets a forwarding handler for a domain config
-     * If no handler exists, creates one
-     */
-    getForwardingHandler(domainConfig) {
-        // If we already have a handler, return it
-        if (this.forwardingHandlers.has(domainConfig)) {
-            return this.forwardingHandlers.get(domainConfig);
-        }
-        // Otherwise create a new handler
-        const handler = this.createForwardingHandler(domainConfig);
-        this.forwardingHandlers.set(domainConfig, handler);
-        return handler;
-    }
-    /**
-     * Gets the forwarding type for a domain config
-     */
-    getForwardingType(domainConfig) {
-        if (!domainConfig?.forwarding)
-            return undefined;
-        return domainConfig.forwarding.type;
-    }
-    /**
-     * Checks if the forwarding type requires TLS termination
-     */
-    requiresTlsTermination(domainConfig) {
-        if (!domainConfig)
-            return false;
-        const forwardingType = this.getForwardingType(domainConfig);
-        return forwardingType === 'https-terminate-to-http' ||
-            forwardingType === 'https-terminate-to-https';
-    }
-    /**
-     * Checks if the forwarding type supports HTTP
-     */
-    supportsHttp(domainConfig) {
-        if (!domainConfig)
-            return false;
-        const forwardingType = this.getForwardingType(domainConfig);
-        // HTTP-only always supports HTTP
-        if (forwardingType === 'http-only')
-            return true;
-        // For termination types, check the HTTP settings
-        if (forwardingType === 'https-terminate-to-http' ||
-            forwardingType === 'https-terminate-to-https') {
-            // HTTP is supported by default for termination types
-            return domainConfig.forwarding?.http?.enabled !== false;
-        }
-        // HTTPS-passthrough doesn't support HTTP
-        return false;
-    }
-    /**
-     * Checks if HTTP requests should be redirected to HTTPS
-     */
-    shouldRedirectToHttps(domainConfig) {
-        if (!domainConfig?.forwarding)
-            return false;
-        // Only check for redirect if HTTP is enabled
-        if (this.supportsHttp(domainConfig)) {
-            return !!domainConfig.forwarding.http?.redirectToHttps;
-        }
-        return false;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"domain-config-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/domain-config-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/legacy-smart-proxy.d.ts

@@ -1,168 +0,0 @@
-import * as plugins from '../../plugins.js';
-import { RouteManager } from './route-manager.js';
-import type { ISmartProxyOptions } from './models/interfaces.js';
-import type { IRouteConfig } from './models/route-types.js';
-/**
- * SmartProxy - Pure route-based API
- *
- * SmartProxy is a unified proxy system that works with routes to define connection handling behavior.
- * Each route contains matching criteria (ports, domains, etc.) and an action to take (forward, redirect, block).
- *
- * Configuration is provided through a set of routes, with each route defining:
- * - What to match (ports, domains, paths, client IPs)
- * - What to do with matching traffic (forward, redirect, block)
- * - How to handle TLS (passthrough, terminate, terminate-and-reencrypt)
- * - Security settings (IP restrictions, connection limits)
- * - Advanced options (timeout, headers, etc.)
- */
-export declare class SmartProxy extends plugins.EventEmitter {
-    private portManager;
-    private connectionLogger;
-    private isShuttingDown;
-    private connectionManager;
-    private securityManager;
-    private tlsManager;
-    private networkProxyBridge;
-    private timeoutManager;
-    routeManager: RouteManager;
-    private routeConnectionHandler;
-    private nftablesManager;
-    private port80Handler;
-    private certProvisioner?;
-    /**
-     * Constructor for SmartProxy
-     *
-     * @param settingsArg Configuration options containing routes and other settings
-     * Routes define how traffic is matched and handled, with each route having:
-     * - match: criteria for matching traffic (ports, domains, paths, IPs)
-     * - action: what to do with matched traffic (forward, redirect, block)
-     *
-     * Example:
-     * ```ts
-     * const proxy = new SmartProxy({
-     *   routes: [
-     *     {
-     *       match: {
-     *         ports: 443,
-     *         domains: ['example.com', '*.example.com']
-     *       },
-     *       action: {
-     *         type: 'forward',
-     *         target: { host: '10.0.0.1', port: 8443 },
-     *         tls: { mode: 'passthrough' }
-     *       }
-     *     }
-     *   ],
-     *   defaults: {
-     *     target: { host: 'localhost', port: 8080 },
-     *     security: { ipAllowList: ['*'] }
-     *   }
-     * });
-     * ```
-     */
-    constructor(settingsArg: ISmartProxyOptions);
-    /**
-     * The settings for the SmartProxy
-     */
-    settings: ISmartProxyOptions;
-    /**
-     * Initialize the Port80Handler for ACME certificate management
-     */
-    private initializePort80Handler;
-    /**
-     * Start the proxy server with support for both configuration types
-     */
-    start(): Promise<void>;
-    /**
-     * Extract domain configurations from routes for certificate provisioning
-     *
-     * Note: This method has been removed as we now work directly with routes
-     */
-    /**
-     * Stop the proxy server
-     */
-    stop(): Promise<void>;
-    /**
-     * Updates the domain configurations for the proxy
-     *
-     * Note: This legacy method has been removed. Use updateRoutes instead.
-     */
-    updateDomainConfigs(): Promise<void>;
-    /**
-     * Update routes with new configuration
-     *
-     * This method replaces the current route configuration with the provided routes.
-     * It also provisions certificates for routes that require TLS termination and have
-     * `certificate: 'auto'` set in their TLS configuration.
-     *
-     * @param newRoutes Array of route configurations to use
-     *
-     * Example:
-     * ```ts
-     * proxy.updateRoutes([
-     *   {
-     *     match: { ports: 443, domains: 'secure.example.com' },
-     *     action: {
-     *       type: 'forward',
-     *       target: { host: '10.0.0.1', port: 8443 },
-     *       tls: { mode: 'terminate', certificate: 'auto' }
-     *     }
-     *   }
-     * ]);
-     * ```
-     */
-    updateRoutes(newRoutes: IRouteConfig[]): Promise<void>;
-    /**
-     * Request a certificate for a specific domain
-     *
-     * @param domain The domain to request a certificate for
-     * @param routeName Optional route name to associate with the certificate
-     */
-    requestCertificate(domain: string, routeName?: string): Promise<boolean>;
-    /**
-     * Validates if a domain name is valid for certificate issuance
-     */
-    private isValidDomain;
-    /**
-     * Add a new listening port without changing the route configuration
-     *
-     * This allows you to add a port listener without updating routes.
-     * Useful for preparing to listen on a port before adding routes for it.
-     *
-     * @param port The port to start listening on
-     * @returns Promise that resolves when the port is listening
-     */
-    addListeningPort(port: number): Promise<void>;
-    /**
-     * Stop listening on a specific port without changing the route configuration
-     *
-     * This allows you to stop a port listener without updating routes.
-     * Useful for temporary maintenance or port changes.
-     *
-     * @param port The port to stop listening on
-     * @returns Promise that resolves when the port is closed
-     */
-    removeListeningPort(port: number): Promise<void>;
-    /**
-     * Get a list of all ports currently being listened on
-     *
-     * @returns Array of port numbers
-     */
-    getListeningPorts(): number[];
-    /**
-     * Get statistics about current connections
-     */
-    getStatistics(): any;
-    /**
-     * Get a list of eligible domains for ACME certificates
-     */
-    getEligibleDomainsForCertificates(): string[];
-    /**
-     * Get NFTables status
-     */
-    getNfTablesStatus(): Promise<Record<string, any>>;
-    /**
-     * Get status of certificates managed by Port80Handler
-     */
-    getCertificateStatus(): any;
-}