@push.rocks/smartproxy 21.1.7 → 22.6.0

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

@@ -0,0 +1,126 @@
+/**
+ * NFTables Route Helper Functions
+ *
+ * This module provides utility functions for creating NFTables-based route configurations
+ * for high-performance packet forwarding at the kernel level.
+ */
+import { createHttpToHttpsRedirect } from './https-helpers.js';
+/**
+ * Create an NFTables-based route for high-performance packet forwarding
+ * @param nameOrDomains Name or domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createNfTablesRoute(nameOrDomains, target, options = {}) {
+    // Determine if this is a name or domain
+    let name;
+    let domains;
+    if (Array.isArray(nameOrDomains) || (typeof nameOrDomains === 'string' && nameOrDomains.includes('.'))) {
+        domains = nameOrDomains;
+        name = Array.isArray(nameOrDomains) ? nameOrDomains[0] : nameOrDomains;
+    }
+    else {
+        name = nameOrDomains;
+        domains = undefined; // No domains
+    }
+    // Create route match
+    const match = {
+        domains,
+        ports: options.ports || 80
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [{
+                host: target.host,
+                port: target.port
+            }],
+        forwardingEngine: 'nftables',
+        nftables: {
+            protocol: options.protocol || 'tcp',
+            preserveSourceIP: options.preserveSourceIP,
+            maxRate: options.maxRate,
+            priority: options.priority,
+            tableName: options.tableName,
+            useIPSets: options.useIPSets,
+            useAdvancedNAT: options.useAdvancedNAT
+        }
+    };
+    // Add TLS options if needed
+    if (options.useTls) {
+        action.tls = {
+            mode: 'passthrough'
+        };
+    }
+    // Create the route config
+    const routeConfig = {
+        name,
+        match,
+        action
+    };
+    // Add security if allowed or blocked IPs are specified
+    if (options.ipAllowList?.length || options.ipBlockList?.length) {
+        routeConfig.security = {
+            ipAllowList: options.ipAllowList,
+            ipBlockList: options.ipBlockList
+        };
+    }
+    return routeConfig;
+}
+/**
+ * Create an NFTables-based TLS termination route
+ * @param nameOrDomains Name or domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createNfTablesTerminateRoute(nameOrDomains, target, options = {}) {
+    // Create basic NFTables route
+    const route = createNfTablesRoute(nameOrDomains, target, {
+        ...options,
+        ports: options.ports || 443,
+        useTls: false
+    });
+    // Set TLS termination
+    route.action.tls = {
+        mode: 'terminate',
+        certificate: options.certificate || 'auto'
+    };
+    return route;
+}
+/**
+ * Create a complete NFTables-based HTTPS setup with HTTP redirect
+ * @param nameOrDomains Name or domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export function createCompleteNfTablesHttpsServer(nameOrDomains, target, options = {}) {
+    // Create the HTTPS route using NFTables
+    const httpsRoute = createNfTablesTerminateRoute(nameOrDomains, target, {
+        ...options,
+        ports: options.httpsPort || 443
+    });
+    // Determine the domain(s) for HTTP redirect
+    const domains = typeof nameOrDomains === 'string' && !nameOrDomains.includes('.')
+        ? undefined
+        : nameOrDomains;
+    // Extract the HTTPS port for the redirect destination
+    const httpsPort = typeof options.httpsPort === 'number'
+        ? options.httpsPort
+        : Array.isArray(options.httpsPort) && typeof options.httpsPort[0] === 'number'
+            ? options.httpsPort[0]
+            : 443;
+    // Create the HTTP redirect route (this uses standard forwarding, not NFTables)
+    const httpRedirectRoute = createHttpToHttpsRedirect(domains, // Type cast needed since domains can be undefined now
+    httpsPort, {
+        match: {
+            ports: options.httpPort || 80,
+            domains: domains // Type cast needed since domains can be undefined now
+        },
+        name: `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains || 'all domains'}`
+    });
+    return [httpsRoute, httpRedirectRoute];
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,47 @@
+/**
+ * Security Route Helper Functions
+ *
+ * This module provides utility functions for adding security features to routes.
+ */
+import type { IRouteConfig } from '../../models/route-types.js';
+/**
+ * Create a rate limiting route pattern
+ * @param baseRoute Base route to add rate limiting to
+ * @param rateLimit Rate limiting configuration
+ * @returns Route with rate limiting
+ */
+export declare function addRateLimiting(baseRoute: IRouteConfig, rateLimit: {
+    maxRequests: number;
+    window: number;
+    keyBy?: 'ip' | 'path' | 'header';
+    headerName?: string;
+    errorMessage?: string;
+}): IRouteConfig;
+/**
+ * Create a basic authentication route pattern
+ * @param baseRoute Base route to add authentication to
+ * @param auth Authentication configuration
+ * @returns Route with basic authentication
+ */
+export declare function addBasicAuth(baseRoute: IRouteConfig, auth: {
+    users: Array<{
+        username: string;
+        password: string;
+    }>;
+    realm?: string;
+    excludePaths?: string[];
+}): IRouteConfig;
+/**
+ * Create a JWT authentication route pattern
+ * @param baseRoute Base route to add JWT authentication to
+ * @param jwt JWT authentication configuration
+ * @returns Route with JWT authentication
+ */
+export declare function addJwtAuth(baseRoute: IRouteConfig, jwt: {
+    secret: string;
+    algorithm?: string;
+    issuer?: string;
+    audience?: string;
+    expiresIn?: number;
+    excludePaths?: string[];
+}): IRouteConfig;

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

