@push.rocks/smartproxy 15.0.2 → 16.0.3

package/dist_ts/proxies/smart-proxy/smart-proxy.js

@@ -2,11 +2,10 @@ import * as plugins from '../../plugins.js';
 // Importing required components
 import { ConnectionManager } from './connection-manager.js';
 import { SecurityManager } from './security-manager.js';
-import { DomainConfigManager } from './domain-config-manager.js';
 import { TlsManager } from './tls-manager.js';
 import { NetworkProxyBridge } from './network-proxy-bridge.js';
 import { TimeoutManager } from './timeout-manager.js';
-import { PortRangeManager } from './port-range-manager.js';
+import { PortManager } from './port-manager.js';
 import { RouteManager } from './route-manager.js';
 import { RouteConnectionHandler } from './route-connection-handler.js';
 // External dependencies
@@ -16,15 +15,52 @@ import { buildPort80Handler } from '../../certificate/acme/acme-factory.js';
 import { createPort80HandlerOptions } from '../../common/port80-adapter.js';
 import { isRoutedOptions, isLegacyOptions } from './models/interfaces.js';
 /**
- * SmartProxy - Unified route-based API
+ * 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 class SmartProxy extends plugins.EventEmitter {
     /**
-     * Constructor that supports both legacy and route-based configuration
+     * 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: { allowedIps: ['*'] }
+     *   }
+     * });
+     * ```
      */
     constructor(settingsArg) {
         super();
-        this.netServers = [];
         this.connectionLogger = null;
         this.isShuttingDown = false;
         // Port80Handler for ACME certificate management
@@ -67,29 +103,24 @@ export class SmartProxy extends plugins.EventEmitter {
                 autoRenew: true,
                 certificateStore: './certs',
                 skipConfiguredCerts: false,
-                httpsRedirectPort: this.settings.fromPort || 443,
+                httpsRedirectPort: 443,
                 renewCheckIntervalHours: 24,
-                domainForwards: []
+                routeForwards: []
             };
         }
         // Initialize component managers
         this.timeoutManager = new TimeoutManager(this.settings);
         this.securityManager = new SecurityManager(this.settings);
         this.connectionManager = new ConnectionManager(this.settings, this.securityManager, this.timeoutManager);
-        // Create the new route manager first
+        // Create the route manager
         this.routeManager = new RouteManager(this.settings);
-        // Create domain config manager and port range manager
-        this.domainConfigManager = new DomainConfigManager(this.settings);
-        // Share the route manager with the domain config manager
-        if (typeof this.domainConfigManager.setRouteManager === 'function') {
-            this.domainConfigManager.setRouteManager(this.routeManager);
-        }
-        this.portRangeManager = new PortRangeManager(this.settings);
         // Create other required components
         this.tlsManager = new TlsManager(this.settings);
         this.networkProxyBridge = new NetworkProxyBridge(this.settings);
         // Initialize connection handler with route support
