@push.rocks/smartproxy 19.3.1 → 19.3.3

package/dist_ts/proxies/http-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/http-proxy/connection-pool.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/http-proxy/context-creator.js

@@ -0,0 +1,108 @@
+import * as plugins from '../../plugins.js';
+import '../../core/models/socket-augmentation.js';
+/**
+ * Context creator for NetworkProxy
+ * Creates route contexts for matching and function evaluation
+ */
+export class ContextCreator {
+    /**
+     * Create a route context from HTTP request information
+     */
+    createHttpRouteContext(req, options) {
+        // Parse headers
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (typeof value === 'string') {
+                headers[key.toLowerCase()] = value;
+            }
+            else if (Array.isArray(value) && value.length > 0) {
+                headers[key.toLowerCase()] = value[0];
+            }
+        }
+        // Parse domain from Host header
+        const domain = headers['host']?.split(':')[0] || '';
+        // Parse URL
+        const url = new URL(`http://${domain}${req.url || '/'}`);
+        return {
+            // Connection basics
+            port: req.socket.localPort || 0,
+            domain,
+            clientIp: options.clientIp,
+            serverIp: options.serverIp,
+            // HTTP specifics
+            path: url.pathname,
+            query: url.search ? url.search.substring(1) : '',
+            headers,
+            // TLS information
+            isTls: !!req.socket.encrypted,
+            tlsVersion: options.tlsVersion,
+            // Request objects
+            req,
+            // Metadata
+            timestamp: Date.now(),
+            connectionId: options.connectionId
+        };
+    }
+    /**
+     * Create a route context from HTTP/2 stream and headers
+     */
+    createHttp2RouteContext(stream, headers, options) {
+        // Parse headers, excluding HTTP/2 pseudo-headers
+        const processedHeaders = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (!key.startsWith(':') && typeof value === 'string') {
+                processedHeaders[key.toLowerCase()] = value;
+            }
+        }
+        // Get domain from :authority pseudo-header
+        const authority = headers[':authority'] || '';
+        const domain = authority.split(':')[0];
+        // Get path from :path pseudo-header
+        const path = headers[':path'] || '/';
+        // Parse the path to extract query string
+        const pathParts = path.split('?');
+        const pathname = pathParts[0];
+        const query = pathParts.length > 1 ? pathParts[1] : '';
+        // Get the socket from the session
+        const socket = stream.session?.socket;
+        return {
+            // Connection basics
+            port: socket?.localPort || 0,
+            domain,
+            clientIp: options.clientIp,
+            serverIp: options.serverIp,
+            // HTTP specifics
+            path: pathname,
+            query,
+            headers: processedHeaders,
+            // HTTP/2 specific properties
+            method: headers[':method'],
+            stream,
+            // TLS information - HTTP/2 is always on TLS in browsers
+            isTls: true,
+            tlsVersion: socket?.getTLSVersion?.() || 'TLSv1.3',
+            // Metadata
+            timestamp: Date.now(),
+            connectionId: options.connectionId
+        };
+    }
+    /**
+     * Create a basic route context from socket information
+     */
+    createSocketRouteContext(socket, options) {
+        return {
+            // Connection basics
+            port: socket.localPort || 0,
+            domain: options.domain,
+            clientIp: socket.remoteAddress?.replace('::ffff:', '') || '0.0.0.0',
+            serverIp: socket.localAddress?.replace('::ffff:', '') || '0.0.0.0',
+            // TLS information
+            isTls: options.tlsVersion !== undefined,
+            tlsVersion: options.tlsVersion,
+            // Metadata
+            timestamp: Date.now(),
+            connectionId: options.connectionId
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/{network-proxy → http-proxy}/function-cache.js

@@ -195,4 +195,4 @@ export class FunctionCache {
         this.logger.info('Function cache cleared');
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb24tY2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL2h0dHAtcHJveHkvZnVuY3Rpb24tY2FjaGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWUE7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sYUFBYTtJQWN4Qjs7Ozs7T0FLRztJQUNILFlBQ0UsTUFBZSxFQUNmLFVBR0ksRUFBRTtRQXhCUixnQkFBZ0I7UUFDUixjQUFTLEdBQWtELElBQUksR0FBRyxFQUFFLENBQUM7UUFDckUsY0FBUyxHQUF1QyxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBd0JoRSxJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixJQUFJLENBQUMsWUFBWSxHQUFHLE9BQU8sQ0FBQyxZQUFZLElBQUksSUFBSSxDQUFDO1FBQ2pELElBQUksQ0FBQyxVQUFVLEdBQUcsT0FBTyxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUMsQ0FBQyxvQkFBb0I7UUFFbEUsZ0NBQWdDO1FBQ2hDLFdBQVcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQywyQkFBMkI7SUFDNUUsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSyxrQkFBa0IsQ0FBQyxPQUFzQixFQUFFLFVBQWtCO1FBQ25FLDJDQUEyQztRQUMzQyxNQUFNLFFBQVEsR0FBRztZQUNmLFVBQVU7WUFDVixJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUk7WUFDbEIsTUFBTSxFQUFFLE9BQU8sQ0FBQyxNQUFNO1lBQ3RCLFFBQVEsRUFBRSxPQUFPLENBQUMsUUFBUTtZQUMxQixJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUk7WUFDbEIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1lBQ3BCLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSztZQUNwQixVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7U0FDL0IsQ0FBQztRQUVGLHlCQUF5QjtRQUN6QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNJLGFBQWEsQ0FBQyxPQUFzQixFQUFFLFVBQWtCO1FBQzdELE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDMUQsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFeEMsdUNBQXVDO1FBQ3ZDLElBQUksQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQztZQUMxQyxJQUFJLE1BQU0sRUFBRSxDQUFDO2dCQUNYLGdDQUFnQztnQkFDaEMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQzVCLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLDJDQUEyQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO1lBQzdFLENBQUM7aUJBQU0sQ0FBQztnQkFDTixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxpQ0FBaUMsVUFBVSxFQUFFLENBQUMsQ0FBQztZQUNuRSxDQUFDO1lBQ0QsT0FBTyxTQUFTLENBQUM7UUFDbkIsQ0FBQztRQUVELElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLGdDQUFnQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO1FBQ2hFLE9BQU8sTUFBTSxDQUFDLEtBQUssQ0FBQztJQUN0QixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksYUFBYSxDQUFDLE9BQXNCLEVBQUUsVUFBa0I7UUFDN0QsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMxRCxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUV4Qyx1Q0FBdUM7UUFDdkMsSUFBSSxDQUFDLE1BQU0sSUFBSSxNQUFNLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDO1lBQzFDLElBQUksTUFBTSxFQUFFLENBQUM7Z0JBQ1gsZ0NBQWdDO2dCQUNoQyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDNUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsMkNBQTJDLFVBQVUsRUFBRSxDQUFDLENBQUM7WUFDN0UsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLGlDQUFpQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO1lBQ25FLENBQUM7WUFDRCxPQUFPLFNBQVMsQ0FBQztRQUNuQixDQUFDO1FBRUQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsZ0NBQWdDLFVBQVUsRUFBRSxDQUFDLENBQUM7UUFDaEUsT0FBTyxNQUFNLENBQUMsS0FBSyxDQUFDO0lBQ3RCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0ksU0FBUyxDQUNkLE9BQXNCLEVBQ3RCLFVBQWtCLEVBQ2xCLEtBQXdCLEVBQ3hCLEdBQVk7UUFFWixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQzFELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLEdBQUcsSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFckQsb0RBQW9EO1FBQ3BELElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQzdDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDMUMsQ0FBQztRQUVELG1CQUFtQjtRQUNuQixJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDbEQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsb0NBQW9DLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDdEUsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSSxTQUFTLENBQ2QsT0FBc0IsRUFDdEIsVUFBa0IsRUFDbEIsS0FBYSxFQUNiLEdBQVk7UUFFWixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQzFELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLEdBQUcsSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFckQsb0RBQW9EO1FBQ3BELElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQzdDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDMUMsQ0FBQztRQUVELG1CQUFtQjtRQUNuQixJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDbEQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsb0NBQW9DLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDdEUsQ0FBQztJQUVEOztPQUVHO0lBQ0ssWUFBWTtRQUNsQixNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDdkIsSUFBSSxZQUFZLEdBQUcsQ0FBQyxDQUFDO1FBRXJCLHNCQUFzQjtRQUN0QixLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDO1lBQ3RELElBQUksTUFBTSxDQUFDLE1BQU0sR0FBRyxHQUFHLEVBQUUsQ0FBQztnQkFDeEIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQzVCLFlBQVksRUFBRSxDQUFDO1lBQ2pCLENBQUM7UUFDSCxDQUFDO1FBRUQsc0JBQXNCO1FBQ3RCLEtBQUssTUFBTSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUM7WUFDdEQsSUFBSSxNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsRUFBRSxDQUFDO2dCQUN4QixJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDNUIsWUFBWSxFQUFFLENBQUM7WUFDakIsQ0FBQztRQUNILENBQUM7UUFFRCxJQUFJLFlBQVksR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNyQixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxjQUFjLFlBQVksd0JBQXdCLENBQUMsQ0FBQztRQUN4RSxDQUFDO0lBQ0gsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ssa0JBQWtCLENBQUksS0FBb0M7UUFDaEUsMEJBQTBCO1FBQzFCLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUN2QixNQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxZQUFZLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQywwQkFBMEI7UUFFckYsK0JBQStCO1FBQy9CLE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFFNUMsZ0NBQWdDO1FBQ2hDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVsRCx3QkFBd0I7UUFDeEIsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFDakQsS0FBSyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksUUFBUSxFQUFFLENBQUM7WUFDOUIsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNyQixDQUFDO1FBRUQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsVUFBVSxRQUFRLENBQUMsTUFBTSx1QkFBdUIsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7SUFFRDs7T0FFRztJQUNJLFFBQVE7UUFDYixPQUFPO1lBQ0wsYUFBYSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSTtZQUNsQyxhQUFhLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJO1NBQ25DLENBQUM7SUFDSixDQUFDO0lBRUQ7O09BRUc7SUFDSSxVQUFVO1FBQ2YsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUN2QixJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLHdCQUF3QixDQUFDLENBQUM7SUFDN0MsQ0FBQztDQUNGIn0=

package/dist_ts/proxies/http-proxy/handlers/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * HTTP handlers for various route types
+ */
+export { RedirectHandler } from './redirect-handler.js';
+export { StaticHandler } from './static-handler.js';

package/dist_ts/proxies/http-proxy/handlers/index.js

@@ -0,0 +1,6 @@
+/**
+ * HTTP handlers for various route types
+ */
+export { RedirectHandler } from './redirect-handler.js';
+export { StaticHandler } from './static-handler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL2h0dHAtcHJveHkvaGFuZGxlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDIn0=

package/dist_ts/proxies/http-proxy/handlers/redirect-handler.d.ts

@@ -0,0 +1,18 @@
+import * as plugins from '../../../plugins.js';
+import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
+import type { ILogger } from '../models/types.js';
+export interface IRedirectHandlerContext {
+    connectionId: string;
+    connectionManager: any;
+    settings: any;
+    logger?: ILogger;
+}
+/**
+ * Handles HTTP redirect routes
+ */
+export declare class RedirectHandler {
+    /**
+     * Handle redirect routes
+     */
+    static handleRedirect(socket: plugins.net.Socket, route: IRouteConfig, context: IRedirectHandlerContext): Promise<void>;
+}

package/dist_ts/proxies/http-proxy/handlers/redirect-handler.js

@@ -0,0 +1,78 @@
+import * as plugins from '../../../plugins.js';
+import { createLogger } from '../models/types.js';
+import { HttpStatus, getStatusText } from '../models/http-types.js';
+/**
+ * Handles HTTP redirect routes
+ */
+export class RedirectHandler {
+    /**
+     * Handle redirect routes
+     */
+    static async handleRedirect(socket, route, context) {
+        const { connectionId, connectionManager, settings } = context;
+        const logger = context.logger || createLogger(settings.logLevel || 'info');
+        const action = route.action;
+        // We should have a redirect configuration
+        if (!action.redirect) {
+            logger.error(`[${connectionId}] Redirect action missing redirect configuration`);
+            socket.end();
+            connectionManager.cleanupConnection({ id: connectionId }, 'missing_redirect');
+            return;
+        }
+        // For TLS connections, we can't do redirects at the TCP level
+        // This check should be done before calling this handler
+        // Wait for the first HTTP request to perform the redirect
+        const dataListeners = [];
+        const httpDataHandler = (chunk) => {
+            // Remove all data listeners to avoid duplicated processing
+            for (const listener of dataListeners) {
+                socket.removeListener('data', listener);
+            }
+            // Parse HTTP request to get path
+            try {
+                const headersEnd = chunk.indexOf('\r\n\r\n');
+                if (headersEnd === -1) {
+                    // Not a complete HTTP request, need more data
+                    socket.once('data', httpDataHandler);
+                    dataListeners.push(httpDataHandler);
+                    return;
+                }
+                const httpHeaders = chunk.slice(0, headersEnd).toString();
+                const requestLine = httpHeaders.split('\r\n')[0];
+                const [method, path] = requestLine.split(' ');
+                // Extract Host header
+                const hostMatch = httpHeaders.match(/Host: (.+?)(\r\n|\r|\n|$)/i);
+                const host = hostMatch ? hostMatch[1].trim() : '';
+                // Process the redirect URL with template variables
+                let redirectUrl = action.redirect.to;
+                redirectUrl = redirectUrl.replace(/\{domain\}/g, host);
+                redirectUrl = redirectUrl.replace(/\{path\}/g, path || '');
+                redirectUrl = redirectUrl.replace(/\{port\}/g, socket.localPort?.toString() || '80');
+                // Prepare the HTTP redirect response
+                const redirectResponse = [
+                    `HTTP/1.1 ${action.redirect.status} Moved`,
+                    `Location: ${redirectUrl}`,
+                    'Connection: close',
+                    'Content-Length: 0',
+                    '',
+                    '',
+                ].join('\r\n');
+                if (settings.enableDetailedLogging) {
+                    logger.info(`[${connectionId}] Redirecting to ${redirectUrl} with status ${action.redirect.status}`);
+                }
+                // Send the redirect response
+                socket.end(redirectResponse);
+                connectionManager.initiateCleanupOnce({ id: connectionId }, 'redirect_complete');
+            }
+            catch (err) {
+                logger.error(`[${connectionId}] Error processing HTTP redirect: ${err}`);
+                socket.end();
+                connectionManager.initiateCleanupOnce({ id: connectionId }, 'redirect_error');
+            }
+        };
+        // Setup the HTTP data handler
+        socket.once('data', httpDataHandler);
+        dataListeners.push(httpDataHandler);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/http-proxy/handlers/static-handler.d.ts

@@ -0,0 +1,19 @@
+import * as plugins from '../../../plugins.js';
+import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
+import type { IConnectionRecord } from '../../smart-proxy/models/interfaces.js';
+import type { ILogger } from '../models/types.js';
+export interface IStaticHandlerContext {
+    connectionId: string;
+    connectionManager: any;
+    settings: any;
+    logger?: ILogger;
+}
+/**
+ * Handles static routes including ACME challenges
+ */
+export declare class StaticHandler {
+    /**
+     * Handle static routes
+     */
+    static handleStatic(socket: plugins.net.Socket, route: IRouteConfig, context: IStaticHandlerContext, record: IConnectionRecord): Promise<void>;
+}