@push.rocks/smartproxy 21.1.7 → 22.4.2

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;

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

@@ -0,0 +1,67 @@
+/**
+ * WebSocket Route Helper Functions
+ *
+ * This module provides utility functions for creating WebSocket route configurations.
+ */
+/**
+ * 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 function createWebSocketRoute(domains, targetOrPath, targetOrOptions, options) {
+    // Handle different signatures
+    let target;
+    let wsPath;
+    let finalOptions;
+    if (typeof targetOrPath === 'string') {
+        // Legacy signature: (domains, path, target, options)
+        wsPath = targetOrPath;
+        target = targetOrOptions;
+        finalOptions = options || {};
+    }
+    else {
+        // New signature: (domains, target, options)
+        target = targetOrPath;
+        finalOptions = targetOrOptions || {};
+        wsPath = finalOptions.path || '/ws';
+    }
+    // Normalize WebSocket path
+    const normalizedPath = wsPath.startsWith('/') ? wsPath : `/${wsPath}`;
+    // Create route match
+    const match = {
+        ports: finalOptions.useTls
+            ? (finalOptions.httpsPort || 443)
+            : (finalOptions.httpPort || 80),
+        domains,
+        path: normalizedPath
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target],
+        websocket: {
+            enabled: true,
+            pingInterval: finalOptions.pingInterval || 30000, // 30 seconds
+            pingTimeout: finalOptions.pingTimeout || 5000 // 5 seconds
+        }
+    };
+    // Add TLS configuration if using HTTPS
+    if (finalOptions.useTls) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: finalOptions.certificate || 'auto'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: finalOptions.name || `WebSocket Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: finalOptions.priority || 100, // Higher priority for WebSocket routes
+        ...finalOptions
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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