-        this.routeConnectionHandler = new RouteConnectionHandler(this.settings, this.connectionManager, this.securityManager, this.domainConfigManager, this.tlsManager, this.networkProxyBridge, this.timeoutManager, this.routeManager);
+        this.routeConnectionHandler = new RouteConnectionHandler(this.settings, this.connectionManager, this.securityManager, this.tlsManager, this.networkProxyBridge, this.timeoutManager, this.routeManager);
+        // Initialize port manager
+        this.portManager = new PortManager(this.settings, this.routeConnectionHandler);
     }
     /**
      * Initialize the Port80Handler for ACME certificate management
@@ -104,7 +135,7 @@ export class SmartProxy extends plugins.EventEmitter {
             // Build and start the Port80Handler
             this.port80Handler = buildPort80Handler({
                 ...config,
-                httpsRedirectPort: config.httpsRedirectPort || (isLegacyOptions(this.settings) ? this.settings.fromPort : 443)
+                httpsRedirectPort: config.httpsRedirectPort || 443
             });
             // Share Port80Handler with NetworkProxyBridge before start
             this.networkProxyBridge.setPort80Handler(this.port80Handler);
@@ -124,72 +155,18 @@ export class SmartProxy extends plugins.EventEmitter {
             console.log("Cannot start SmartProxy while it's shutting down");
             return;
         }
-        // Initialize domain config based on configuration type
-        if (isLegacyOptions(this.settings)) {
-            // Initialize domain config manager with the legacy domain configs
-            this.domainConfigManager.updateDomainConfigs(this.settings.domainConfigs || []);
-        }
-        else if (isRoutedOptions(this.settings)) {
-            // For pure route-based configuration, the domain config is already initialized
-            // in the constructor, but we might need to regenerate it
-            if (typeof this.domainConfigManager.generateDomainConfigsFromRoutes === 'function') {
-                this.domainConfigManager.generateDomainConfigsFromRoutes();
-            }
-        }
+        // Pure route-based configuration - no domain configs needed
         // Initialize Port80Handler if enabled
         await this.initializePort80Handler();
         // Initialize CertProvisioner for unified certificate workflows
         if (this.port80Handler) {
             const acme = this.settings.acme;
-            // Setup domain forwards based on configuration type
-            const domainForwards = acme.domainForwards?.map(f => {
-                if (isLegacyOptions(this.settings)) {
-                    // If using legacy mode, check if domain config exists
-                    const domainConfig = this.settings.domainConfigs.find(dc => dc.domains.some(d => d === f.domain));
-                    if (domainConfig?.forwarding) {
-                        return {
-                            domain: f.domain,
-                            forwardConfig: f.forwardConfig,
-                            acmeForwardConfig: f.acmeForwardConfig,
-                            sslRedirect: f.sslRedirect || domainConfig.forwarding.http?.redirectToHttps || false
-                        };
-                    }
-                }
-                else {
-                    // In route mode, look for matching route
-                    const route = this.routeManager.findMatchingRoute({
-                        port: 443,
-                        domain: f.domain,
-                        clientIp: '127.0.0.1' // Dummy IP for finding routes
-                    })?.route;
-                    if (route && route.action.type === 'forward' && route.action.tls) {
-                        // If we found a matching route with TLS settings
-                        return {
-                            domain: f.domain,
-                            forwardConfig: f.forwardConfig,
-                            acmeForwardConfig: f.acmeForwardConfig,
-                            sslRedirect: f.sslRedirect || false
-                        };
-                    }
-                }
-                // Otherwise use the existing configuration
-                return {
-                    domain: f.domain,
-                    forwardConfig: f.forwardConfig,
-                    acmeForwardConfig: f.acmeForwardConfig,
-                    sslRedirect: f.sslRedirect || false
-                };
-            }) || [];
+            // Setup route forwards
+            const routeForwards = acme.routeForwards?.map(f => f) || [];
             // Create CertProvisioner with appropriate parameters
-            if (isLegacyOptions(this.settings)) {
-                this.certProvisioner = new CertProvisioner(this.settings.domainConfigs, this.port80Handler, this.networkProxyBridge, this.settings.certProvisionFunction, acme.renewThresholdDays, acme.renewCheckIntervalHours, acme.autoRenew, domainForwards);
-            }
-            else {
-                // For route-based configuration, we need to adapt the interface
-                // Convert routes to domain configs for CertProvisioner
-                const domainConfigs = this.extractDomainConfigsFromRoutes(this.settings.routes);
-                this.certProvisioner = new CertProvisioner(domainConfigs, this.port80Handler, this.networkProxyBridge, this.settings.certProvisionFunction, acme.renewThresholdDays, acme.renewCheckIntervalHours, acme.autoRenew, domainForwards);
-            }
+            // No longer need to support multiple configuration types
+            // Just pass the routes directly
+            this.certProvisioner = new CertProvisioner(this.settings.routes, this.port80Handler, this.networkProxyBridge, this.settings.certProvisionFunction, acme.renewThresholdDays, acme.renewCheckIntervalHours, acme.autoRenew, routeForwards);
             // Register certificate event handler
             this.certProvisioner.on('certificate', (certData) => {
                 this.emit('certificate', {
@@ -219,28 +196,8 @@ export class SmartProxy extends plugins.EventEmitter {
         }
         // Get listening ports from RouteManager
         const listeningPorts = this.routeManager.getListeningPorts();
-        // Create servers for each port
-        for (const port of listeningPorts) {
-            const server = plugins.net.createServer((socket) => {
-                // Check if shutting down
-                if (this.isShuttingDown) {
-                    socket.end();
-                    socket.destroy();
-                    return;
-                }
-                // Delegate to route connection handler
-                this.routeConnectionHandler.handleConnection(socket);
-            }).on('error', (err) => {
-                console.log(`Server Error on port ${port}: ${err.message}`);
-            });
-            server.listen(port, () => {
-                const isNetworkProxyPort = this.settings.useNetworkProxy?.includes(port);
-                console.log(`SmartProxy -> OK: Now listening on port ${port}${isLegacyOptions(this.settings) && this.settings.sniEnabled && !isNetworkProxyPort ?
-                    ' (SNI passthrough enabled)' :
-                    ''}${isNetworkProxyPort ? ' (NetworkProxy forwarding enabled)' : ''}`);
-            });
-            this.netServers.push(server);
-        }
+        // Start port listeners using the PortManager
+        await this.portManager.addPorts(listeningPorts);
         // Set up periodic connection logging and inactivity checks
         this.connectionLogger = setInterval(() => {
             // Immediately return if shutting down
@@ -305,61 +262,16 @@ export class SmartProxy extends plugins.EventEmitter {
     }
     /**
      * Extract domain configurations from routes for certificate provisioning
+     *
+     * Note: This method has been removed as we now work directly with routes
      */
