@push.rocks/smartproxy 19.4.2 → 19.5.2

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '19.4.2',
+  version: '19.5.2',
   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.'
 }

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

@@ -2,5 +2,4 @@
  * HTTP handlers for various route types
  */
 
-export { RedirectHandler } from './redirect-handler.js';
-export { StaticHandler } from './static-handler.js';
+// Empty - all handlers have been removed

package/ts/proxies/smart-proxy/certificate-manager.ts

@@ -5,6 +5,7 @@ import type { IAcmeOptions } from './models/interfaces.js';
 import { CertStore } from './cert-store.js';
 import type { AcmeStateManager } from './acme-state-manager.js';
 import { logger } from '../../core/utils/logger.js';
+import { SocketHandlers } from './utils/route-helpers.js';
 
 export interface ICertStatus {
   domain: string;
@@ -693,22 +694,24 @@ export class SmartCertManager {
         path: '/.well-known/acme-challenge/*'
       },
       action: {
-        type: 'static',
-        handler: async (context) => {
+        type: 'socket-handler',
+        socketHandler: SocketHandlers.httpServer((req, res) => {
           // Extract the token from the path
-          const token = context.path?.split('/').pop();
+          const token = req.url?.split('/').pop();
           if (!token) {
-            return { status: 404, body: 'Not found' };
+            res.status(404);
+            res.send('Not found');
+            return;
           }
           
           // Create mock request/response objects for SmartAcme
+          let responseData: any = null;
           const mockReq = {
-            url: context.path,
-            method: 'GET',
-            headers: context.headers || {}
+            url: req.url,
+            method: req.method,
+            headers: req.headers
           };
           
-          let responseData: any = null;
           const mockRes = {
             statusCode: 200,
             setHeader: (name: string, value: string) => {},
@@ -718,24 +721,27 @@ export class SmartCertManager {
           };
           
           // Use SmartAcme's handler
-          const handled = await new Promise<boolean>((resolve) => {
+          const handleAcme = () => {
             http01Handler.handleRequest(mockReq as any, mockRes as any, () => {
-              resolve(false);
+              // Not handled by ACME
+              res.status(404);
+              res.send('Not found');
             });
-            // Give it a moment to process
-            setTimeout(() => resolve(true), 100);
-          });
+            
+            // Give it a moment to process, then send response
+            setTimeout(() => {
+              if (responseData) {
+                res.header('Content-Type', 'text/plain');
+                res.send(String(responseData));
+              } else {
+                res.status(404);
+                res.send('Not found');
+              }
+            }, 100);
+          };
           
-          if (handled && responseData) {
-            return {
-              status: mockRes.statusCode,
-              headers: { 'Content-Type': 'text/plain' },
-              body: responseData
-            };
-          } else {
-            return { status: 404, body: 'Not found' };
-          }
-        }
+          handleAcme();
+        })
       }
     };
     

package/ts/proxies/smart-proxy/models/route-types.ts

@@ -2,11 +2,20 @@ import * as plugins from '../../../plugins.js';
 // Certificate types removed - use local definition
 import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
 import type { PortRange } from '../../../proxies/nftables-proxy/models/interfaces.js';
+import type { IRouteContext } from '../../../core/models/route-context.js';
+
+// Re-export IRouteContext for convenience
+export type { IRouteContext };
 
 /**
  * Supported action types for route configurations
  */
-export type TRouteActionType = 'forward' | 'redirect' | 'block' | 'static';
+export type TRouteActionType = 'forward' | 'socket-handler';
+
+/**
+ * Socket handler function type
+ */
+export type TSocketHandler = (socket: plugins.net.Socket, context: IRouteContext) => void | Promise<void>;
 
 /**
  * TLS handling modes for route configurations
@@ -35,36 +44,6 @@ export interface IRouteMatch {
   headers?: Record<string, string | RegExp>; // Match specific HTTP headers
 }
 
-/**
- * Context provided to port and host mapping functions
- */
-export interface IRouteContext {
-  // Connection information
-  port: number;          // The matched incoming port
-  domain?: string;       // The domain from SNI or Host header
-  clientIp: string;      // The client's IP address
-  serverIp: string;      // The server's IP address
-  path?: string;         // URL path (for HTTP connections)
-  query?: string;        // Query string (for HTTP connections)
-  headers?: Record<string, string>; // HTTP headers (for HTTP connections)
-  method?: string;       // HTTP method (for HTTP connections)
-
-  // TLS information
-  isTls: boolean;        // Whether the connection is TLS
-  tlsVersion?: string;   // TLS version if applicable
-
-  // Route information
-  routeName?: string;    // The name of the matched route
-  routeId?: string;      // The ID of the matched route
-
-  // Target information (resolved from dynamic mapping)
-  targetHost?: string | string[];   // The resolved target host(s)
-  targetPort?: number;   // The resolved target port
-
-  // Additional properties
-  timestamp: number;     // The request timestamp
-  connectionId: string;  // Unique connection identifier
-}
 
 /**
  * Target configuration for forwarding
@@ -84,15 +63,6 @@ export interface IRouteAcme {
   renewBeforeDays?: number;         // Days before expiry to renew (default: 30)
 }
 
-/**
- * Static route handler response
- */
-export interface IStaticResponse {
-  status: number;
-  headers?: Record<string, string>;
-  body: string | Buffer;
-}
-
 /**
  * TLS configuration for route actions
  */
@@ -112,14 +82,6 @@ export interface IRouteTls {
   sessionTimeout?: number;         // TLS session timeout in seconds
 }
 
-/**
- * Redirect configuration for route actions
- */
-export interface IRouteRedirect {
-  to: string;            // URL or template with {domain}, {port}, etc.
-  status: 301 | 302 | 307 | 308;
-}
-
 /**
  * Authentication options
  */
@@ -265,12 +227,6 @@ export interface IRouteAction {
   // TLS handling
   tls?: IRouteTls;
 
-  // For redirects
-  redirect?: IRouteRedirect;
-
-  // For static files
-  static?: IRouteStaticFiles;
-
   // WebSocket support
   websocket?: IRouteWebSocket;
 
@@ -295,8 +251,8 @@ export interface IRouteAction {
   // NFTables-specific options
   nftables?: INfTablesOptions;
 
-  // Handler function for static routes
-  handler?: (context: IRouteContext) => Promise<IStaticResponse>;
+  // Socket handler function (when type is 'socket-handler')
+  socketHandler?: TSocketHandler;
 }
 
 /**

package/ts/proxies/smart-proxy/route-connection-handler.ts

@@ -10,7 +10,6 @@ import { HttpProxyBridge } from './http-proxy-bridge.js';
 import { TimeoutManager } from './timeout-manager.js';
 import { RouteManager } from './route-manager.js';
 import type { ForwardingHandler } from '../../forwarding/handlers/base-handler.js';
-import { RedirectHandler, StaticHandler } from '../http-proxy/handlers/index.js';
 
 /**
  * Handles new connection processing and setup logic with support for route-based configuration
@@ -389,14 +388,13 @@ export class RouteConnectionHandler {
       case 'forward':
         return this.handleForwardAction(socket, record, route, initialChunk);
 
-      case 'redirect':
-        return this.handleRedirectAction(socket, record, route);
-
-      case 'block':
-        return this.handleBlockAction(socket, record, route);
-
-      case 'static':
-        this.handleStaticAction(socket, record, route, initialChunk);
+      case 'socket-handler':
+        logger.log('info', `Handling socket-handler action for route ${route.name}`, {
+          connectionId,
+          routeName: route.name,
+          component: 'route-handler'
+        });
+        this.handleSocketHandlerAction(socket, record, route, initialChunk);
         return;
 
       default:
@@ -710,70 +708,85 @@ export class RouteConnectionHandler {
   }
 
   /**
-   * Handle a redirect action for a route
+   * Handle a socket-handler action for a route
    */
-  private handleRedirectAction(
+  private async handleSocketHandlerAction(
     socket: plugins.net.Socket,
     record: IConnectionRecord,
-    route: IRouteConfig
-  ): void {
-    // For TLS connections, we can't do redirects at the TCP level
-    if (record.isTLS) {
-      logger.log('warn', `Cannot redirect TLS connection ${record.id} at TCP level`, {
-        connectionId: record.id,
+    route: IRouteConfig,
+    initialChunk?: Buffer
+  ): Promise<void> {
+    const connectionId = record.id;
+    
+    if (!route.action.socketHandler) {
+      logger.log('error', 'socket-handler action missing socketHandler function', {
+        connectionId,
+        routeName: route.name,
         component: 'route-handler'
       });
-      socket.end();
-      this.connectionManager.cleanupConnection(record, 'tls_redirect_error');
+      socket.destroy();
+      this.connectionManager.cleanupConnection(record, 'missing_handler');
       return;
     }
-
-    // Delegate to HttpProxy's RedirectHandler
-    RedirectHandler.handleRedirect(socket, route, {
+    
+    // Create route context for the handler
+    const routeContext = this.createRouteContext({
       connectionId: record.id,
-      connectionManager: this.connectionManager,
-      settings: this.settings
+      port: record.localPort,
+      domain: record.lockedDomain,
+      clientIp: record.remoteIP,
+      serverIp: socket.localAddress || '',
+      isTls: record.isTLS || false,
+      tlsVersion: record.tlsVersion,
+      routeName: route.name,
+      routeId: route.id,
     });
-  }
-
-  /**
-   * Handle a block action for a route
-   */
-  private handleBlockAction(
-    socket: plugins.net.Socket,
-    record: IConnectionRecord,
-    route: IRouteConfig
-  ): void {
-    const connectionId = record.id;
-
-    if (this.settings.enableDetailedLogging) {
-      logger.log('info', `Blocking connection ${connectionId} based on route '${route.name || 'unnamed'}'`, {
+    
+    try {
+      // Call the handler with socket AND context
+      const result = route.action.socketHandler(socket, routeContext);
+      
+      // Handle async handlers properly
+      if (result instanceof Promise) {
+        result
+          .then(() => {
+            // Emit initial chunk after async handler completes
+            if (initialChunk && initialChunk.length > 0) {
+              socket.emit('data', initialChunk);
+            }
+          })
+          .catch(error => {
+            logger.log('error', 'Socket handler error', {
+              connectionId,
+              routeName: route.name,
+              error: error.message,
+              component: 'route-handler'
+            });
+            if (!socket.destroyed) {
+              socket.destroy();
+            }
+            this.connectionManager.cleanupConnection(record, 'handler_error');
+          });
+      } else {
+        // For sync handlers, emit on next tick
+        if (initialChunk && initialChunk.length > 0) {
+          process.nextTick(() => {
+            socket.emit('data', initialChunk);
+          });
+        }
+      }
+    } catch (error) {
+      logger.log('error', 'Socket handler error', {
         connectionId,
-        routeName: route.name || 'unnamed',
+        routeName: route.name,
+        error: error.message,
         component: 'route-handler'
       });
+      if (!socket.destroyed) {
+        socket.destroy();
+      }
+      this.connectionManager.cleanupConnection(record, 'handler_error');
     }
-
-    // Simply close the connection
-    socket.end();
-    this.connectionManager.initiateCleanupOnce(record, 'route_blocked');
-  }
-
-  /**
-   * Handle a static action for a route
-   */
-  private async handleStaticAction(
-    socket: plugins.net.Socket,
-    record: IConnectionRecord,
-    route: IRouteConfig,
-    initialChunk?: Buffer
-  ): Promise<void> {
-    // Delegate to HttpProxy's StaticHandler
-    await StaticHandler.handleStatic(socket, route, {
-      connectionId: record.id,
-      connectionManager: this.connectionManager,
-      settings: this.settings
-    }, record, initialChunk);
   }
 
   /**

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

@@ -19,7 +19,6 @@ import {
   createWebSocketRoute as createWebSocketPatternRoute,
   createLoadBalancerRoute as createLoadBalancerPatternRoute,
   createApiGatewayRoute,
-  createStaticFileServerRoute,
   addRateLimiting,
   addBasicAuth,
   addJwtAuth
@@ -29,7 +28,6 @@ export {
   createWebSocketPatternRoute,
   createLoadBalancerPatternRoute,
   createApiGatewayRoute,
-  createStaticFileServerRoute,
   addRateLimiting,
   addBasicAuth,
   addJwtAuth