@push.rocks/smartproxy 21.1.7 → 22.6.0

package/dist_ts/proxies/smart-proxy/socket-handler-server.d.ts

@@ -0,0 +1,45 @@
+import type { RoutePreprocessor } from './route-preprocessor.js';
+/**
+ * Unix domain socket server that receives relayed connections from the Rust proxy.
+ *
+ * When Rust encounters a route of type `socket-handler`, it connects to this
+ * Unix socket, sends a JSON metadata line, then proxies the raw TCP bytes.
+ * This server reads the metadata, finds the original JS handler, builds an
+ * IRouteContext, and hands the socket to the handler.
+ */
+export declare class SocketHandlerServer {
+    private server;
+    private socketPath;
+    private preprocessor;
+    private activeSockets;
+    constructor(preprocessor: RoutePreprocessor);
+    /**
+     * The Unix socket path this server listens on.
+     */
+    getSocketPath(): string;
+    /**
+     * Start listening for relayed connections from Rust.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server and clean up.
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle an incoming relayed connection from Rust.
+     *
+     * Protocol: Rust sends a single JSON line with metadata, then raw bytes follow.
+     * JSON format: { "routeKey": "my-route", "remoteIP": "1.2.3.4", "remotePort": 12345,
+     *                "localPort": 443, "isTLS": true, "domain": "example.com" }
+     */
+    private handleConnection;
+    /**
+     * Dispatch a relayed connection to the appropriate JS handler.
+     */
+    private dispatchToHandler;
+    /**
+     * Forward a connection to a dynamically resolved target.
+     * Used for routes with function-based host/port that Rust cannot handle.
+     */
+    private forwardDynamicRoute;
+}

package/dist_ts/proxies/smart-proxy/socket-handler-server.js

