@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/proxies/network-proxy/connection-pool.js

@@ -0,0 +1,210 @@
+import * as plugins from '../../plugins.js';
+import { createLogger } from './models/types.js';
+/**
+ * Manages a pool of backend connections for efficient reuse
+ */
+export class ConnectionPool {
+    constructor(options) {
+        this.options = options;
+        this.connectionPool = new Map();
+        this.roundRobinPositions = new Map();
+        this.logger = createLogger(options.logLevel || 'info');
+    }
+    /**
+     * Get a connection from the pool or create a new one
+     */
+    getConnection(host, port) {
+        return new Promise((resolve, reject) => {
+            const poolKey = `${host}:${port}`;
+            const connectionList = this.connectionPool.get(poolKey) || [];
+            // Look for an idle connection
+            const idleConnectionIndex = connectionList.findIndex(c => c.isIdle);
+            if (idleConnectionIndex >= 0) {
+                // Get existing connection from pool
+                const connection = connectionList[idleConnectionIndex];
+                connection.isIdle = false;
+                connection.lastUsed = Date.now();
+                this.logger.debug(`Reusing connection from pool for ${poolKey}`);
+                // Update the pool
+                this.connectionPool.set(poolKey, connectionList);
+                resolve(connection.socket);
+                return;
+            }
+            // No idle connection available, create a new one if pool isn't full
+            const poolSize = this.options.connectionPoolSize || 50;
+            if (connectionList.length < poolSize) {
+                this.logger.debug(`Creating new connection to ${host}:${port}`);
+                try {
+                    const socket = plugins.net.connect({
+                        host,
+                        port,
+                        keepAlive: true,
+                        keepAliveInitialDelay: 30000 // 30 seconds
+                    });
+                    socket.once('connect', () => {
+                        // Add to connection pool
+                        const connection = {
+                            socket,
+                            lastUsed: Date.now(),
+                            isIdle: false
+                        };
+                        connectionList.push(connection);
+                        this.connectionPool.set(poolKey, connectionList);
+                        // Setup cleanup when the connection is closed
+                        socket.once('close', () => {
+                            const idx = connectionList.findIndex(c => c.socket === socket);
+                            if (idx >= 0) {
+                                connectionList.splice(idx, 1);
+                                this.connectionPool.set(poolKey, connectionList);
+                                this.logger.debug(`Removed closed connection from pool for ${poolKey}`);
+                            }
+                        });
+                        resolve(socket);
+                    });
+                    socket.once('error', (err) => {
+                        this.logger.error(`Error creating connection to ${host}:${port}`, err);
+                        reject(err);
+                    });
+                }
+                catch (err) {
+                    this.logger.error(`Failed to create connection to ${host}:${port}`, err);
+                    reject(err);
+                }
+            }
+            else {
+                // Pool is full, wait for an idle connection or reject
+                this.logger.warn(`Connection pool for ${poolKey} is full (${connectionList.length})`);
+                reject(new Error(`Connection pool for ${poolKey} is full`));
+            }
+        });
+    }
+    /**
+     * Return a connection to the pool for reuse
+     */
+    returnConnection(socket, host, port) {
+        const poolKey = `${host}:${port}`;
+        const connectionList = this.connectionPool.get(poolKey) || [];
+        // Find this connection in the pool
+        const connectionIndex = connectionList.findIndex(c => c.socket === socket);
+        if (connectionIndex >= 0) {
+            // Mark as idle and update last used time
+            connectionList[connectionIndex].isIdle = true;
+            connectionList[connectionIndex].lastUsed = Date.now();
+            this.logger.debug(`Returned connection to pool for ${poolKey}`);
+        }
+        else {
+            this.logger.warn(`Attempted to return unknown connection to pool for ${poolKey}`);
+        }
+    }
+    /**
+     * Cleanup the connection pool by removing idle connections
+     * or reducing pool size if it exceeds the configured maximum
+     */
+    cleanupConnectionPool() {
+        const now = Date.now();
+        const idleTimeout = this.options.keepAliveTimeout || 120000; // 2 minutes default
+        for (const [host, connections] of this.connectionPool.entries()) {
+            // Sort by last used time (oldest first)
+            connections.sort((a, b) => a.lastUsed - b.lastUsed);
+            // Remove idle connections older than the idle timeout
+            let removed = 0;
+            while (connections.length > 0) {
+                const connection = connections[0];
+                // Remove if idle and exceeds timeout, or if pool is too large
+                if ((connection.isIdle && now - connection.lastUsed > idleTimeout) ||
+                    connections.length > (this.options.connectionPoolSize || 50)) {
+                    try {
+                        if (!connection.socket.destroyed) {
+                            connection.socket.end();
+                            connection.socket.destroy();
+                        }
+                    }
+                    catch (err) {
+                        this.logger.error(`Error destroying pooled connection to ${host}`, err);
+                    }
+                    connections.shift(); // Remove from pool
+                    removed++;
+                }
+                else {
+                    break; // Stop removing if we've reached active or recent connections
+                }
+            }
+            if (removed > 0) {
+                this.logger.debug(`Removed ${removed} idle connections from pool for ${host}, ${connections.length} remaining`);
+            }
+            // Update the pool with the remaining connections
+            if (connections.length === 0) {
+                this.connectionPool.delete(host);
+            }
+            else {
+                this.connectionPool.set(host, connections);
+            }
+        }
+    }
+    /**
+     * Close all connections in the pool
+     */
+    closeAllConnections() {
+        for (const [host, connections] of this.connectionPool.entries()) {
+            this.logger.debug(`Closing ${connections.length} connections to ${host}`);
+            for (const connection of connections) {
+                try {
+                    if (!connection.socket.destroyed) {
+                        connection.socket.end();
+                        connection.socket.destroy();
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Error closing connection to ${host}:`, error);
+                }
+            }
+        }
+        this.connectionPool.clear();
+        this.roundRobinPositions.clear();
+    }
+    /**
+     * Get load balancing target using round-robin
+     */
+    getNextTarget(targets, port) {
+        const targetKey = targets.join(',');
+        // Initialize position if not exists
+        if (!this.roundRobinPositions.has(targetKey)) {
+            this.roundRobinPositions.set(targetKey, 0);
+        }
+        // Get current position and increment for next time
+        const currentPosition = this.roundRobinPositions.get(targetKey);
+        const nextPosition = (currentPosition + 1) % targets.length;
+        this.roundRobinPositions.set(targetKey, nextPosition);
+        // Return the selected target
+        return {
+            host: targets[currentPosition],
+            port
+        };
+    }
+    /**
+     * Gets the connection pool status
+     */
+    getPoolStatus() {
+        return Object.fromEntries(Array.from(this.connectionPool.entries()).map(([host, connections]) => [
+            host,
+            {
+                total: connections.length,
+                idle: connections.filter(c => c.isIdle).length
+            }
+        ]));
+    }
+    /**
+     * Setup a periodic cleanup task
+     */
+    setupPeriodicCleanup(interval = 60000) {
+        const timer = setInterval(() => {
+            this.cleanupConnectionPool();
+        }, interval);
+        // Don't prevent process exit
+        if (timer.unref) {
+            timer.unref();
+        }
+        return timer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection-pool.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/connection-pool.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * NetworkProxy implementation
+ */
+export * from './models/index.js';
+export { NetworkProxy } from './network-proxy.js';
+export { CertificateManager } from './certificate-manager.js';
+export { ConnectionPool } from './connection-pool.js';
+export { RequestHandler } from './request-handler.js';
+export type { IMetricsTracker, MetricsTracker } from './request-handler.js';
+export { WebSocketHandler } from './websocket-handler.js';

package/dist_ts/proxies/network-proxy/index.js

@@ -0,0 +1,12 @@
+/**
+ * NetworkProxy implementation
+ */
+// Re-export models
+export * from './models/index.js';
+// Export NetworkProxy and supporting classes
+export { NetworkProxy } from './network-proxy.js';
+export { CertificateManager } from './certificate-manager.js';
+export { ConnectionPool } from './connection-pool.js';
+export { RequestHandler } from './request-handler.js';
+export { WebSocketHandler } from './websocket-handler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL25ldHdvcmstcHJveHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxtQkFBbUI7QUFDbkIsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQyw2Q0FBNkM7QUFDN0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzlELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFdEQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0JBQXdCLENBQUMifQ==

package/dist_ts/proxies/network-proxy/models/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * NetworkProxy models
+ */
+export * from './types.js';

package/dist_ts/proxies/network-proxy/models/index.js

@@ -0,0 +1,5 @@
+/**
+ * NetworkProxy models
+ */
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL25ldHdvcmstcHJveHkvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxZQUFZLENBQUMifQ==

package/dist_ts/proxies/network-proxy/models/types.d.ts

@@ -0,0 +1,80 @@
+import * as plugins from '../../../plugins.js';
+import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+/**
+ * Configuration options for NetworkProxy
+ */
+export interface INetworkProxyOptions {
+    port: number;
+    maxConnections?: number;
+    keepAliveTimeout?: number;
+    headersTimeout?: number;
+    logLevel?: 'error' | 'warn' | 'info' | 'debug';
+    cors?: {
+        allowOrigin?: string;
+        allowMethods?: string;
+        allowHeaders?: string;
+        maxAge?: number;
+    };
+    connectionPoolSize?: number;
+    portProxyIntegration?: boolean;
+    useExternalPort80Handler?: boolean;
+    backendProtocol?: 'http1' | 'http2';
+    acme?: IAcmeOptions;
+}
+/**
+ * Interface for a certificate entry in the cache
+ */
+export interface ICertificateEntry {
+    key: string;
+    cert: string;
+    expires?: Date;
+}
+/**
+ * Interface for reverse proxy configuration
+ */
+export interface IReverseProxyConfig {
+    destinationIps: string[];
+    destinationPorts: number[];
+    hostName: string;
+    privateKey: string;
+    publicKey: string;
+    authentication?: {
+        type: 'Basic';
+        user: string;
+        pass: string;
+    };
+    rewriteHostHeader?: boolean;
+    /**
+     * Protocol to use when proxying to this backend: 'http1' or 'http2'.
+     * Overrides the global backendProtocol option if set.
+     */
+    backendProtocol?: 'http1' | 'http2';
+}
+/**
+ * Interface for connection tracking in the pool
+ */
+export interface IConnectionEntry {
+    socket: plugins.net.Socket;
+    lastUsed: number;
+    isIdle: boolean;
+}
+/**
+ * WebSocket with heartbeat interface
+ */
+export interface IWebSocketWithHeartbeat extends plugins.wsDefault {
+    lastPong: number;
+    isAlive: boolean;
+}
+/**
+ * Logger interface for consistent logging across components
+ */
+export interface ILogger {
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, data?: any): void;
+}
+/**
+ * Creates a logger based on the specified log level
+ */
+export declare function createLogger(logLevel?: string): ILogger;

package/dist_ts/proxies/network-proxy/models/types.js

@@ -0,0 +1,35 @@
+import * as plugins from '../../../plugins.js';
+/**
+ * Creates a logger based on the specified log level
+ */
+export function createLogger(logLevel = 'info') {
+    const logLevels = {
+        error: 0,
+        warn: 1,
+        info: 2,
+        debug: 3
+    };
+    return {
+        debug: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.debug) {
+                console.log(`[DEBUG] ${message}`, data || '');
+            }
+        },
+        info: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.info) {
+                console.log(`[INFO] ${message}`, data || '');
+            }
+        },
+        warn: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.warn) {
+                console.warn(`[WARN] ${message}`, data || '');
+            }
+        },
+        error: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.error) {
+                console.error(`[ERROR] ${message}`, data || '');
+            }
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL25ldHdvcmstcHJveHkvbW9kZWxzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUF3Ri9DOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxXQUFtQixNQUFNO0lBQ3BELE1BQU0sU0FBUyxHQUFHO1FBQ2hCLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxFQUFFLENBQUM7UUFDUCxJQUFJLEVBQUUsQ0FBQztRQUNQLEtBQUssRUFBRSxDQUFDO0tBQ1QsQ0FBQztJQUVGLE9BQU87UUFDTCxLQUFLLEVBQUUsQ0FBQyxPQUFlLEVBQUUsSUFBVSxFQUFFLEVBQUU7WUFDckMsSUFBSSxTQUFTLENBQUMsUUFBUSxDQUFDLElBQUksU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUMzQyxPQUFPLENBQUMsR0FBRyxDQUFDLFdBQVcsT0FBTyxFQUFFLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ2hELENBQUM7UUFDSCxDQUFDO1FBQ0QsSUFBSSxFQUFFLENBQUMsT0FBZSxFQUFFLElBQVUsRUFBRSxFQUFFO1lBQ3BDLElBQUksU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztnQkFDMUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLE9BQU8sRUFBRSxFQUFFLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQztZQUMvQyxDQUFDO1FBQ0gsQ0FBQztRQUNELElBQUksRUFBRSxDQUFDLE9BQWUsRUFBRSxJQUFVLEVBQUUsRUFBRTtZQUNwQyxJQUFJLFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7Z0JBQzFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxPQUFPLEVBQUUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLENBQUM7WUFDaEQsQ0FBQztRQUNILENBQUM7UUFDRCxLQUFLLEVBQUUsQ0FBQyxPQUFlLEVBQUUsSUFBVSxFQUFFLEVBQUU7WUFDckMsSUFBSSxTQUFTLENBQUMsUUFBUSxDQUFDLElBQUksU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUMzQyxPQUFPLENBQUMsS0FBSyxDQUFDLFdBQVcsT0FBTyxFQUFFLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ2xELENBQUM7UUFDSCxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUMifQ==

package/dist_ts/proxies/network-proxy/network-proxy.d.ts

@@ -0,0 +1,118 @@
+import * as plugins from '../../plugins.js';
+import type { INetworkProxyOptions, IReverseProxyConfig } from './models/types.js';
+import { type IMetricsTracker } from './request-handler.js';
+import { Port80Handler } from '../../http/port80/port80-handler.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 {
+    toJSON(): any;
+    options: INetworkProxyOptions;
+    proxyConfigs: IReverseProxyConfig[];
+    httpsServer: any;
+    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 SmartProxy 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 SmartProxy 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: IReverseProxyConfig[]): Promise<void>;
+    /**
+     * Converts SmartProxy domain configurations to NetworkProxy configs
+     * @param domainConfigs SmartProxy domain configs
+     * @param sslKeyPair Default SSL key pair to use if not specified
+     * @returns Array of NetworkProxy configs
+     */
+    convertSmartProxyConfigs(domainConfigs: Array<{
+        domains: string[];
+        targetIPs?: string[];
+        allowedIPs?: string[];
+    }>, sslKeyPair?: {
+        key: string;
+        cert: string;
+    }): 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(): IReverseProxyConfig[];
+}