@push.rocks/smartproxy 22.4.2 → 23.0.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/routing/index.d.ts

@@ -1,5 +1,5 @@
 /**
  * Routing functionality module
  */
-export * from '../proxies/http-proxy/models/http-types.js';
+export * from './models/http-types.js';
 export * from './router/index.js';

package/dist_ts/routing/index.js

@@ -1,8 +1,8 @@
 /**
  * Routing functionality module
  */
-// Export types and models from HttpProxy
-export * from '../proxies/http-proxy/models/http-types.js';
+// Export types and models
+export * from './models/http-types.js';
 // Export router functionality
 export * from './router/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9yb3V0aW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgseUNBQXlDO0FBQ3pDLGNBQWMsNENBQTRDLENBQUM7QUFFM0QsOEJBQThCO0FBQzlCLGNBQWMsbUJBQW1CLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9yb3V0aW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsMEJBQTBCO0FBQzFCLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsOEJBQThCO0FBQzlCLGNBQWMsbUJBQW1CLENBQUMifQ==

package/dist_ts/routing/models/http-types.d.ts

@@ -1,6 +1,121 @@
 /**
- * This file re-exports HTTP types from the HttpProxy module
- * for backward compatibility. All HTTP types are now consolidated
- * in the HttpProxy module.
+ * HTTP types for routing module.
+ * These were previously in http-proxy and are now self-contained here.
  */