-    extractDomainConfigsFromRoutes(routes) {
-        const domainConfigs = [];
-        for (const route of routes) {
-            // Skip routes without domain specs
-            if (!route.match.domains)
-                continue;
-            // Skip non-forward routes
-            if (route.action.type !== 'forward')
-                continue;
-            // Only process routes that need TLS termination (those with certificates)
-            if (!route.action.tls ||
-                route.action.tls.mode === 'passthrough' ||
-                !route.action.target)
-                continue;
-            const domains = Array.isArray(route.match.domains)
-                ? route.match.domains
-                : [route.match.domains];
-            // Determine forwarding type based on TLS mode
-            const forwardingType = route.action.tls.mode === 'terminate'
-                ? 'https-terminate-to-http'
-                : 'https-terminate-to-https';
-            // Create a forwarding config
-            const forwarding = {
-                type: forwardingType,
-                target: {
-                    host: Array.isArray(route.action.target.host)
-                        ? route.action.target.host[0]
-                        : route.action.target.host,
-                    port: route.action.target.port
-                },
-                // Add TLS settings
-                https: {
-                    customCert: route.action.tls.certificate !== 'auto'
-                        ? route.action.tls.certificate
-                        : undefined
-                },
-                // Add security settings if present
-                security: route.action.security,
-                // Add advanced settings if present
-                advanced: route.action.advanced
-            };
-            domainConfigs.push({
-                domains,
-                forwarding
-            });
-        }
-        return domainConfigs;
-    }
     /**
      * Stop the proxy server
      */
     async stop() {
         console.log('SmartProxy shutting down...');
         this.isShuttingDown = true;
+        this.portManager.setShuttingDown(true);
         // Stop CertProvisioner if active
         if (this.certProvisioner) {
             await this.certProvisioner.stop();
@@ -376,183 +288,112 @@ export class SmartProxy extends plugins.EventEmitter {
                 console.log(`Error stopping Port80Handler: ${err}`);
             }
         }
-        // Stop accepting new connections
-        const closeServerPromises = this.netServers.map((server) => new Promise((resolve) => {
-            if (!server.listening) {
-                resolve();
-                return;
-            }
-            server.close((err) => {
-                if (err) {
-                    console.log(`Error closing server: ${err.message}`);
-                }
-                resolve();
-            });
-        }));
         // Stop the connection logger
         if (this.connectionLogger) {
             clearInterval(this.connectionLogger);
             this.connectionLogger = null;
         }
-        // Wait for servers to close
-        await Promise.all(closeServerPromises);
+        // Stop all port listeners
+        await this.portManager.closeAll();
         console.log('All servers closed. Cleaning up active connections...');
         // Clean up all active connections
         this.connectionManager.clearConnections();
         // Stop NetworkProxy
         await this.networkProxyBridge.stop();
-        // Clear all servers
-        this.netServers = [];
         console.log('SmartProxy shutdown complete.');
     }
     /**
-     * Updates the domain configurations for the proxy (legacy support)
+     * Updates the domain configurations for the proxy
+     *
+     * Note: This legacy method has been removed. Use updateRoutes instead.
      */
