@push.rocks/smartproxy 5.0.0 → 6.0.0

package/dist_ts/networkproxy/classes.np.networkproxy.d.ts

@@ -0,0 +1,117 @@
+import * as plugins from '../plugins.js';
+import { type INetworkProxyOptions, type IReverseProxyConfig } from './classes.np.types.js';
+import { type IMetricsTracker } from './classes.np.requesthandler.js';
+import { Port80Handler } from '../port80handler/classes.port80handler.js';
+/**
+ * NetworkProxy provides a reverse proxy with TLS termination, WebSocket support,
+ * automatic certificate management, and high-performance connection pooling.
+ */
+export declare class NetworkProxy implements IMetricsTracker {
+    options: INetworkProxyOptions;
+    proxyConfigs: IReverseProxyConfig[];
+    httpsServer: plugins.https.Server;
+    private certificateManager;
+    private connectionPool;
+    private requestHandler;
+    private webSocketHandler;
+    private router;
+    socketMap: plugins.lik.ObjectMap<plugins.net.Socket>;
+    activeContexts: Set<string>;
+    connectedClients: number;
+    startTime: number;
+    requestsServed: number;
+    failedRequests: number;
+    private portProxyConnections;
+    private tlsTerminatedConnections;
+    private metricsInterval;
+    private connectionPoolCleanupInterval;
+    private logger;
+    /**
+     * Creates a new NetworkProxy instance
+     */
+    constructor(optionsArg: INetworkProxyOptions);
+    /**
+     * Implements IMetricsTracker interface to increment request counters
+     */
+    incrementRequestsServed(): void;
+    /**
+     * Implements IMetricsTracker interface to increment failed request counters
+     */
+    incrementFailedRequests(): void;
+    /**
+     * Returns the port number this NetworkProxy is listening on
+     * Useful for PortProxy to determine where to forward connections
+     */
+    getListeningPort(): number;
+    /**
+     * Updates the server capacity settings
+     * @param maxConnections Maximum number of simultaneous connections
+     * @param keepAliveTimeout Keep-alive timeout in milliseconds
+     * @param connectionPoolSize Size of the connection pool per backend
+     */
+    updateCapacity(maxConnections?: number, keepAliveTimeout?: number, connectionPoolSize?: number): void;
+    /**
+     * Returns current server metrics
+     * Useful for PortProxy to determine which NetworkProxy to use for load balancing
+     */
+    getMetrics(): any;
+    /**
+     * Sets an external Port80Handler for certificate management
+     * This allows the NetworkProxy to use a centrally managed Port80Handler
+     * instead of creating its own
+     *
+     * @param handler The Port80Handler instance to use
+     */
+    setExternalPort80Handler(handler: Port80Handler): void;
+    /**
+     * Starts the proxy server
+     */
+    start(): Promise<void>;
+    /**
+     * Sets up tracking of TCP connections
+     */
+    private setupConnectionTracking;
+    /**
+     * Sets up metrics collection
+     */
+    private setupMetricsCollection;
+    /**
+     * Updates proxy configurations
+     */
+    updateProxyConfigs(proxyConfigsArg: plugins.tsclass.network.IReverseProxyConfig[]): Promise<void>;
+    /**
+     * Converts PortProxy domain configurations to NetworkProxy configs
+     * @param domainConfigs PortProxy domain configs
+     * @param sslKeyPair Default SSL key pair to use if not specified
+     * @returns Array of NetworkProxy configs
+     */
+    convertPortProxyConfigs(domainConfigs: Array<{
+        domains: string[];
+        targetIPs?: string[];
+        allowedIPs?: string[];
+    }>, sslKeyPair?: {
+        key: string;
+        cert: string;
+    }): plugins.tsclass.network.IReverseProxyConfig[];
+    /**
+     * Adds default headers to be included in all responses
+     */
+    addDefaultHeaders(headersArg: {
+        [key: string]: string;
+    }): Promise<void>;
+    /**
+     * Stops the proxy server
+     */
+    stop(): Promise<void>;
+    /**
+     * Requests a new certificate for a domain
+     * This can be used to manually trigger certificate issuance
+     * @param domain The domain to request a certificate for
+     * @returns A promise that resolves when the request is submitted (not when the certificate is issued)
+     */
+    requestCertificate(domain: string): Promise<boolean>;
+    /**
+     * Gets all proxy configurations currently in use
+     */
+    getProxyConfigs(): plugins.tsclass.network.IReverseProxyConfig[];
+}