-export * from '../../proxies/http-proxy/models/http-types.js';
+import * as plugins from '../../plugins.js';
+import { HttpStatus as ProtocolHttpStatus } from '../../protocols/http/index.js';
+/**
+ * HTTP-specific event types
+ */
+export declare enum HttpEvents {
+    REQUEST_RECEIVED = "request-received",
+    REQUEST_FORWARDED = "request-forwarded",
+    REQUEST_HANDLED = "request-handled",
+    REQUEST_ERROR = "request-error"
+}
+export declare const HttpStatus: {
+    readonly OK: ProtocolHttpStatus.OK;
+    readonly MOVED_PERMANENTLY: ProtocolHttpStatus.MOVED_PERMANENTLY;
+    readonly FOUND: ProtocolHttpStatus.FOUND;
+    readonly TEMPORARY_REDIRECT: ProtocolHttpStatus.TEMPORARY_REDIRECT;
+    readonly PERMANENT_REDIRECT: ProtocolHttpStatus.PERMANENT_REDIRECT;
+    readonly BAD_REQUEST: ProtocolHttpStatus.BAD_REQUEST;
+    readonly UNAUTHORIZED: ProtocolHttpStatus.UNAUTHORIZED;
+    readonly FORBIDDEN: ProtocolHttpStatus.FORBIDDEN;
+    readonly NOT_FOUND: ProtocolHttpStatus.NOT_FOUND;
+    readonly METHOD_NOT_ALLOWED: ProtocolHttpStatus.METHOD_NOT_ALLOWED;
+    readonly REQUEST_TIMEOUT: ProtocolHttpStatus.REQUEST_TIMEOUT;
+    readonly TOO_MANY_REQUESTS: ProtocolHttpStatus.TOO_MANY_REQUESTS;
+    readonly INTERNAL_SERVER_ERROR: ProtocolHttpStatus.INTERNAL_SERVER_ERROR;
+    readonly NOT_IMPLEMENTED: ProtocolHttpStatus.NOT_IMPLEMENTED;
+    readonly BAD_GATEWAY: ProtocolHttpStatus.BAD_GATEWAY;
+    readonly SERVICE_UNAVAILABLE: ProtocolHttpStatus.SERVICE_UNAVAILABLE;
+    readonly GATEWAY_TIMEOUT: ProtocolHttpStatus.GATEWAY_TIMEOUT;
+};
+/**
+ * Base error class for HTTP-related errors
+ */
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Error related to certificate operations
+ */
+export declare class CertificateError extends HttpError {
+    readonly domain: string;
+    readonly isRenewal: boolean;
+    constructor(message: string, domain: string, isRenewal?: boolean);
+}
+/**
+ * Error related to server operations
+ */
+export declare class ServerError extends HttpError {
+    readonly code?: string;
+    constructor(message: string, code?: string, statusCode?: number);
+}
+/**
+ * Error for bad requests
+ */
+export declare class BadRequestError extends HttpError {
+    constructor(message: string);
+}
+/**
+ * Error for not found resources
+ */
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string);
+}
+/**
+ * Redirect configuration for HTTP requests
+ */
+export interface IRedirectConfig {
+    source: string;
+    destination: string;
+    type: number;
+    preserveQuery?: boolean;
+}
+/**
+ * HTTP router configuration
+ */
+export interface IRouterConfig {
+    routes: Array<{
+        path: string;
+        method?: string;
+        handler: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void | Promise<void>;
+    }>;
+    notFoundHandler?: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+    errorHandler?: (error: Error, req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+}
+/**
+ * HTTP request method types
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+/**
+ * Helper function to get HTTP status text
+ */
+export declare function getStatusText(status: number): string;
+export interface IDomainOptions {
+    domainName: string;
+    sslRedirect: boolean;
+    acmeMaintenance: boolean;
+    forward?: {
+        ip: string;
+        port: number;
+    };
+    acmeForward?: {
+        ip: string;
+        port: number;
+    };
+}
+export interface IDomainCertificate {
+    options: IDomainOptions;
+    certObtained: boolean;
+    obtainingInProgress: boolean;
+    certificate?: string;
+    privateKey?: string;
+    expiryDate?: Date;
+    lastRenewalAttempt?: Date;
+}
+export { HttpError as Port80HandlerError };
+export { CertificateError as CertError };

package/dist_ts/routing/models/http-types.js

@@ -1,7 +1,95 @@
 /**
- * This file re-exports HTTP types from the HttpProxy module
- * for backward compatibility. All HTTP types are now consolidated
- * in the HttpProxy module.
+ * HTTP types for routing module.
+ * These were previously in http-proxy and are now self-contained here.
  */
-export * from '../../proxies/http-proxy/models/http-types.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3JvdXRpbmcvbW9kZWxzL2h0dHAtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILGNBQWMsK0NBQStDLENBQUMifQ==
+import * as plugins from '../../plugins.js';
+import { HttpStatus as ProtocolHttpStatus, getStatusText as getProtocolStatusText } from '../../protocols/http/index.js';
+/**
+ * HTTP-specific event types
+ */
+export var HttpEvents;
+(function (HttpEvents) {
+    HttpEvents["REQUEST_RECEIVED"] = "request-received";
+    HttpEvents["REQUEST_FORWARDED"] = "request-forwarded";
+    HttpEvents["REQUEST_HANDLED"] = "request-handled";
+    HttpEvents["REQUEST_ERROR"] = "request-error";
+})(HttpEvents || (HttpEvents = {}));
+// Re-export for backward compatibility with subset of commonly used codes
+export const HttpStatus = {
+    OK: ProtocolHttpStatus.OK,
+    MOVED_PERMANENTLY: ProtocolHttpStatus.MOVED_PERMANENTLY,
+    FOUND: ProtocolHttpStatus.FOUND,
+    TEMPORARY_REDIRECT: ProtocolHttpStatus.TEMPORARY_REDIRECT,
+    PERMANENT_REDIRECT: ProtocolHttpStatus.PERMANENT_REDIRECT,
+    BAD_REQUEST: ProtocolHttpStatus.BAD_REQUEST,
+    UNAUTHORIZED: ProtocolHttpStatus.UNAUTHORIZED,
+    FORBIDDEN: ProtocolHttpStatus.FORBIDDEN,
+    NOT_FOUND: ProtocolHttpStatus.NOT_FOUND,
+    METHOD_NOT_ALLOWED: ProtocolHttpStatus.METHOD_NOT_ALLOWED,
+    REQUEST_TIMEOUT: ProtocolHttpStatus.REQUEST_TIMEOUT,
+    TOO_MANY_REQUESTS: ProtocolHttpStatus.TOO_MANY_REQUESTS,
+    INTERNAL_SERVER_ERROR: ProtocolHttpStatus.INTERNAL_SERVER_ERROR,
+    NOT_IMPLEMENTED: ProtocolHttpStatus.NOT_IMPLEMENTED,
+    BAD_GATEWAY: ProtocolHttpStatus.BAD_GATEWAY,
+    SERVICE_UNAVAILABLE: ProtocolHttpStatus.SERVICE_UNAVAILABLE,
+    GATEWAY_TIMEOUT: ProtocolHttpStatus.GATEWAY_TIMEOUT,
+};
+/**
+ * Base error class for HTTP-related errors
+ */
+export class HttpError extends Error {
+    constructor(message, statusCode = HttpStatus.INTERNAL_SERVER_ERROR) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'HttpError';
+    }
+}
+/**
+ * Error related to certificate operations
+ */
+export class CertificateError extends HttpError {
+    constructor(message, domain, isRenewal = false) {
+        super(`${message} for domain ${domain}${isRenewal ? ' (renewal)' : ''}`, HttpStatus.INTERNAL_SERVER_ERROR);
+        this.domain = domain;
+        this.isRenewal = isRenewal;
+        this.name = 'CertificateError';
+    }
+}
+/**
+ * Error related to server operations
+ */
+export class ServerError extends HttpError {
+    constructor(message, code, statusCode = HttpStatus.INTERNAL_SERVER_ERROR) {
+        super(message, statusCode);
+        this.code = code;
+        this.name = 'ServerError';
+    }
+}
+/**
+ * Error for bad requests
+ */
+export class BadRequestError extends HttpError {
+    constructor(message) {
+        super(message, HttpStatus.BAD_REQUEST);
+        this.name = 'BadRequestError';
+    }
+}
+/**
+ * Error for not found resources
+ */
+export class NotFoundError extends HttpError {
+    constructor(message = 'Resource not found') {
+        super(message, HttpStatus.NOT_FOUND);
+        this.name = 'NotFoundError';
+    }
+}
+/**
+ * Helper function to get HTTP status text
+ */
+export function getStatusText(status) {
+    return getProtocolStatusText(status);
+}
+// Backward compatibility exports
+export { HttpError as Port80HandlerError };
+export { CertificateError as CertError };
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "22.4.2",
+  "version": "23.0.0",
   "private": false,
   "description": "A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.",
   "main": "dist_ts/index.js",