@@ -0,0 +1,66 @@
+/**
+ * Security Route Helper Functions
+ *
+ * This module provides utility functions for adding security features to routes.
+ */
+import { mergeRouteConfigs } from '../route-utils.js';
+/**
+ * Create a rate limiting route pattern
+ * @param baseRoute Base route to add rate limiting to
+ * @param rateLimit Rate limiting configuration
+ * @returns Route with rate limiting
+ */
+export function addRateLimiting(baseRoute, rateLimit) {
+    return mergeRouteConfigs(baseRoute, {
+        security: {
+            rateLimit: {
+                enabled: true,
+                maxRequests: rateLimit.maxRequests,
+                window: rateLimit.window,
+                keyBy: rateLimit.keyBy || 'ip',
+                headerName: rateLimit.headerName,
+                errorMessage: rateLimit.errorMessage || 'Rate limit exceeded. Please try again later.'
+            }
+        }
+    });
+}
+/**
+ * Create a basic authentication route pattern
+ * @param baseRoute Base route to add authentication to
+ * @param auth Authentication configuration
+ * @returns Route with basic authentication
+ */
+export function addBasicAuth(baseRoute, auth) {
+    return mergeRouteConfigs(baseRoute, {
+        security: {
+            basicAuth: {
+                enabled: true,
+                users: auth.users,
+                realm: auth.realm || 'Restricted Area',
+                excludePaths: auth.excludePaths || []
+            }
+        }
+    });
+}
+/**
+ * Create a JWT authentication route pattern
+ * @param baseRoute Base route to add JWT authentication to
+ * @param jwt JWT authentication configuration
+ * @returns Route with JWT authentication
+ */
+export function addJwtAuth(baseRoute, jwt) {
+    return mergeRouteConfigs(baseRoute, {
+        security: {
+            jwtAuth: {
+                enabled: true,
+                secret: jwt.secret,
+                algorithm: jwt.algorithm || 'HS256',
+                issuer: jwt.issuer,
+                audience: jwt.audience,
+                expiresIn: jwt.expiresIn,
+                excludePaths: jwt.excludePaths || []
+            }
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjdXJpdHktaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvdXRpbHMvcm91dGUtaGVscGVycy9zZWN1cml0eS1oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFHSCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUV0RDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQzdCLFNBQXVCLEVBQ3ZCLFNBTUM7SUFFRCxPQUFPLGlCQUFpQixDQUFDLFNBQVMsRUFBRTtRQUNsQyxRQUFRLEVBQUU7WUFDUixTQUFTLEVBQUU7Z0JBQ1QsT0FBTyxFQUFFLElBQUk7Z0JBQ2IsV0FBVyxFQUFFLFNBQVMsQ0FBQyxXQUFXO2dCQUNsQyxNQUFNLEVBQUUsU0FBUyxDQUFDLE1BQU07Z0JBQ3hCLEtBQUssRUFBRSxTQUFTLENBQUMsS0FBSyxJQUFJLElBQUk7Z0JBQzlCLFVBQVUsRUFBRSxTQUFTLENBQUMsVUFBVTtnQkFDaEMsWUFBWSxFQUFFLFNBQVMsQ0FBQyxZQUFZLElBQUksOENBQThDO2FBQ3ZGO1NBQ0Y7S0FDRixDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUMxQixTQUF1QixFQUN2QixJQUlDO0lBRUQsT0FBTyxpQkFBaUIsQ0FBQyxTQUFTLEVBQUU7UUFDbEMsUUFBUSxFQUFFO1lBQ1IsU0FBUyxFQUFFO2dCQUNULE9BQU8sRUFBRSxJQUFJO2dCQUNiLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSztnQkFDakIsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLLElBQUksaUJBQWlCO2dCQUN0QyxZQUFZLEVBQUUsSUFBSSxDQUFDLFlBQVksSUFBSSxFQUFFO2FBQ3RDO1NBQ0Y7S0FDRixDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsVUFBVSxDQUN4QixTQUF1QixFQUN2QixHQU9DO0lBRUQsT0FBTyxpQkFBaUIsQ0FBQyxTQUFTLEVBQUU7UUFDbEMsUUFBUSxFQUFFO1lBQ1IsT0FBTyxFQUFFO2dCQUNQLE9BQU8sRUFBRSxJQUFJO2dCQUNiLE1BQU0sRUFBRSxHQUFHLENBQUMsTUFBTTtnQkFDbEIsU0FBUyxFQUFFLEdBQUcsQ0FBQyxTQUFTLElBQUksT0FBTztnQkFDbkMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxNQUFNO2dCQUNsQixRQUFRLEVBQUUsR0FBRyxDQUFDLFFBQVE7Z0JBQ3RCLFNBQVMsRUFBRSxHQUFHLENBQUMsU0FBUztnQkFDeEIsWUFBWSxFQUFFLEdBQUcsQ0FBQyxZQUFZLElBQUksRUFBRTthQUNyQztTQUNGO0tBQ0YsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyJ9

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

@@ -0,0 +1,70 @@
+/**
+ * Socket Handler Functions
+ *
+ * This module provides pre-built socket handlers for common use cases
+ * like echoing, proxying, HTTP responses, and redirects.
+ */
+import * as plugins from '../../../../plugins.js';
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../models/route-types.js';
+/**
+ * Pre-built socket handlers for common use cases
+ */
+export declare const SocketHandlers: {
+    /**
+     * Simple echo server handler
+     */
+    echo: (socket: plugins.net.Socket, context: IRouteContext) => void;
+    /**
+     * TCP proxy handler
+     */
+    proxy: (targetHost: string, targetPort: number) => (socket: plugins.net.Socket, context: IRouteContext) => void;
+    /**
+     * Line-based protocol handler
+     */
+    lineProtocol: (handler: (line: string, socket: plugins.net.Socket) => void) => (socket: plugins.net.Socket, context: IRouteContext) => void;
+    /**
+     * Simple HTTP response handler (for testing)
+     */
+    httpResponse: (statusCode: number, body: string) => (socket: plugins.net.Socket, context: IRouteContext) => void;
+    /**
+     * Block connection immediately
+     */
+    block: (message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => void;
+    /**
+     * HTTP block response
+     */
+    httpBlock: (statusCode?: number, message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => void;
+    /**
+     * HTTP redirect handler
+     * Uses the centralized detection module for HTTP parsing
+     */
+    httpRedirect: (locationTemplate: string, statusCode?: number) => (socket: plugins.net.Socket, context: IRouteContext) => void;
+    /**
+     * HTTP server handler for ACME challenges and other HTTP needs
+     * Uses the centralized detection module for HTTP parsing
+     */
+    httpServer: (handler: (req: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+        body?: string;
+    }, res: {
+        status: (code: number) => void;
+        header: (name: string, value: string) => void;
+        send: (data: string) => void;
+        end: () => void;
+    }) => void) => (socket: plugins.net.Socket, context: IRouteContext) => void;
+};
+/**
+ * Create a socket handler route configuration
+ * @param domains Domain(s) to match
+ * @param ports Port(s) to listen on
+ * @param handler Socket handler function
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createSocketHandlerRoute(domains: string | string[], ports: TPortRange, handler: (socket: plugins.net.Socket) => void | Promise<void>, options?: {
+    name?: string;
+    priority?: number;
+    path?: string;
+}): IRouteConfig;

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

@@ -0,0 +1,287 @@
+/**
+ * Socket Handler Functions
+ *
+ * This module provides pre-built socket handlers for common use cases
+ * like echoing, proxying, HTTP responses, and redirects.
+ */
+import * as plugins from '../../../../plugins.js';
+import { ProtocolDetector } from '../../../../detection/index.js';
+import { createSocketTracker } from '../../../../core/utils/socket-tracker.js';
+/**
+ * Pre-built socket handlers for common use cases
+ */
+export const SocketHandlers = {
+    /**
+     * Simple echo server handler
+     */
+    echo: (socket, context) => {
+        socket.write('ECHO SERVER READY\n');
+        socket.on('data', data => socket.write(data));
+    },
+    /**
+     * TCP proxy handler
+     */
+    proxy: (targetHost, targetPort) => (socket, context) => {
+        const target = plugins.net.connect(targetPort, targetHost);
+        socket.pipe(target);
+        target.pipe(socket);
+        socket.on('close', () => target.destroy());
+        target.on('close', () => socket.destroy());
+        target.on('error', (err) => {
+            console.error('Proxy target error:', err);
+            socket.destroy();
+        });
+    },
+    /**
+     * Line-based protocol handler
+     */
+    lineProtocol: (handler) => (socket, context) => {
+        let buffer = '';
+        socket.on('data', (data) => {
+            buffer += data.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            lines.forEach(line => {
+                if (line.trim()) {
+                    handler(line.trim(), socket);
+                }
+            });
+        });
+    },
+    /**
+     * Simple HTTP response handler (for testing)
+     */
+    httpResponse: (statusCode, body) => (socket, context) => {
+        const response = [
+            `HTTP/1.1 ${statusCode} ${statusCode === 200 ? 'OK' : 'Error'}`,
+            'Content-Type: text/plain',
+            `Content-Length: ${body.length}`,
+            'Connection: close',
+            '',
+            body
+        ].join('\r\n');
+        socket.write(response);
+        socket.end();
+    },
+    /**
+     * Block connection immediately
+     */
+    block: (message) => (socket, context) => {
+        const finalMessage = message || `Connection blocked from ${context.clientIp}`;
+        if (finalMessage) {
+            socket.write(finalMessage);
+        }
+        socket.end();
+    },
+    /**
+     * HTTP block response
+     */
+    httpBlock: (statusCode = 403, message) => (socket, context) => {
+        const defaultMessage = `Access forbidden for ${context.domain || context.clientIp}`;
+        const finalMessage = message || defaultMessage;
+        const response = [
+            `HTTP/1.1 ${statusCode} ${finalMessage}`,
+            'Content-Type: text/plain',
+            `Content-Length: ${finalMessage.length}`,
+            'Connection: close',
+            '',
+            finalMessage
+        ].join('\r\n');
+        socket.write(response);
+        socket.end();
+    },
+    /**
+     * HTTP redirect handler
+     * Uses the centralized detection module for HTTP parsing
+     */
+    httpRedirect: (locationTemplate, statusCode = 301) => (socket, context) => {
+        const tracker = createSocketTracker(socket);
+        const connectionId = ProtocolDetector.createConnectionId({
+            socketId: context.connectionId || `${Date.now()}-${Math.random()}`
+        });
+        const handleData = async (data) => {
+            // Use detection module for parsing
+            const detectionResult = await ProtocolDetector.detectWithConnectionTracking(data, connectionId, { extractFullHeaders: false } // We only need method and path
+            );
+            if (detectionResult.protocol === 'http' && detectionResult.connectionInfo.path) {
+                const method = detectionResult.connectionInfo.method || 'GET';
+                const path = detectionResult.connectionInfo.path || '/';
+                const domain = context.domain || 'localhost';
+                const port = context.port;
+                let finalLocation = locationTemplate
+                    .replace('{domain}', domain)
+                    .replace('{port}', String(port))
+                    .replace('{path}', path)
+                    .replace('{clientIp}', context.clientIp);
+                const message = `Redirecting to ${finalLocation}`;
+                const response = [
+                    `HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
+                    `Location: ${finalLocation}`,
+                    'Content-Type: text/plain',
+                    `Content-Length: ${message.length}`,
+                    'Connection: close',
+                    '',
+                    message
+                ].join('\r\n');
+                socket.write(response);
+            }
+            else {
+                // Not a valid HTTP request, close connection
+                socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+            }
+            socket.end();
+            // Clean up detection state
+            ProtocolDetector.cleanupConnections();
+            // Clean up all tracked resources
+            tracker.cleanup();
+        };
+        // Use tracker to manage the listener
+        socket.once('data', handleData);
+        tracker.addListener('error', (err) => {
+            tracker.safeDestroy(err);
+        });
+        tracker.addListener('close', () => {
+            tracker.cleanup();
+        });
+    },
+    /**
+     * HTTP server handler for ACME challenges and other HTTP needs
+     * Uses the centralized detection module for HTTP parsing
+     */
+    httpServer: (handler) => (socket, context) => {
+        const tracker = createSocketTracker(socket);
+        let requestParsed = false;
+        let responseTimer = null;
+        const connectionId = ProtocolDetector.createConnectionId({
+            socketId: context.connectionId || `${Date.now()}-${Math.random()}`
+        });
+        const processData = async (data) => {
+            if (requestParsed)
+                return; // Only handle the first request
+            // Use HttpDetector for parsing
+            const detectionResult = await ProtocolDetector.detectWithConnectionTracking(data, connectionId, { extractFullHeaders: true });
+            if (detectionResult.protocol !== 'http' || !detectionResult.isComplete) {
+                // Not a complete HTTP request yet
+                return;
+            }
+            requestParsed = true;
+            // Remove data listener after parsing request
+            socket.removeListener('data', processData);
+            const connInfo = detectionResult.connectionInfo;
+            // Create request object from detection result
+            const req = {
+                method: connInfo.method || 'GET',
+                url: connInfo.path || '/',
+                headers: connInfo.headers || {},
+                body: detectionResult.remainingBuffer?.toString() || ''
+            };
+            // Create response object
+            let statusCode = 200;
+            const responseHeaders = {};
+            let ended = false;
+            const res = {
+                status: (code) => {
+                    statusCode = code;
+                },
+                header: (name, value) => {
+                    responseHeaders[name] = value;
+                },
+                send: (data) => {
+                    if (ended)
+                        return;
+                    ended = true;
+                    // Clear response timer since we're sending now
+                    if (responseTimer) {
+                        clearTimeout(responseTimer);
+                        responseTimer = null;
+                    }
+                    if (!responseHeaders['content-type']) {
+                        responseHeaders['content-type'] = 'text/plain';
+                    }
+                    responseHeaders['content-length'] = String(data.length);
+                    responseHeaders['connection'] = 'close';
+                    const statusText = statusCode === 200 ? 'OK' :
+                        statusCode === 404 ? 'Not Found' :
+                            statusCode === 500 ? 'Internal Server Error' : 'Response';
+                    let response = `HTTP/1.1 ${statusCode} ${statusText}\r\n`;
+                    for (const [name, value] of Object.entries(responseHeaders)) {
+                        response += `${name}: ${value}\r\n`;
+                    }
+                    response += '\r\n';
+                    response += data;
+                    socket.write(response);
+                    socket.end();
+                },
+                end: () => {
+                    if (ended)
+                        return;
+                    ended = true;
+                    socket.write('HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n');
+                    socket.end();
+                }
+            };
+            try {
+                handler(req, res);
+                // Ensure response is sent even if handler doesn't call send()
+                responseTimer = setTimeout(() => {
+                    if (!ended) {
+                        res.send('');
+                    }
+                    responseTimer = null;
+                }, 1000);
+                // Track and unref the timer
+                tracker.addTimer(responseTimer);
+            }
+            catch (error) {
+                if (!ended) {
+                    res.status(500);
+                    res.send('Internal Server Error');
+                }
+                // Use safeDestroy for error cases
+                tracker.safeDestroy(error instanceof Error ? error : new Error('Handler error'));
+            }
+        };
+        // Use tracker to manage listeners
+        tracker.addListener('data', processData);
+        tracker.addListener('error', (err) => {
+            if (!requestParsed) {
+                tracker.safeDestroy(err);
+            }
+        });
+        tracker.addListener('close', () => {
+            // Clear any pending response timer
+            if (responseTimer) {
+                clearTimeout(responseTimer);
+                responseTimer = null;
+            }
+            // Clean up detection state
+            ProtocolDetector.cleanupConnections();
+            // Clean up all tracked resources
+            tracker.cleanup();
+        });
+    }
+};
+/**
+ * Create a socket handler route configuration
+ * @param domains Domain(s) to match
+ * @param ports Port(s) to listen on
+ * @param handler Socket handler function
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createSocketHandlerRoute(domains, ports, handler, options = {}) {
+    return {
+        name: options.name || 'socket-handler-route',
+        priority: options.priority !== undefined ? options.priority : 50,
+        match: {
+            domains,
+            ports,
+            ...(options.path && { path: options.path })
+        },
+        action: {
+            type: 'socket-handler',
+            socketHandler: handler
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"socket-handlers.js","sourceRoot":"","sources":["../../../../../ts/proxies/smart-proxy/utils/route-helpers/socket-handlers.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,46 @@
+/**
+ * WebSocket Route Helper Functions
+ *
+ * This module provides utility functions for creating WebSocket route configurations.
+ */
+import type { IRouteConfig } from '../../models/route-types.js';
+/**
+ * Create a WebSocket route configuration
+ * @param domains Domain(s) to match
+ * @param targetOrPath Target server OR WebSocket path (legacy)
+ * @param targetOrOptions Target server (legacy) OR options
+ * @param options Additional route options (legacy)
+ * @returns Route configuration object
+ */
+export declare function createWebSocketRoute(domains: string | string[], targetOrPath: {
+    host: string | string[];
+    port: number;
+} | string, targetOrOptions?: {
+    host: string | string[];
+    port: number;
+} | {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    path?: string;
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    pingInterval?: number;
+    pingTimeout?: number;
+    name?: string;
+    [key: string]: any;
+}, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    pingInterval?: number;
+    pingTimeout?: number;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;