@push.rocks/smartproxy 5.1.0 → 6.0.1

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

@@ -0,0 +1,354 @@
+import * as plugins from '../plugins.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { createLogger } from './classes.np.types.js';
+import { Port80Handler, Port80HandlerEvents } from '../port80handler/classes.port80handler.js';
+/**
+ * Manages SSL certificates for NetworkProxy including ACME integration
+ */
+export class CertificateManager {
+    constructor(options) {
+        this.options = options;
+        this.certificateCache = new Map();
+        this.port80Handler = null;
+        this.externalPort80Handler = false;
+        this.httpsServer = null;
+        this.certificateStoreDir = path.resolve(options.acme?.certificateStore || './certs');
+        this.logger = createLogger(options.logLevel || 'info');
+        // Ensure certificate store directory exists
+        try {
+            if (!fs.existsSync(this.certificateStoreDir)) {
+                fs.mkdirSync(this.certificateStoreDir, { recursive: true });
+                this.logger.info(`Created certificate store directory: ${this.certificateStoreDir}`);
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to create certificate store directory: ${error}`);
+        }
+        this.loadDefaultCertificates();
+    }
+    /**
+     * Loads default certificates from the filesystem
+     */
+    loadDefaultCertificates() {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const certPath = path.join(__dirname, '..', '..', 'assets', 'certs');
+        try {
+            this.defaultCertificates = {
+                key: fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8'),
+                cert: fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8')
+            };
+            this.logger.info('Default certificates loaded successfully');
+        }
+        catch (error) {
+            this.logger.error('Error loading default certificates', error);
+            // Generate self-signed fallback certificates
+            try {
+                // This is a placeholder for actual certificate generation code
+                // In a real implementation, you would use a library like selfsigned to generate certs
+                this.defaultCertificates = {
+                    key: "FALLBACK_KEY_CONTENT",
+                    cert: "FALLBACK_CERT_CONTENT"
+                };
+                this.logger.warn('Using fallback self-signed certificates');
+            }
+            catch (fallbackError) {
+                this.logger.error('Failed to generate fallback certificates', fallbackError);
+                throw new Error('Could not load or generate SSL certificates');
+            }
+        }
+    }
+    /**
+     * Set the HTTPS server reference for context updates
+     */
+    setHttpsServer(server) {
+        this.httpsServer = server;
+    }
+    /**
+     * Get default certificates
+     */
+    getDefaultCertificates() {
+        return { ...this.defaultCertificates };
+    }
+    /**
+     * Sets an external Port80Handler for certificate management
+     */
+    setExternalPort80Handler(handler) {
+        if (this.port80Handler && !this.externalPort80Handler) {
+            this.logger.warn('Replacing existing internal Port80Handler with external handler');
+            // Clean up existing handler if needed
+            if (this.port80Handler !== handler) {
+                // Unregister event handlers to avoid memory leaks
+                this.port80Handler.removeAllListeners(Port80HandlerEvents.CERTIFICATE_ISSUED);
+                this.port80Handler.removeAllListeners(Port80HandlerEvents.CERTIFICATE_RENEWED);
+                this.port80Handler.removeAllListeners(Port80HandlerEvents.CERTIFICATE_FAILED);
+                this.port80Handler.removeAllListeners(Port80HandlerEvents.CERTIFICATE_EXPIRING);
+            }
+        }
+        // Set the external handler
+        this.port80Handler = handler;
+        this.externalPort80Handler = true;
+        // Register event handlers
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, this.handleCertificateIssued.bind(this));
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, this.handleCertificateIssued.bind(this));
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, this.handleCertificateFailed.bind(this));
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, (data) => {
+            this.logger.info(`Certificate for ${data.domain} expires in ${data.daysRemaining} days`);
+        });
+        this.logger.info('External Port80Handler connected to CertificateManager');
+        // Register domains with Port80Handler if we have any certificates cached
+        if (this.certificateCache.size > 0) {
+            const domains = Array.from(this.certificateCache.keys())
+                .filter(domain => !domain.includes('*')); // Skip wildcard domains
+            this.registerDomainsWithPort80Handler(domains);
+        }
+    }
+    /**
+     * Handle newly issued or renewed certificates from Port80Handler
+     */
+    handleCertificateIssued(data) {
+        const { domain, certificate, privateKey, expiryDate } = data;
+        this.logger.info(`Certificate ${this.certificateCache.has(domain) ? 'renewed' : 'issued'} for ${domain}, valid until ${expiryDate.toISOString()}`);
+        // Update certificate in HTTPS server
+        this.updateCertificateCache(domain, certificate, privateKey, expiryDate);
+        // Save the certificate to the filesystem if not using external handler
+        if (!this.externalPort80Handler && this.options.acme?.certificateStore) {
+            this.saveCertificateToStore(domain, certificate, privateKey);
+        }
+    }
+    /**
+     * Handle certificate issuance failures
+     */
+    handleCertificateFailed(data) {
+        this.logger.error(`Certificate issuance failed for ${data.domain}: ${data.error}`);
+    }
+    /**
+     * Saves certificate and private key to the filesystem
+     */
+    saveCertificateToStore(domain, certificate, privateKey) {
+        try {
+            const certPath = path.join(this.certificateStoreDir, `${domain}.cert.pem`);
+            const keyPath = path.join(this.certificateStoreDir, `${domain}.key.pem`);
+            fs.writeFileSync(certPath, certificate);
+            fs.writeFileSync(keyPath, privateKey);
+            // Ensure private key has restricted permissions
+            try {
+                fs.chmodSync(keyPath, 0o600);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to set permissions on private key for ${domain}: ${error}`);
+            }
+            this.logger.info(`Saved certificate for ${domain} to ${certPath}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to save certificate for ${domain}: ${error}`);
+        }
+    }
+    /**
+     * Handles SNI (Server Name Indication) for TLS connections
+     * Used by the HTTPS server to select the correct certificate for each domain
+     */
+    handleSNI(domain, cb) {
+        this.logger.debug(`SNI request for domain: ${domain}`);
+        // Check if we have a certificate for this domain
+        const certs = this.certificateCache.get(domain);
+        if (certs) {
+            try {
+                // Create TLS context with the cached certificate
+                const context = plugins.tls.createSecureContext({
+                    key: certs.key,
+                    cert: certs.cert
+                });
+                this.logger.debug(`Using cached certificate for ${domain}`);
+                cb(null, context);
+                return;
+            }
+            catch (err) {
+                this.logger.error(`Error creating secure context for ${domain}:`, err);
+            }
+        }
+        // Check if we should trigger certificate issuance
+        if (this.options.acme?.enabled && this.port80Handler && !domain.includes('*')) {
+            // Check if this domain is already registered
+            const certData = this.port80Handler.getCertificate(domain);
+            if (!certData) {
+                this.logger.info(`No certificate found for ${domain}, registering for issuance`);
+                // Register with new domain options format
+                const domainOptions = {
+                    domainName: domain,
+                    sslRedirect: true,
+                    acmeMaintenance: true
+                };
+                this.port80Handler.addDomain(domainOptions);
+            }
+        }
+        // Fall back to default certificate
+        try {
+            const context = plugins.tls.createSecureContext({
+                key: this.defaultCertificates.key,
+                cert: this.defaultCertificates.cert
+            });
+            this.logger.debug(`Using default certificate for ${domain}`);
+            cb(null, context);
+        }
+        catch (err) {
+            this.logger.error(`Error creating default secure context:`, err);
+            cb(new Error('Cannot create secure context'), null);
+        }
+    }
+    /**
+     * Updates certificate in cache
+     */
+    updateCertificateCache(domain, certificate, privateKey, expiryDate) {
+        // Update certificate context in HTTPS server if it's running
+        if (this.httpsServer) {
+            try {
+                this.httpsServer.addContext(domain, {
+                    key: privateKey,
+                    cert: certificate
+                });
+                this.logger.debug(`Updated SSL context for domain: ${domain}`);
+            }
+            catch (error) {
+                this.logger.error(`Error updating SSL context for domain ${domain}:`, error);
+            }
+        }
+        // Update certificate in cache
+        this.certificateCache.set(domain, {
+            key: privateKey,
+            cert: certificate,
+            expires: expiryDate
+        });
+    }
+    /**
+     * Gets a certificate for a domain
+     */
+    getCertificate(domain) {
+        return this.certificateCache.get(domain);
+    }
+    /**
+     * Requests a new certificate for a domain
+     */
+    async requestCertificate(domain) {
+        if (!this.options.acme?.enabled && !this.externalPort80Handler) {
+            this.logger.warn('ACME certificate management is not enabled');
+            return false;
+        }
+        if (!this.port80Handler) {
+            this.logger.error('Port80Handler is not initialized');
+            return false;
+        }
+        // Skip wildcard domains - can't get certs for these with HTTP-01 validation
+        if (domain.includes('*')) {
+            this.logger.error(`Cannot request certificate for wildcard domain: ${domain}`);
+            return false;
+        }
+        try {
+            // Use the new domain options format
+            const domainOptions = {
+                domainName: domain,
+                sslRedirect: true,
+                acmeMaintenance: true
+            };
+            this.port80Handler.addDomain(domainOptions);
+            this.logger.info(`Certificate request submitted for domain: ${domain}`);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error requesting certificate for domain ${domain}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Registers domains with Port80Handler for ACME certificate management
+     */
+    registerDomainsWithPort80Handler(domains) {
+        if (!this.port80Handler) {
+            this.logger.warn('Port80Handler is not initialized');
+            return;
+        }
+        for (const domain of domains) {
+            // Skip wildcard domains - can't get certs for these with HTTP-01 validation
+            if (domain.includes('*')) {
+                this.logger.info(`Skipping wildcard domain for ACME: ${domain}`);
+                continue;
+            }
+            // Skip domains already with certificates if configured to do so
+            if (this.options.acme?.skipConfiguredCerts) {
+                const cachedCert = this.certificateCache.get(domain);
+                if (cachedCert) {
+                    this.logger.info(`Skipping domain with existing certificate: ${domain}`);
+                    continue;
+                }
+            }
+            // Register the domain for certificate issuance with new domain options format
+            const domainOptions = {
+                domainName: domain,
+                sslRedirect: true,
+                acmeMaintenance: true
+            };
+            this.port80Handler.addDomain(domainOptions);
+            this.logger.info(`Registered domain for ACME certificate issuance: ${domain}`);
+        }
+    }
+    /**
+     * Initialize internal Port80Handler
+     */
+    async initializePort80Handler() {
+        // Skip if using external handler
+        if (this.externalPort80Handler) {
+            this.logger.info('Using external Port80Handler, skipping initialization');
+            return this.port80Handler;
+        }
+        if (!this.options.acme?.enabled) {
+            return null;
+        }
+        // Create certificate manager
+        this.port80Handler = new Port80Handler({
+            port: this.options.acme.port,
+            contactEmail: this.options.acme.contactEmail,
+            useProduction: this.options.acme.useProduction,
+            renewThresholdDays: this.options.acme.renewThresholdDays,
+            httpsRedirectPort: this.options.port, // Redirect to our HTTPS port
+            renewCheckIntervalHours: 24, // Check daily for renewals
+            enabled: this.options.acme.enabled,
+            autoRenew: this.options.acme.autoRenew,
+            certificateStore: this.options.acme.certificateStore,
+            skipConfiguredCerts: this.options.acme.skipConfiguredCerts
+        });
+        // Register event handlers
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, this.handleCertificateIssued.bind(this));
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, this.handleCertificateIssued.bind(this));
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, this.handleCertificateFailed.bind(this));
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, (data) => {
+            this.logger.info(`Certificate for ${data.domain} expires in ${data.daysRemaining} days`);
+        });
+        // Start the handler
+        try {
+            await this.port80Handler.start();
+            this.logger.info(`Port80Handler started on port ${this.options.acme.port}`);
+            return this.port80Handler;
+        }
+        catch (error) {
+            this.logger.error(`Failed to start Port80Handler: ${error}`);
+            this.port80Handler = null;
+            return null;
+        }
+    }
+    /**
+     * Stop the Port80Handler if it was internally created
+     */
+    async stopPort80Handler() {
+        if (this.port80Handler && !this.externalPort80Handler) {
+            try {
+                await this.port80Handler.stop();
+                this.logger.info('Port80Handler stopped');
+            }
+            catch (error) {
+                this.logger.error('Error stopping Port80Handler', error);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.np.certificatemanager.js","sourceRoot":"","sources":["../../ts/networkproxy/classes.np.certificatemanager.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,47 @@
+import * as plugins from '../plugins.js';
+import { type INetworkProxyOptions } from './classes.np.types.js';
+/**
+ * Manages a pool of backend connections for efficient reuse
+ */
+export declare class ConnectionPool {
+    private options;
+    private connectionPool;
+    private roundRobinPositions;
+    private logger;
+    constructor(options: INetworkProxyOptions);
+    /**
+     * Get a connection from the pool or create a new one
+     */
+    getConnection(host: string, port: number): Promise<plugins.net.Socket>;
+    /**
+     * Return a connection to the pool for reuse
+     */
+    returnConnection(socket: plugins.net.Socket, host: string, port: number): void;
+    /**
+     * Cleanup the connection pool by removing idle connections
+     * or reducing pool size if it exceeds the configured maximum
+     */
+    cleanupConnectionPool(): void;
+    /**
+     * Close all connections in the pool
+     */
+    closeAllConnections(): void;
+    /**
+     * Get load balancing target using round-robin
+     */
+    getNextTarget(targets: string[], port: number): {
+        host: string;
+        port: number;
+    };
+    /**
+     * Gets the connection pool status
+     */
+    getPoolStatus(): Record<string, {
+        total: number;
+        idle: number;
+    }>;
+    /**
+     * Setup a periodic cleanup task
+     */
+    setupPeriodicCleanup(interval?: number): NodeJS.Timeout;
+}

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

@@ -0,0 +1,210 @@
+import * as plugins from '../plugins.js';
+import { createLogger } from './classes.np.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":"classes.np.connectionpool.js","sourceRoot":"","sources":["../../ts/networkproxy/classes.np.connectionpool.ts"],"names":[],"mappings":"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"}