package/dist_ts/networkproxy/classes.np.networkproxy.js

@@ -0,0 +1,375 @@
+import * as plugins from '../plugins.js';
+import { createLogger } from './classes.np.types.js';
+import { CertificateManager } from './classes.np.certificatemanager.js';
+import { ConnectionPool } from './classes.np.connectionpool.js';
+import { RequestHandler } from './classes.np.requesthandler.js';
+import { WebSocketHandler } from './classes.np.websockethandler.js';
+import { ProxyRouter } from '../classes.router.js';
+import { Port80Handler } from '../port80handler/classes.port80handler.js';
+/**
+ * NetworkProxy provides a reverse proxy with TLS termination, WebSocket support,
+ * automatic certificate management, and high-performance connection pooling.
+ */
+export class NetworkProxy {
+    /**
+     * Creates a new NetworkProxy instance
+     */
+    constructor(optionsArg) {
+        this.proxyConfigs = [];
+        this.router = new ProxyRouter();
+        // State tracking
+        this.socketMap = new plugins.lik.ObjectMap();
+        this.activeContexts = new Set();
+        this.connectedClients = 0;
+        this.startTime = 0;
+        this.requestsServed = 0;
+        this.failedRequests = 0;
+        // Tracking for PortProxy integration
+        this.portProxyConnections = 0;
+        this.tlsTerminatedConnections = 0;
+        // Set default options
+        this.options = {
+            port: optionsArg.port,
+            maxConnections: optionsArg.maxConnections || 10000,
+            keepAliveTimeout: optionsArg.keepAliveTimeout || 120000, // 2 minutes 
+            headersTimeout: optionsArg.headersTimeout || 60000, // 1 minute
+            logLevel: optionsArg.logLevel || 'info',
+            cors: optionsArg.cors || {
+                allowOrigin: '*',
+                allowMethods: 'GET, POST, PUT, DELETE, OPTIONS',
+                allowHeaders: 'Content-Type, Authorization',
+                maxAge: 86400
+            },
+            // Defaults for PortProxy integration
+            connectionPoolSize: optionsArg.connectionPoolSize || 50,
+            portProxyIntegration: optionsArg.portProxyIntegration || false,
+            useExternalPort80Handler: optionsArg.useExternalPort80Handler || false,
+            // Default ACME options
+            acme: {
+                enabled: optionsArg.acme?.enabled || false,
+                port: optionsArg.acme?.port || 80,
+                contactEmail: optionsArg.acme?.contactEmail || 'admin@example.com',
+                useProduction: optionsArg.acme?.useProduction || false, // Default to staging for safety
+                renewThresholdDays: optionsArg.acme?.renewThresholdDays || 30,
+                autoRenew: optionsArg.acme?.autoRenew !== false, // Default to true
+                certificateStore: optionsArg.acme?.certificateStore || './certs',
+                skipConfiguredCerts: optionsArg.acme?.skipConfiguredCerts || false
+            }
+        };
+        // Initialize logger
+        this.logger = createLogger(this.options.logLevel);
+        // Initialize components
+        this.certificateManager = new CertificateManager(this.options);
+        this.connectionPool = new ConnectionPool(this.options);
+        this.requestHandler = new RequestHandler(this.options, this.connectionPool, this.router);
+        this.webSocketHandler = new WebSocketHandler(this.options, this.connectionPool, this.router);
+        // Connect request handler to this metrics tracker
+        this.requestHandler.setMetricsTracker(this);
+    }
+    /**
+     * Implements IMetricsTracker interface to increment request counters
+     */
+    incrementRequestsServed() {
+        this.requestsServed++;
+    }
+    /**
+     * Implements IMetricsTracker interface to increment failed request counters
+     */
+    incrementFailedRequests() {
+        this.failedRequests++;
+    }
+    /**
+     * Returns the port number this NetworkProxy is listening on
+     * Useful for PortProxy to determine where to forward connections
+     */
+    getListeningPort() {
+        return this.options.port;
+    }
+    /**
+     * Updates the server capacity settings
+     * @param maxConnections Maximum number of simultaneous connections
+     * @param keepAliveTimeout Keep-alive timeout in milliseconds
+     * @param connectionPoolSize Size of the connection pool per backend
+     */
+    updateCapacity(maxConnections, keepAliveTimeout, connectionPoolSize) {
+        if (maxConnections !== undefined) {
+            this.options.maxConnections = maxConnections;
+            this.logger.info(`Updated max connections to ${maxConnections}`);
+        }
+        if (keepAliveTimeout !== undefined) {
+            this.options.keepAliveTimeout = keepAliveTimeout;
+            if (this.httpsServer) {
+                this.httpsServer.keepAliveTimeout = keepAliveTimeout;
+                this.logger.info(`Updated keep-alive timeout to ${keepAliveTimeout}ms`);
+            }
+        }
+        if (connectionPoolSize !== undefined) {
+            this.options.connectionPoolSize = connectionPoolSize;
+            this.logger.info(`Updated connection pool size to ${connectionPoolSize}`);
+            // Clean up excess connections in the pool
+            this.connectionPool.cleanupConnectionPool();
+        }
+    }
+    /**
+     * Returns current server metrics
+     * Useful for PortProxy to determine which NetworkProxy to use for load balancing
+     */
+    getMetrics() {
+        return {
+            activeConnections: this.connectedClients,
+            totalRequests: this.requestsServed,
+            failedRequests: this.failedRequests,
+            portProxyConnections: this.portProxyConnections,
+            tlsTerminatedConnections: this.tlsTerminatedConnections,
+            connectionPoolSize: this.connectionPool.getPoolStatus(),
+            uptime: Math.floor((Date.now() - this.startTime) / 1000),
+            memoryUsage: process.memoryUsage(),
+            activeWebSockets: this.webSocketHandler.getConnectionInfo().activeConnections
+        };
+    }
+    /**
+     * Sets an external Port80Handler for certificate management
+     * This allows the NetworkProxy to use a centrally managed Port80Handler
+     * instead of creating its own
+     *
+     * @param handler The Port80Handler instance to use
+     */
+    setExternalPort80Handler(handler) {
+        // Connect it to the certificate manager
+        this.certificateManager.setExternalPort80Handler(handler);
+    }
+    /**
+     * Starts the proxy server
+     */
+    async start() {
+        this.startTime = Date.now();
+        // Initialize Port80Handler if enabled and not using external handler
+        if (this.options.acme?.enabled && !this.options.useExternalPort80Handler) {
+            await this.certificateManager.initializePort80Handler();
+        }
+        // Create the HTTPS server
+        this.httpsServer = plugins.https.createServer({
+            key: this.certificateManager.getDefaultCertificates().key,
+            cert: this.certificateManager.getDefaultCertificates().cert,
+            SNICallback: (domain, cb) => this.certificateManager.handleSNI(domain, cb)
+        }, (req, res) => this.requestHandler.handleRequest(req, res));
+        // Configure server timeouts
+        this.httpsServer.keepAliveTimeout = this.options.keepAliveTimeout;
+        this.httpsServer.headersTimeout = this.options.headersTimeout;
+        // Setup connection tracking
+        this.setupConnectionTracking();
+        // Share HTTPS server with certificate manager
+        this.certificateManager.setHttpsServer(this.httpsServer);
+        // Setup WebSocket support
+        this.webSocketHandler.initialize(this.httpsServer);
+        // Start metrics collection
+        this.setupMetricsCollection();
+        // Setup connection pool cleanup interval
+        this.connectionPoolCleanupInterval = this.connectionPool.setupPeriodicCleanup();
+        // Start the server
+        return new Promise((resolve) => {
+            this.httpsServer.listen(this.options.port, () => {
+                this.logger.info(`NetworkProxy started on port ${this.options.port}`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Sets up tracking of TCP connections
+     */
+    setupConnectionTracking() {
+        this.httpsServer.on('connection', (connection) => {
+            // Check if max connections reached
+            if (this.socketMap.getArray().length >= this.options.maxConnections) {
+                this.logger.warn(`Max connections (${this.options.maxConnections}) reached, rejecting new connection`);
+                connection.destroy();
+                return;
+            }
+            // Add connection to tracking
+            this.socketMap.add(connection);
+            this.connectedClients = this.socketMap.getArray().length;
+            // Check for connection from PortProxy by inspecting the source port
+            const localPort = connection.localPort || 0;
+            const remotePort = connection.remotePort || 0;
+            // If this connection is from a PortProxy (usually indicated by it coming from localhost)
+            if (this.options.portProxyIntegration && connection.remoteAddress?.includes('127.0.0.1')) {
+                this.portProxyConnections++;
+                this.logger.debug(`New connection from PortProxy (local: ${localPort}, remote: ${remotePort})`);
+            }
+            else {
+                this.logger.debug(`New direct connection (local: ${localPort}, remote: ${remotePort})`);
+            }
+            // Setup connection cleanup handlers
+            const cleanupConnection = () => {
+                if (this.socketMap.checkForObject(connection)) {
+                    this.socketMap.remove(connection);
+                    this.connectedClients = this.socketMap.getArray().length;
+                    // If this was a PortProxy connection, decrement the counter
+                    if (this.options.portProxyIntegration && connection.remoteAddress?.includes('127.0.0.1')) {
+                        this.portProxyConnections--;
+                    }
+                    this.logger.debug(`Connection closed. ${this.connectedClients} connections remaining`);
+                }
+            };
+            connection.on('close', cleanupConnection);
+            connection.on('error', (err) => {
+                this.logger.debug('Connection error', err);
+                cleanupConnection();
+            });
+            connection.on('end', cleanupConnection);
+        });
+        // Track TLS handshake completions
+        this.httpsServer.on('secureConnection', (tlsSocket) => {
+            this.tlsTerminatedConnections++;
+            this.logger.debug('TLS handshake completed, connection secured');
+        });
+    }
+    /**
+     * Sets up metrics collection
+     */
+    setupMetricsCollection() {
+        this.metricsInterval = setInterval(() => {
+            const uptime = Math.floor((Date.now() - this.startTime) / 1000);
+            const metrics = {
+                uptime,
+                activeConnections: this.connectedClients,
+                totalRequests: this.requestsServed,
+                failedRequests: this.failedRequests,
+                portProxyConnections: this.portProxyConnections,
+                tlsTerminatedConnections: this.tlsTerminatedConnections,
+                activeWebSockets: this.webSocketHandler.getConnectionInfo().activeConnections,
+                memoryUsage: process.memoryUsage(),
+                activeContexts: Array.from(this.activeContexts),
+                connectionPool: this.connectionPool.getPoolStatus()
+            };
+            this.logger.debug('Proxy metrics', metrics);
+        }, 60000); // Log metrics every minute
+        // Don't keep process alive just for metrics
+        if (this.metricsInterval.unref) {
+            this.metricsInterval.unref();
+        }
+    }
+    /**
+     * Updates proxy configurations
+     */
+    async updateProxyConfigs(proxyConfigsArg) {
+        this.logger.info(`Updating proxy configurations (${proxyConfigsArg.length} configs)`);
+        // Update internal configs
+        this.proxyConfigs = proxyConfigsArg;
+        this.router.setNewProxyConfigs(proxyConfigsArg);
+        // Collect all hostnames for cleanup later
+        const currentHostNames = new Set();
+        // Add/update SSL contexts for each host
+        for (const config of proxyConfigsArg) {
+            currentHostNames.add(config.hostName);
+            try {
+                // Update certificate in cache
+                this.certificateManager.updateCertificateCache(config.hostName, config.publicKey, config.privateKey);
+                this.activeContexts.add(config.hostName);
+            }
+            catch (error) {
+                this.logger.error(`Failed to add SSL context for ${config.hostName}`, error);
+            }
+        }
+        // Clean up removed contexts
+        for (const hostname of this.activeContexts) {
+            if (!currentHostNames.has(hostname)) {
+                this.logger.info(`Hostname ${hostname} removed from configuration`);
+                this.activeContexts.delete(hostname);
+            }
+        }
+        // Register domains with Port80Handler if available
+        const domainsForACME = Array.from(currentHostNames)
+            .filter(domain => !domain.includes('*')); // Skip wildcard domains
+        this.certificateManager.registerDomainsWithPort80Handler(domainsForACME);
+    }
+    /**
+     * Converts PortProxy domain configurations to NetworkProxy configs
+     * @param domainConfigs PortProxy domain configs
+     * @param sslKeyPair Default SSL key pair to use if not specified
+     * @returns Array of NetworkProxy configs
+     */
+    convertPortProxyConfigs(domainConfigs, sslKeyPair) {
+        const proxyConfigs = [];
+        // Use default certificates if not provided
+        const defaultCerts = this.certificateManager.getDefaultCertificates();
+        const sslKey = sslKeyPair?.key || defaultCerts.key;
+        const sslCert = sslKeyPair?.cert || defaultCerts.cert;
+        for (const domainConfig of domainConfigs) {
+            // Each domain in the domains array gets its own config
+            for (const domain of domainConfig.domains) {
+                // Skip non-hostname patterns (like IP addresses)
+                if (domain.match(/^\d+\.\d+\.\d+\.\d+$/) || domain === '*' || domain === 'localhost') {
+                    continue;
+                }
+                proxyConfigs.push({
+                    hostName: domain,
+                    destinationIps: domainConfig.targetIPs || ['localhost'],
+                    destinationPorts: [this.options.port], // Use the NetworkProxy port
+                    privateKey: sslKey,
+                    publicKey: sslCert
+                });
+            }
+        }
+        this.logger.info(`Converted ${domainConfigs.length} PortProxy configs to ${proxyConfigs.length} NetworkProxy configs`);
+        return proxyConfigs;
+    }
+    /**
+     * Adds default headers to be included in all responses
+     */
+    async addDefaultHeaders(headersArg) {
+        this.logger.info('Adding default headers', headersArg);
+        this.requestHandler.setDefaultHeaders(headersArg);
+    }
+    /**
+     * Stops the proxy server
+     */
+    async stop() {
+        this.logger.info('Stopping NetworkProxy server');
+        // Clear intervals
+        if (this.metricsInterval) {
+            clearInterval(this.metricsInterval);
+        }
+        if (this.connectionPoolCleanupInterval) {
+            clearInterval(this.connectionPoolCleanupInterval);
+        }
+        // Stop WebSocket handler
+        this.webSocketHandler.shutdown();
+        // Close all tracked sockets
+        for (const socket of this.socketMap.getArray()) {
+            try {
+                socket.destroy();
+            }
+            catch (error) {
+                this.logger.error('Error destroying socket', error);
+            }
+        }
+        // Close all connection pool connections
+        this.connectionPool.closeAllConnections();
+        // Stop Port80Handler if internally managed
+        await this.certificateManager.stopPort80Handler();
+        // Close the HTTPS server
+        return new Promise((resolve) => {
+            this.httpsServer.close(() => {
+                this.logger.info('NetworkProxy server stopped successfully');
+                resolve();
+            });
+        });
+    }
+    /**
+     * Requests a new certificate for a domain
+     * This can be used to manually trigger certificate issuance
+     * @param domain The domain to request a certificate for
+     * @returns A promise that resolves when the request is submitted (not when the certificate is issued)
+     */
+    async requestCertificate(domain) {
+        return this.certificateManager.requestCertificate(domain);
+    }
+    /**
+     * Gets all proxy configurations currently in use
+     */
+    getProxyConfigs() {
+        return [...this.proxyConfigs];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.np.networkproxy.js","sourceRoot":"","sources":["../../ts/networkproxy/classes.np.networkproxy.ts"],"names":[],"mappings":"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"}

package/dist_ts/networkproxy/classes.np.requesthandler.d.ts

@@ -0,0 +1,51 @@
+import * as plugins from '../plugins.js';
+import { type INetworkProxyOptions } from './classes.np.types.js';
+import { ConnectionPool } from './classes.np.connectionpool.js';
+import { ProxyRouter } from '../classes.router.js';
+/**
+ * Interface for tracking metrics
+ */
+export interface IMetricsTracker {
+    incrementRequestsServed(): void;
+    incrementFailedRequests(): void;
+}
+/**
+ * Handles HTTP request processing and proxying
+ */
+export declare class RequestHandler {
+    private options;
+    private connectionPool;
+    private router;
+    private defaultHeaders;
+    private logger;
+    private metricsTracker;
+    constructor(options: INetworkProxyOptions, connectionPool: ConnectionPool, router: ProxyRouter);
+    /**
+     * Set the metrics tracker instance
+     */
+    setMetricsTracker(tracker: IMetricsTracker): void;
+    /**
+     * Set default headers to be included in all responses
+     */
+    setDefaultHeaders(headers: {
+        [key: string]: string;
+    }): void;
+    /**
+     * Get all default headers
+     */
+    getDefaultHeaders(): {
+        [key: string]: string;
+    };
+    /**
+     * Apply CORS headers to response if configured
+     */
+    private applyCorsHeaders;
+    /**
+     * Apply default headers to response
+     */
+    private applyDefaultHeaders;
+    /**
+     * Handle an HTTP request
+     */
+    handleRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): Promise<void>;
+}