@@ -0,0 +1,253 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../core/utils/logger.js';
+/**
+ * Unix domain socket server that receives relayed connections from the Rust proxy.
+ *
+ * When Rust encounters a route of type `socket-handler`, it connects to this
+ * Unix socket, sends a JSON metadata line, then proxies the raw TCP bytes.
+ * This server reads the metadata, finds the original JS handler, builds an
+ * IRouteContext, and hands the socket to the handler.
+ */
+export class SocketHandlerServer {
+    constructor(preprocessor) {
+        this.server = null;
+        this.activeSockets = new Set();
+        this.preprocessor = preprocessor;
+        this.socketPath = `/tmp/smartproxy-relay-${process.pid}.sock`;
+    }
+    /**
+     * The Unix socket path this server listens on.
+     */
+    getSocketPath() {
+        return this.socketPath;
+    }
+    /**
+     * Start listening for relayed connections from Rust.
+     */
+    async start() {
+        // Clean up stale socket file
+        try {
+            await plugins.fs.promises.unlink(this.socketPath);
+        }
+        catch {
+            // Ignore if doesn't exist
+        }
+        return new Promise((resolve, reject) => {
+            this.server = plugins.net.createServer((socket) => {
+                this.activeSockets.add(socket);
+                socket.on('close', () => this.activeSockets.delete(socket));
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                logger.log('error', `SocketHandlerServer error: ${err.message}`, { component: 'socket-handler-server' });
+            });
+            this.server.listen(this.socketPath, () => {
+                logger.log('info', `SocketHandlerServer listening on ${this.socketPath}`, { component: 'socket-handler-server' });
+                resolve();
+            });
+            this.server.on('error', reject);
+        });
+    }
+    /**
+     * Stop the server and clean up.
+     */
+    async stop() {
+        // Destroy all active connections first
+        for (const socket of this.activeSockets) {
+            socket.destroy();
+        }
+        this.activeSockets.clear();
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server.close(() => {
+                    this.server = null;
+                    // Clean up socket file
+                    plugins.fs.unlink(this.socketPath, () => resolve());
+                });
+            });
+        }
+    }
+    /**
+     * Handle an incoming relayed connection from Rust.
+     *
+     * Protocol: Rust sends a single JSON line with metadata, then raw bytes follow.
+     * JSON format: { "routeKey": "my-route", "remoteIP": "1.2.3.4", "remotePort": 12345,
+     *                "localPort": 443, "isTLS": true, "domain": "example.com" }
+     */
+    handleConnection(socket) {
+        let metadataBuffer = '';
+        let metadataParsed = false;
+        const onData = (chunk) => {
+            if (metadataParsed)
+                return;
+            metadataBuffer += chunk.toString('utf8');
+            const newlineIndex = metadataBuffer.indexOf('\n');
+            if (newlineIndex === -1) {
+                // Haven't received full metadata line yet
+                if (metadataBuffer.length > 8192) {
+                    logger.log('error', 'Socket handler metadata too large, closing', { component: 'socket-handler-server' });
+                    socket.destroy();
+                }
+                return;
+            }
+            metadataParsed = true;
+            socket.removeListener('data', onData);
+            socket.pause(); // Prevent data loss between handler removal and pipe setup
+            const metadataJson = metadataBuffer.slice(0, newlineIndex);
+            const remainingData = metadataBuffer.slice(newlineIndex + 1);
+            let metadata;
+            try {
+                metadata = JSON.parse(metadataJson);
+            }
+            catch {
+                logger.log('error', `Invalid socket handler metadata JSON: ${metadataJson.slice(0, 200)}`, { component: 'socket-handler-server' });
+                socket.destroy();
+                return;
+            }
+            this.dispatchToHandler(socket, metadata, remainingData);
+        };
+        socket.on('data', onData);
+        socket.on('error', (err) => {
+            logger.log('error', `Socket handler relay error: ${err.message}`, { component: 'socket-handler-server' });
+        });
+    }
+    /**
+     * Dispatch a relayed connection to the appropriate JS handler.
+     */
+    dispatchToHandler(socket, metadata, remainingData) {
+        const routeKey = metadata.routeKey;
+        if (!routeKey) {
+            logger.log('error', 'Socket handler relay missing routeKey', { component: 'socket-handler-server' });
+            socket.destroy();
+            return;
+        }
+        const originalRoute = this.preprocessor.getOriginalRoute(routeKey);
+        if (!originalRoute) {
+            logger.log('error', `No handler found for route: ${routeKey}`, { component: 'socket-handler-server' });
+            socket.destroy();
+            return;
+        }
+        // Build route context
+        const context = {
+            port: metadata.localPort || 0,
+            domain: metadata.domain,
+            clientIp: metadata.remoteIP || 'unknown',
+            serverIp: '0.0.0.0',
+            path: metadata.path,
+            isTls: metadata.isTLS || false,
+            tlsVersion: metadata.tlsVersion,
+            routeName: originalRoute.name,
+            routeId: originalRoute.id,
+            timestamp: Date.now(),
+            connectionId: metadata.connectionId || `relay-${Date.now()}`,
+        };
+        // If there was remaining data after the metadata line, push it back
+        if (remainingData.length > 0) {
+            socket.unshift(Buffer.from(remainingData, 'utf8'));
+        }
+        const handler = originalRoute.action.socketHandler;
+        if (handler) {
+            // Route has an explicit socket handler callback
+            try {
+                const result = handler(socket, context);
+                // If the handler is async, wait for it to finish setup before resuming.
+                // This prevents data loss when async handlers need to do work before
+                // attaching their `data` listeners.
+                if (result && typeof result.then === 'function') {
+                    result.then(() => {
+                        socket.resume();
+                    }).catch((err) => {
+                        logger.log('error', `Async socket handler rejected for route ${routeKey}: ${err.message}`, { component: 'socket-handler-server' });
+                        socket.destroy();
+                    });
+                }
+                else {
+                    // Synchronous handler — listeners are already attached, safe to resume.
+                    socket.resume();
+                }
+            }
+            catch (err) {
+                logger.log('error', `Socket handler threw for route ${routeKey}: ${err.message}`, { component: 'socket-handler-server' });
+                socket.destroy();
+            }
+            return;
+        }
+        // Route has dynamic host/port functions - resolve and forward
+        if (originalRoute.action.targets && originalRoute.action.targets.length > 0) {
+            this.forwardDynamicRoute(socket, originalRoute, context);
+            return;
+        }
+        logger.log('error', `Route ${routeKey} has no socketHandler and no targets`, { component: 'socket-handler-server' });
+        socket.destroy();
+    }
+    /**
+     * Forward a connection to a dynamically resolved target.
+     * Used for routes with function-based host/port that Rust cannot handle.
+     */
+    forwardDynamicRoute(socket, route, context) {
+        const targets = route.action.targets;
+        // Pick a target (round-robin would be ideal, but simple random for now)
+        const target = targets[Math.floor(Math.random() * targets.length)];
+        // Resolve host
+        let host;
+        if (typeof target.host === 'function') {
+            try {
+                const result = target.host(context);
+                host = Array.isArray(result) ? result[Math.floor(Math.random() * result.length)] : result;
+            }
+            catch (err) {
+                logger.log('error', `Dynamic host function failed: ${err.message}`, { component: 'socket-handler-server' });
+                socket.destroy();
+                return;
+            }
+        }
+        else if (typeof target.host === 'string') {
+            host = target.host;
+        }
+        else if (Array.isArray(target.host)) {
+            host = target.host[Math.floor(Math.random() * target.host.length)];
+        }
+        else {
+            host = 'localhost';
+        }
+        // Resolve port
+        let port;
+        if (typeof target.port === 'function') {
+            try {
+                port = target.port(context);
+            }
+            catch (err) {
+                logger.log('error', `Dynamic port function failed: ${err.message}`, { component: 'socket-handler-server' });
+                socket.destroy();
+                return;
+            }
+        }
+        else if (typeof target.port === 'number') {
+            port = target.port;
+        }
+        else {
+            port = context.port;
+        }
+        logger.log('debug', `Dynamic forward: ${context.clientIp} -> ${host}:${port}`, { component: 'socket-handler-server' });
+        // Connect to the resolved target
+        const backend = plugins.net.connect(port, host, () => {
+            // Pipe bidirectionally
+            socket.pipe(backend);
+            backend.pipe(socket);
+        });
+        backend.on('error', (err) => {
+            logger.log('error', `Dynamic forward backend error: ${err.message}`, { component: 'socket-handler-server' });
+            socket.destroy();
+        });
+        socket.on('error', () => {
+            backend.destroy();
+        });
+        socket.on('close', () => {
+            backend.destroy();
+        });
+        backend.on('close', () => {
+            socket.destroy();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"socket-handler-server.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/socket-handler-server.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/tls-manager.d.ts

@@ -27,15 +27,8 @@ export declare class TlsManager {
      */
     extractSNI(chunk: Buffer, connInfo: IConnectionInfo, previousDomain?: string): string | undefined;
     /**
-     * Handle session resumption attempts
-     */
-    handleSessionResumption(chunk: Buffer, connectionId: string, hasSNI: boolean): {
-        shouldBlock: boolean;
-        reason?: string;
-    };
-    /**
-     * Check for SNI mismatch during renegotiation
-     */
+       * Check for SNI mismatch during renegotiation
+       */
     checkRenegotiationSNI(chunk: Buffer, connInfo: IConnectionInfo, expectedDomain: string, connectionId: string): {
         hasMismatch: boolean;
         extractedSNI?: string;

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

@@ -28,31 +28,8 @@ export class TlsManager {
         return SniHandler.processTlsPacket(chunk, connInfo, this.smartProxy.settings.enableTlsDebugLogging || false, previousDomain);
     }
     /**
-     * Handle session resumption attempts
-     */
-    handleSessionResumption(chunk, connectionId, hasSNI) {
-        // Skip if session tickets are allowed
-        if (this.smartProxy.settings.allowSessionTicket !== false) {
-            return { shouldBlock: false };
-        }
-        // Check for session resumption attempt
-        const resumptionInfo = SniHandler.hasSessionResumption(chunk, this.smartProxy.settings.enableTlsDebugLogging || false);
-        // If this is a resumption attempt without SNI, block it
-        if (resumptionInfo.isResumption && !hasSNI && !resumptionInfo.hasSNI) {
-            if (this.smartProxy.settings.enableTlsDebugLogging) {
-                console.log(`[${connectionId}] Session resumption detected without SNI and allowSessionTicket=false. ` +
-                    `Terminating connection to force new TLS handshake.`);
-            }
-            return {
-                shouldBlock: true,
-                reason: 'session_ticket_blocked'
-            };
-        }
-        return { shouldBlock: false };
-    }
-    /**
-     * Check for SNI mismatch during renegotiation
-     */
+       * Check for SNI mismatch during renegotiation
+       */
     checkRenegotiationSNI(chunk, connInfo, expectedDomain, connectionId) {
         // Only process if this looks like a TLS ClientHello
         if (!this.isClientHello(chunk)) {
@@ -130,4 +107,4 @@ export class TlsManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/utils/index.d.ts

@@ -5,6 +5,6 @@
  * including helpers, validators, utilities, and patterns for working with routes.
  */
 export * from './route-helpers.js';
-export * from './route-validators.js';
+export * from './route-validator.js';
 export * from './route-utils.js';
 export { createApiGatewayRoute, addRateLimiting, addBasicAuth, addJwtAuth } from './route-helpers.js';

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

@@ -6,11 +6,10 @@
  */
 // Export route helpers for creating route configurations
 export * from './route-helpers.js';
-// Export route validators for validating route configurations
-export * from './route-validators.js';
+// Export route validator (class-based and functional API)
+export * from './route-validator.js';
 // Export route utilities for route operations
 export * from './route-utils.js';
 // Export additional functions from route-helpers that weren't already exported
 export { createApiGatewayRoute, addRateLimiting, addBasicAuth, addJwtAuth } from './route-helpers.js';
-// Migration utilities have been removed as they are no longer needed
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgseURBQXlEO0FBQ3pELGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsOERBQThEO0FBQzlELGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsOENBQThDO0FBQzlDLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsK0VBQStFO0FBQy9FLE9BQU8sRUFDTCxxQkFBcUIsRUFDckIsZUFBZSxFQUNmLFlBQVksRUFDWixVQUFVLEVBQ1gsTUFBTSxvQkFBb0IsQ0FBQztBQUU1QixxRUFBcUUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgseURBQXlEO0FBQ3pELGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsMERBQTBEO0FBQzFELGNBQWMsc0JBQXNCLENBQUM7QUFFckMsOENBQThDO0FBQzlDLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsK0VBQStFO0FBQy9FLE9BQU8sRUFDTCxxQkFBcUIsRUFDckIsZUFBZSxFQUNmLFlBQVksRUFDWixVQUFVLEVBQ1gsTUFBTSxvQkFBb0IsQ0FBQyJ9

package/dist_ts/proxies/smart-proxy/utils/route-helpers/api-helpers.d.ts

@@ -0,0 +1,49 @@
+/**
+ * API Route Helper Functions
+ *
+ * This module provides utility functions for creating API route configurations.
+ */
+import type { IRouteConfig } from '../../models/route-types.js';
+/**
+ * Create an API route configuration
+ * @param domains Domain(s) to match
+ * @param apiPath API base path (e.g., "/api")
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createApiRoute(domains: string | string[], apiPath: string, target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    addCorsHeaders?: boolean;
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create an API Gateway route pattern
+ * @param domains Domain(s) to match
+ * @param apiBasePath Base path for API endpoints (e.g., '/api')
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns API route configuration
+ */
+export declare function createApiGatewayRoute(domains: string | string[], apiBasePath: string, target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    addCorsHeaders?: boolean;
+    [key: string]: any;
+}): IRouteConfig;

package/dist_ts/proxies/smart-proxy/utils/route-helpers/api-helpers.js

@@ -0,0 +1,108 @@
+/**
+ * API Route Helper Functions
+ *
+ * This module provides utility functions for creating API route configurations.
+ */
+import { mergeRouteConfigs } from '../route-utils.js';
+import { createHttpRoute } from './http-helpers.js';
+import { createHttpsTerminateRoute } from './https-helpers.js';
+/**
+ * Create an API route configuration
+ * @param domains Domain(s) to match
+ * @param apiPath API base path (e.g., "/api")
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createApiRoute(domains, apiPath, target, options = {}) {
+    // Normalize API path
+    const normalizedPath = apiPath.startsWith('/') ? apiPath : `/${apiPath}`;
+    const pathWithWildcard = normalizedPath.endsWith('/')
+        ? `${normalizedPath}*`
+        : `${normalizedPath}/*`;
+    // Create route match
+    const match = {
+        ports: options.useTls
+            ? (options.httpsPort || 443)
+            : (options.httpPort || 80),
+        domains,
+        path: pathWithWildcard
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target]
+    };
+    // Add TLS configuration if using HTTPS
+    if (options.useTls) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    // Add CORS headers if requested
+    const headers = {};
+    if (options.addCorsHeaders) {
+        headers.response = {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+            'Access-Control-Max-Age': '86400'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        headers: Object.keys(headers).length > 0 ? headers : undefined,
+        name: options.name || `API Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: options.priority || 100, // Higher priority for specific path matches
+        ...options
+    };
+}
+/**
+ * Create an API Gateway route pattern
+ * @param domains Domain(s) to match
+ * @param apiBasePath Base path for API endpoints (e.g., '/api')
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns API route configuration
+ */
+export function createApiGatewayRoute(domains, apiBasePath, target, options = {}) {
+    // Normalize apiBasePath to ensure it starts with / and doesn't end with /
+    const normalizedPath = apiBasePath.startsWith('/')
+        ? apiBasePath
+        : `/${apiBasePath}`;
+    // Add wildcard to path to match all API endpoints
+    const apiPath = normalizedPath.endsWith('/')
+        ? `${normalizedPath}*`
+        : `${normalizedPath}/*`;
+    // Create base route
+    const baseRoute = options.useTls
+        ? createHttpsTerminateRoute(domains, target, {
+            certificate: options.certificate || 'auto'
+        })
+        : createHttpRoute(domains, target);
+    // Add API-specific configurations
+    const apiRoute = {
+        match: {
+            ...baseRoute.match,
+            path: apiPath
+        },
+        name: options.name || `API Gateway: ${apiPath} -> ${Array.isArray(target.host) ? target.host.join(', ') : target.host}:${target.port}`,
+        priority: options.priority || 100 // Higher priority for specific path matching
+    };
+    // Add CORS headers if requested
+    if (options.addCorsHeaders) {
+        apiRoute.headers = {
+            response: {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                'Access-Control-Max-Age': '86400'
+            }
+        };
+    }
+    return mergeRouteConfigs(baseRoute, apiRoute);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/utils/route-helpers/dynamic-helpers.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Dynamic Route Helper Functions
+ *
+ * This module provides utility functions for creating dynamic routes
+ * with context-based host and port mapping.
+ */
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../models/route-types.js';
+/**
+ * Create a helper function that applies a port offset
+ * @param offset The offset to apply to the matched port
+ * @returns A function that adds the offset to the matched port
+ */
+export declare function createPortOffset(offset: number): (context: IRouteContext) => number;
+/**
+ * Create a port mapping route with context-based port function
+ * @param options Port mapping route options
+ * @returns Route configuration object
+ */
+export declare function createPortMappingRoute(options: {
+    sourcePortRange: TPortRange;
+    targetHost: string | string[] | ((context: IRouteContext) => string | string[]);
+    portMapper: (context: IRouteContext) => number;
+    name?: string;
+    domains?: string | string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a simple offset port mapping route
+ * @param options Offset port mapping route options
+ * @returns Route configuration object
+ */
+export declare function createOffsetPortMappingRoute(options: {
+    ports: TPortRange;
+    targetHost: string | string[];
+    offset: number;
+    name?: string;
+    domains?: string | string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a dynamic route with context-based host and port mapping
+ * @param options Dynamic route options
+ * @returns Route configuration object
+ */
+export declare function createDynamicRoute(options: {
+    ports: TPortRange;
+    targetHost: (context: IRouteContext) => string | string[];
+    portMapper: (context: IRouteContext) => number;
+    name?: string;
+    domains?: string | string[];
+    path?: string;
+    clientIp?: string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;