-    async updateDomainConfigs(newDomainConfigs) {
-        console.log(`Updating domain configurations (${newDomainConfigs.length} configs)`);
-        // Update domain configs in DomainConfigManager (legacy)
-        this.domainConfigManager.updateDomainConfigs(newDomainConfigs);
-        // Also update the RouteManager with these domain configs
-        this.routeManager.updateFromDomainConfigs(newDomainConfigs);
-        // If NetworkProxy is initialized, resync the configurations
-        if (this.networkProxyBridge.getNetworkProxy()) {
-            await this.networkProxyBridge.syncDomainConfigsToNetworkProxy();
-        }
-        // If Port80Handler is running, provision certificates based on forwarding type
-        if (this.port80Handler && this.settings.acme?.enabled) {
-            for (const domainConfig of newDomainConfigs) {
-                // Skip certificate provisioning for http-only or passthrough configs that don't need certs
-                const forwardingType = this.domainConfigManager.getForwardingType(domainConfig);
-                const needsCertificate = forwardingType === 'https-terminate-to-http' ||
-                    forwardingType === 'https-terminate-to-https';
-                // Skip certificate provisioning if ACME is explicitly disabled for this domain
-                const acmeDisabled = domainConfig.forwarding.acme?.enabled === false;
-                if (!needsCertificate || acmeDisabled) {
-                    if (this.settings.enableDetailedLogging) {
-                        console.log(`Skipping certificate provisioning for ${domainConfig.domains.join(', ')} (${forwardingType})`);
-                    }
-                    continue;
-                }
-                for (const domain of domainConfig.domains) {
-                    const isWildcard = domain.includes('*');
-                    let provision = 'http01';
-                    // Check for ACME forwarding configuration in the domain
-                    const forwardAcmeChallenges = domainConfig.forwarding.acme?.forwardChallenges;
-                    if (this.settings.certProvisionFunction) {
-                        try {
-                            provision = await this.settings.certProvisionFunction(domain);
-                        }
-                        catch (err) {
-                            console.log(`certProvider error for ${domain}: ${err}`);
-                        }
-                    }
-                    else if (isWildcard) {
-                        console.warn(`Skipping wildcard domain without certProvisionFunction: ${domain}`);
-                        continue;
-                    }
-                    if (provision === 'http01') {
-                        if (isWildcard) {
-                            console.warn(`Skipping HTTP-01 for wildcard domain: ${domain}`);
-                            continue;
-                        }
-                        // Create Port80Handler options from the forwarding configuration
-                        const port80Config = createPort80HandlerOptions(domain, domainConfig.forwarding);
-                        this.port80Handler.addDomain(port80Config);
-                        console.log(`Registered domain ${domain} with Port80Handler for HTTP-01`);
-                    }
-                    else {
-                        // Static certificate (e.g., DNS-01 provisioned) supports wildcards
-                        const certObj = provision;
-                        const certData = {
-                            domain: certObj.domainName,
-                            certificate: certObj.publicKey,
-                            privateKey: certObj.privateKey,
-                            expiryDate: new Date(certObj.validUntil)
-                        };
-                        this.networkProxyBridge.applyExternalCertificate(certData);
-                        console.log(`Applied static certificate for ${domain} from certProvider`);
-                    }
-                }
-            }
-            console.log('Provisioned certificates for new domains');
-        }
+    async updateDomainConfigs() {
+        console.warn('Method updateDomainConfigs() is deprecated. Use updateRoutes() instead.');
+        throw new Error('updateDomainConfigs() is deprecated - use updateRoutes() instead');
     }
     /**
-     * Update routes with new configuration (new API)
+     * 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' }
+     *     }
+     *   }
+     * ]);
+     * ```
      */
     async updateRoutes(newRoutes) {
         console.log(`Updating routes (${newRoutes.length} routes)`);
         // Update routes in RouteManager
         this.routeManager.updateRoutes(newRoutes);
+        // Get the new set of required ports
+        const requiredPorts = this.routeManager.getListeningPorts();
+        // Update port listeners to match the new configuration
+        await this.portManager.updatePorts(requiredPorts);
         // If NetworkProxy is initialized, resync the configurations
         if (this.networkProxyBridge.getNetworkProxy()) {
-            // Create equivalent domain configs for NetworkProxy
-            const domainConfigs = this.extractDomainConfigsFromRoutes(newRoutes);
-            // Update domain configs in DomainConfigManager for sync
-            this.domainConfigManager.updateDomainConfigs(domainConfigs);
-            // Sync with NetworkProxy
-            await this.networkProxyBridge.syncDomainConfigsToNetworkProxy();
+            await this.networkProxyBridge.syncRoutesToNetworkProxy(newRoutes);
         }
         // If Port80Handler is running, provision certificates based on routes
         if (this.port80Handler && this.settings.acme?.enabled) {
-            for (const route of newRoutes) {
-                // Skip routes without domains
-                if (!route.match.domains)
-                    continue;
-                // Skip non-forward routes
-                if (route.action.type !== 'forward')
-                    continue;
-                // Skip routes without TLS termination
-                if (!route.action.tls ||
-                    route.action.tls.mode === 'passthrough' ||
-                    !route.action.target)
-                    continue;
-                // Skip certificate provisioning if certificate is not auto
-                if (route.action.tls.certificate !== 'auto')
-                    continue;
-                const domains = Array.isArray(route.match.domains)
-                    ? route.match.domains
-                    : [route.match.domains];
-                for (const domain of domains) {
-                    const isWildcard = domain.includes('*');
-                    let provision = 'http01';
-                    if (this.settings.certProvisionFunction) {
+            // Register all eligible domains from routes
+            this.port80Handler.addDomainsFromRoutes(newRoutes);
+            // Handle static certificates from certProvisionFunction if available
+            if (this.settings.certProvisionFunction) {
+                for (const route of newRoutes) {
+                    // Skip routes without domains
+                    if (!route.match.domains)
+                        continue;
+                    // Skip non-forward routes
+                    if (route.action.type !== 'forward')
+                        continue;
+                    // Skip routes without TLS termination
+                    if (!route.action.tls ||
+                        route.action.tls.mode === 'passthrough' ||
+                        !route.action.target)
+                        continue;
+                    // Skip certificate provisioning if certificate is not auto
+                    if (route.action.tls.certificate !== 'auto')
+                        continue;
+                    const domains = Array.isArray(route.match.domains)
+                        ? route.match.domains
+                        : [route.match.domains];
+                    for (const domain of domains) {
                         try {
-                            provision = await this.settings.certProvisionFunction(domain);
+                            const provision = await this.settings.certProvisionFunction(domain);
+                            // Skip http01 as those are handled by Port80Handler
+                            if (provision !== 'http01') {
+                                // Handle static certificate (e.g., DNS-01 provisioned)
+                                const certObj = provision;
+                                const certData = {
+                                    domain: certObj.domainName,
+                                    certificate: certObj.publicKey,
+                                    privateKey: certObj.privateKey,
+                                    expiryDate: new Date(certObj.validUntil),
+                                    routeReference: {
+                                        routeName: route.name
+                                    }
+                                };
+                                this.networkProxyBridge.applyExternalCertificate(certData);
+                                console.log(`Applied static certificate for ${domain} from certProvider`);
+                            }
                         }
                         catch (err) {
                             console.log(`certProvider error for ${domain}: ${err}`);
                         }
                     }
-                    else if (isWildcard) {
-                        console.warn(`Skipping wildcard domain without certProvisionFunction: ${domain}`);
-                        continue;
-                    }
-                    if (provision === 'http01') {
-                        if (isWildcard) {
-                            console.warn(`Skipping HTTP-01 for wildcard domain: ${domain}`);
-                            continue;
-                        }
-                        // Register domain with Port80Handler
-                        this.port80Handler.addDomain({
-                            domainName: domain,
-                            sslRedirect: true,
-                            acmeMaintenance: true
-                        });
-                        console.log(`Registered domain ${domain} with Port80Handler for HTTP-01`);
-                    }
-                    else {
-                        // Handle static certificate (e.g., DNS-01 provisioned)
-                        const certObj = provision;
-                        const certData = {
-                            domain: certObj.domainName,
-                            certificate: certObj.publicKey,
-                            privateKey: certObj.privateKey,
-                            expiryDate: new Date(certObj.validUntil)
-                        };
-                        this.networkProxyBridge.applyExternalCertificate(certData);
-                        console.log(`Applied static certificate for ${domain} from certProvider`);
-                    }
                 }
             }
             console.log('Provisioned certificates for new routes');
@@ -560,8 +401,11 @@ export class SmartProxy extends plugins.EventEmitter {
     }
     /**
      * 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
      */
-    async requestCertificate(domain) {
+    async requestCertificate(domain, routeName) {
         // Validate domain format
         if (!this.isValidDomain(domain)) {
             console.log(`Invalid domain format: ${domain}`);
@@ -578,11 +422,12 @@ export class SmartProxy extends plugins.EventEmitter {
                 }
                 // Register domain for certificate issuance
                 this.port80Handler.addDomain({
-                    domainName: domain,
+                    domain,
                     sslRedirect: true,
-                    acmeMaintenance: true
+                    acmeMaintenance: true,
+                    routeReference: routeName ? { routeName } : undefined
                 });
-                console.log(`Domain ${domain} registered for certificate issuance`);
+                console.log(`Domain ${domain} registered for certificate issuance` + (routeName ? ` for route '${routeName}'` : ''));
                 return true;
             }
             catch (err) {
@@ -614,6 +459,38 @@ export class SmartProxy extends plugins.EventEmitter {
         }
         return true;
     }
+    /**
+     * 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
+     */
+    async addListeningPort(port) {
+        return this.portManager.addPort(port);
+    }
+    /**
+     * 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
+     */
+    async removeListeningPort(port) {
+        return this.portManager.removePort(port);
+    }
+    /**
+     * Get a list of all ports currently being listened on
+     *
+     * @returns Array of port numbers
+     */
+    getListeningPorts() {
+        return this.portManager.getListeningPorts();
+    }
     /**
      * Get statistics about current connections
      */
@@ -644,7 +521,9 @@ export class SmartProxy extends plugins.EventEmitter {
             terminationStats,
             acmeEnabled: !!this.port80Handler,
             port80HandlerPort: this.port80Handler ? this.settings.acme?.port : null,
-            routes: this.routeManager.getListeningPorts().length
+            routes: this.routeManager.getListeningPorts().length,
+            listeningPorts: this.portManager.getListeningPorts(),
+            activePorts: this.portManager.getListeningPorts().length
         };
     }
     /**
@@ -670,14 +549,7 @@ export class SmartProxy extends plugins.EventEmitter {
             const eligibleDomains = routeDomains.filter(domain => !domain.includes('*') && this.isValidDomain(domain));
             domains.push(...eligibleDomains);
         }
-        // For legacy mode, also get domains from domain configs
-        if (isLegacyOptions(this.settings)) {
-            for (const config of this.settings.domainConfigs) {
-                // Skip domains that can't be used with ACME
-                const eligibleDomains = config.domains.filter(domain => !domain.includes('*') && this.isValidDomain(domain));
-                domains.push(...eligibleDomains);
-            }
-        }
+        // Legacy mode is no longer supported
         return domains;
     }
     /**
@@ -724,4 +596,4 @@ export class SmartProxy extends plugins.EventEmitter {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-proxy.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/smart-proxy.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-proxy.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/smart-proxy.ts"],"names":[],"mappings":"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"}