@push.rocks/smartproxy 16.0.4 → 18.0.0

package/ts/common/port80-adapter.ts

@@ -21,9 +21,21 @@ export function convertToLegacyForwardConfig(
     ? forwardConfig.target.host[0]  // Use the first host in the array
     : forwardConfig.target.host;
 
+  // Extract port number, handling different port formats
+  let port: number;
+  if (typeof forwardConfig.target.port === 'function') {
+    // Use a default port for function-based ports in adapter context
+    port = 80;
+  } else if (forwardConfig.target.port === 'preserve') {
+    // For 'preserve', use the default port 80 in this adapter context
+    port = 80;
+  } else {
+    port = forwardConfig.target.port;
+  }
+
   return {
     ip: host,
-    port: forwardConfig.target.port
+    port: port
   };
 }
 
@@ -75,11 +87,23 @@ export function createPort80HandlerOptions(
       forwardConfig.type === 'https-terminate-to-https'));
   
   if (supportsHttp) {
+    // Determine port value handling different formats
+    let port: number;
+    if (typeof forwardConfig.target.port === 'function') {
+      // Use a default port for function-based ports
+      port = 80;
+    } else if (forwardConfig.target.port === 'preserve') {
+      // For 'preserve', use 80 in this adapter context
+      port = 80;
+    } else {
+      port = forwardConfig.target.port;
+    }
+
     options.forward = {
       ip: Array.isArray(forwardConfig.target.host) 
         ? forwardConfig.target.host[0]
         : forwardConfig.target.host,
-      port: forwardConfig.target.port
+      port: port
     };
   }
   

package/ts/core/utils/shared-security-manager.ts

@@ -199,8 +199,8 @@ export class SharedSecurityManager {
     }
     
     // Check IP against route security settings
-    const ipAllowList = route.security.ipAllowList || route.security.allowedIps;
-    const ipBlockList = route.security.ipBlockList || route.security.blockedIps;
+    const ipAllowList = route.security.ipAllowList;
+    const ipBlockList = route.security.ipBlockList;
     
     const allowed = this.isIPAuthorized(clientIp, ipAllowList, ipBlockList);
     

package/ts/forwarding/config/forwarding-types.ts

@@ -1,10 +1,8 @@
 import type * as plugins from '../../plugins.js';
 
 /**
- * @deprecated The legacy forwarding types are being replaced by the route-based configuration system.
- * See /ts/proxies/smart-proxy/models/route-types.ts for the new route-based configuration.
- *
  * The primary forwarding types supported by SmartProxy
+ * Used for configuration compatibility
  */
 export type TForwardingType =
   | 'http-only'                // HTTP forwarding only (no HTTPS)
@@ -35,7 +33,7 @@ export interface IForwardingHandler extends plugins.EventEmitter {
   handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
 }
 
-// Import and re-export the route-based helpers for seamless transition
+// Route-based helpers are now available directly from route-patterns.ts
 import {
   createHttpRoute,
   createHttpsTerminateRoute,
@@ -43,7 +41,7 @@ import {
   createHttpToHttpsRedirect,
   createCompleteHttpsServer,
   createLoadBalancerRoute
-} from '../../proxies/smart-proxy/utils/route-helpers.js';
+} from '../../proxies/smart-proxy/utils/route-patterns.js';
 
 export {
   createHttpRoute,
@@ -54,23 +52,20 @@ export {
   createLoadBalancerRoute
 };
 
-/**
- * @deprecated These helper functions are maintained for backward compatibility.
- * Please use the route-based helpers instead:
- * - createHttpRoute
- * - createHttpsTerminateRoute
- * - createHttpsPassthroughRoute
- * - createHttpToHttpsRedirect
- */
+// Note: Legacy helper functions have been removed
+// Please use the route-based helpers instead:
+// - createHttpRoute
+// - createHttpsTerminateRoute
+// - createHttpsPassthroughRoute
+// - createHttpToHttpsRedirect
 import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-import { domainConfigToRouteConfig } from '../../proxies/smart-proxy/utils/route-migration-utils.js';
 
-// For backward compatibility
+// For backward compatibility, kept only the basic configuration interface
 export interface IForwardConfig {
   type: TForwardingType;
   target: {
     host: string | string[];
-    port: number;
+    port: number | 'preserve' | ((ctx: any) => number);
   };
   http?: any;
   https?: any;
@@ -78,57 +73,4 @@ export interface IForwardConfig {
   security?: any;
   advanced?: any;
   [key: string]: any;
-}
-
-export interface IDeprecatedForwardConfig {
-  type: TForwardingType;
-  target: {
-    host: string | string[];
-    port: number;
-  };
-  [key: string]: any;
-}
-
-/**
- * @deprecated Use createHttpRoute instead
- */
-export const httpOnly = (
-  partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, 'target'>
-): IDeprecatedForwardConfig => ({
-  type: 'http-only',
-  target: partialConfig.target,
-  ...(partialConfig)
-});
-
-/**
- * @deprecated Use createHttpsTerminateRoute instead
- */
-export const tlsTerminateToHttp = (
-  partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, 'target'>
-): IDeprecatedForwardConfig => ({
-  type: 'https-terminate-to-http',
-  target: partialConfig.target,
-  ...(partialConfig)
-});
-
-/**
- * @deprecated Use createHttpsTerminateRoute with reencrypt option instead
- */
-export const tlsTerminateToHttps = (
-  partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, 'target'>
-): IDeprecatedForwardConfig => ({
-  type: 'https-terminate-to-https',
-  target: partialConfig.target,
-  ...(partialConfig)
-});
-
-/**
- * @deprecated Use createHttpsPassthroughRoute instead
- */
-export const httpsPassthrough = (
-  partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, 'target'>
-): IDeprecatedForwardConfig => ({
-  type: 'https-passthrough',
-  target: partialConfig.target,
-  ...(partialConfig)
-});
+}

package/ts/forwarding/config/index.ts

@@ -5,5 +5,22 @@
  * See /ts/proxies/smart-proxy/models/route-types.ts for the new route-based configuration.
  */
 
-export * from './forwarding-types.js';
-export * from '../../proxies/smart-proxy/utils/route-helpers.js';
+export type { 
+  TForwardingType,
+  IForwardConfig,
+  IForwardingHandler
+} from './forwarding-types.js';
+
+export { 
+  ForwardingHandlerEvents
+} from './forwarding-types.js';
+
+// Import route helpers from route-patterns instead of deleted route-helpers
+export {
+  createHttpRoute,
+  createHttpsTerminateRoute,
+  createHttpsPassthroughRoute,
+  createHttpToHttpsRedirect,
+  createCompleteHttpsServer,
+  createLoadBalancerRoute
+} from '../../proxies/smart-proxy/utils/route-patterns.js';

package/ts/forwarding/factory/forwarding-factory.ts

@@ -122,8 +122,13 @@ export class ForwardingHandlerFactory {
       throw new Error('Target must include a host or array of hosts');
     }
     
-    if (!config.target.port || config.target.port <= 0 || config.target.port > 65535) {
-      throw new Error('Target must include a valid port (1-65535)');
+    // Validate port if it's a number
+    if (typeof config.target.port === 'number') {
+      if (config.target.port <= 0 || config.target.port > 65535) {
+        throw new Error('Target must include a valid port (1-65535)');
+      }
+    } else if (config.target.port !== 'preserve' && typeof config.target.port !== 'function') {
+      throw new Error('Target port must be a number, "preserve", or a function');
     }
     
     // Type-specific validation

package/ts/forwarding/handlers/base-handler.ts

@@ -40,9 +40,10 @@ export abstract class ForwardingHandler extends plugins.EventEmitter implements
   
   /**
    * Get a target from the configuration, supporting round-robin selection
+   * @param incomingPort Optional incoming port for 'preserve' mode
    * @returns A resolved target object with host and port
    */
-  protected getTargetFromConfig(): { host: string, port: number } {
+  protected getTargetFromConfig(incomingPort: number = 80): { host: string, port: number } {
     const { target } = this.config;
     
     // Handle round-robin host selection
@@ -55,17 +56,42 @@ export abstract class ForwardingHandler extends plugins.EventEmitter implements
       const randomIndex = Math.floor(Math.random() * target.host.length);
       return {
         host: target.host[randomIndex],
-        port: target.port
+        port: this.resolvePort(target.port, incomingPort)
       };
     }
     
     // Single host
     return {
       host: target.host,
-      port: target.port
+      port: this.resolvePort(target.port, incomingPort)
     };
   }
   
+  /**
+   * Resolves a port value, handling 'preserve' and function ports
+   * @param port The port value to resolve
+   * @param incomingPort Optional incoming port to use for 'preserve' mode
+   */
+  protected resolvePort(
+    port: number | 'preserve' | ((ctx: any) => number), 
+    incomingPort: number = 80
+  ): number {
+    if (typeof port === 'function') {
+      try {
+        // Create a minimal context for the function that includes the incoming port
+        const ctx = { port: incomingPort };
+        return port(ctx);
+      } catch (err) {
+        console.error('Error resolving port function:', err);
+        return incomingPort; // Fall back to incoming port
+      }
+    } else if (port === 'preserve') {
+      return incomingPort; // Use the actual incoming port for 'preserve'
+    } else {
+      return port;
+    }
+  }
+
   /**
    * Redirect an HTTP request to HTTPS
    * @param req The HTTP request

package/ts/forwarding/handlers/http-handler.ts

@@ -38,6 +38,7 @@ export class HttpForwardingHandler extends ForwardingHandler {
     // For HTTP, we mainly handle parsed requests, but we can still set up
     // some basic connection tracking
     const remoteAddress = socket.remoteAddress || 'unknown';
+    const localPort = socket.localPort || 80;
     
     socket.on('close', (hadError) => {
       this.emit(ForwardingHandlerEvents.DISCONNECTED, {
@@ -54,7 +55,8 @@ export class HttpForwardingHandler extends ForwardingHandler {
     });
     
     this.emit(ForwardingHandlerEvents.CONNECTED, {
-      remoteAddress
+      remoteAddress,
+      localPort
     });
   }
   
@@ -64,8 +66,11 @@ export class HttpForwardingHandler extends ForwardingHandler {
    * @param res The HTTP response
    */
   public handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void {
-    // Get the target from configuration
-    const target = this.getTargetFromConfig();
+    // Get the local port from the request (for 'preserve' port handling)
+    const localPort = req.socket.localPort || 80;
+    
+    // Get the target from configuration, passing the incoming port
+    const target = this.getTargetFromConfig(localPort);
     
     // Create a custom headers object with variables for substitution
     const variables = {

package/ts/forwarding/index.ts

@@ -3,9 +3,6 @@
  * Provides a flexible and type-safe way to configure and manage various forwarding strategies
  */
 
-// Export types and configuration
-export * from './config/forwarding-types.js';
-
 // Export handlers
 export { ForwardingHandler } from './handlers/base-handler.js';
 export * from './handlers/http-handler.js';
@@ -16,20 +13,23 @@ export * from './handlers/https-terminate-to-https-handler.js';
 // Export factory
 export * from './factory/forwarding-factory.js';
 
-// Helper functions as a convenience object
-import {
-  httpOnly,
-  tlsTerminateToHttp,
-  tlsTerminateToHttps,
-  httpsPassthrough
+// Export types - these include TForwardingType and IForwardConfig
+export type { 
+  TForwardingType,
+  IForwardConfig,
+  IForwardingHandler
 } from './config/forwarding-types.js';
 
-// Export route-based helpers from smart-proxy
-export * from '../proxies/smart-proxy/utils/route-helpers.js';
+export { 
+  ForwardingHandlerEvents
+} from './config/forwarding-types.js';
 
-export const helpers = {
-  httpOnly,
-  tlsTerminateToHttp,
-  tlsTerminateToHttps,
-  httpsPassthrough
-};
+// Export route helpers directly from route-patterns
+export {
+  createHttpRoute,
+  createHttpsTerminateRoute,
+  createHttpsPassthroughRoute,
+  createHttpToHttpsRedirect,
+  createCompleteHttpsServer,
+  createLoadBalancerRoute
+} from '../proxies/smart-proxy/utils/route-patterns.js';

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

@@ -3,6 +3,3 @@
  */
 export * from './interfaces.js';
 export * from './route-types.js';
-
-// Re-export IRoutedSmartProxyOptions explicitly to avoid ambiguity
-export type { ISmartProxyOptions as IRoutedSmartProxyOptions } from './interfaces.js';

package/ts/proxies/smart-proxy/models/interfaces.ts

@@ -8,23 +8,7 @@ import type { TForwardingType } from '../../../forwarding/config/forwarding-type
  */
 export type TSmartProxyCertProvisionObject = plugins.tsclass.network.ICert | 'http01';
 
-/**
- * Alias for backward compatibility with code that uses IRoutedSmartProxyOptions
- */
-export type IRoutedSmartProxyOptions = ISmartProxyOptions;
-
-/**
- * Helper functions for type checking configuration types
- */
-export function isLegacyOptions(options: any): boolean {
-  // Legacy options are no longer supported
-  return false;
-}
-
-export function isRoutedOptions(options: any): boolean {
-  // All configurations are now route-based
-  return true;
-}
+// Legacy options and type checking functions have been removed
 
 /**
  * SmartProxy configuration options
@@ -43,8 +27,8 @@ export interface ISmartProxyOptions {
       port: number; // Default port to use when not specified in routes
     };
     security?: {
-      allowedIps?: string[]; // Default allowed IPs
-      blockedIps?: string[]; // Default blocked IPs
+      ipAllowList?: string[]; // Default allowed IPs
+      ipBlockList?: string[]; // Default blocked IPs
       maxConnections?: number; // Default max connections
     };
     preserveSourceIP?: boolean; // Default source IP preservation

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

@@ -112,13 +112,39 @@ export interface IRouteAuthentication {
 }
 
 /**
- * Security options for route actions
+ * Security options for routes
  */
 export interface IRouteSecurity {
-  allowedIps?: string[];
-  blockedIps?: string[];
-  maxConnections?: number;
+  // Access control lists
+  ipAllowList?: string[];       // IP addresses that are allowed to connect
+  ipBlockList?: string[];       // IP addresses that are blocked from connecting
+  
+  // Connection limits
+  maxConnections?: number;      // Maximum concurrent connections
+  
+  // Authentication
   authentication?: IRouteAuthentication;
+  
+  // Rate limiting
+  rateLimit?: IRouteRateLimit;
+  
+  // Authentication methods
+  basicAuth?: {
+    enabled: boolean;
+    users: Array<{ username: string; password: string }>;
+    realm?: string;
+    excludePaths?: string[];
+  };
+  
+  jwtAuth?: {
+    enabled: boolean;
+    secret: string;
+    algorithm?: string;
+    issuer?: string;
+    audience?: string;
+    expiresIn?: number;
+    excludePaths?: string[];
+  };
 }
 
 /**
@@ -247,29 +273,7 @@ export interface IRouteRateLimit {
   errorMessage?: string;
 }
 
-/**
- * Security features for routes
- */
-export interface IRouteSecurity {
-  rateLimit?: IRouteRateLimit;
-  basicAuth?: {
-    enabled: boolean;
-    users: Array<{ username: string; password: string }>;
-    realm?: string;
-    excludePaths?: string[];
-  };
-  jwtAuth?: {
-    enabled: boolean;
-    secret: string;
-    algorithm?: string;
-    issuer?: string;
-    audience?: string;
-    expiresIn?: number;
-    excludePaths?: string[];
-  };
-  ipAllowList?: string[];
-  ipBlockList?: string[];
-}
+// IRouteSecurity is defined above - unified definition is used for all routes
 
 /**
  * CORS configuration for a route
@@ -321,61 +325,4 @@ export interface IRouteConfig {
   enabled?: boolean;         // Whether the route is active (default: true)
 }
 
-/**
- * Unified SmartProxy options with routes-based configuration
- */
-export interface IRoutedSmartProxyOptions {
-  // The unified configuration array (required)
-  routes: IRouteConfig[];
-
-  // Global/default settings
-  defaults?: {
-    target?: {
-      host: string;
-      port: number;
-    };
-    security?: IRouteSecurity;
-    tls?: IRouteTls;
-    // ...other defaults
-  };
-
-  // Other global settings remain (acme, etc.)
-  acme?: IAcmeOptions;
-
-  // Connection timeouts and other global settings
-  initialDataTimeout?: number;
-  socketTimeout?: number;
-  inactivityCheckInterval?: number;
-  maxConnectionLifetime?: number;
-  inactivityTimeout?: number;
-  gracefulShutdownTimeout?: number;
-
-  // Socket optimization settings
-  noDelay?: boolean;
-  keepAlive?: boolean;
-  keepAliveInitialDelay?: number;
-  maxPendingDataSize?: number;
-
-  // Enhanced features
-  disableInactivityCheck?: boolean;
-  enableKeepAliveProbes?: boolean;
-  enableDetailedLogging?: boolean;
-  enableTlsDebugLogging?: boolean;
-  enableRandomizedTimeouts?: boolean;
-  allowSessionTicket?: boolean;
-
-  // Rate limiting and security
-  maxConnectionsPerIP?: number;
-  connectionRateLimitPerMinute?: number;
-
-  // Enhanced keep-alive settings
-  keepAliveTreatment?: 'standard' | 'extended' | 'immortal';
-  keepAliveInactivityMultiplier?: number;
-  extendedKeepAliveLifetime?: number;
-
-  /**
-   * Optional certificate provider callback. Return 'http01' to use HTTP-01 challenges,
-   * or a static certificate object for immediate provisioning.
-   */
-  certProvisionFunction?: (domain: string) => Promise<any>;
-}
+// Configuration moved to models/interfaces.ts as ISmartProxyOptions

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

@@ -3,9 +3,7 @@ import type {
   IConnectionRecord,
   ISmartProxyOptions
 } from './models/interfaces.js';
-import {
-  isRoutedOptions
-} from './models/interfaces.js';
+// Route checking functions have been removed
 import type {
   IRouteConfig,
   IRouteAction,
@@ -291,11 +289,11 @@ export class RouteConnectionHandler {
       // Check default security settings
       const defaultSecuritySettings = this.settings.defaults?.security;
       if (defaultSecuritySettings) {
-        if (defaultSecuritySettings.allowedIps && defaultSecuritySettings.allowedIps.length > 0) {
+        if (defaultSecuritySettings.ipAllowList && defaultSecuritySettings.ipAllowList.length > 0) {
           const isAllowed = this.securityManager.isIPAuthorized(
             remoteIP,
-            defaultSecuritySettings.allowedIps,
-            defaultSecuritySettings.blockedIps || []
+            defaultSecuritySettings.ipAllowList,
+            defaultSecuritySettings.ipBlockList || []
           );
 
           if (!isAllowed) {
@@ -316,7 +314,6 @@ export class RouteConnectionHandler {
         return this.setupDirectConnection(
           socket,
           record,
-          undefined,
           serverName,
           initialChunk,
           undefined,
@@ -457,7 +454,6 @@ export class RouteConnectionHandler {
           return this.setupDirectConnection(
             socket,
             record,
-            undefined,
             record.lockedDomain,
             initialChunk,
             undefined,
@@ -538,7 +534,6 @@ export class RouteConnectionHandler {
       return this.setupDirectConnection(
         socket,
         record,
-        undefined,
         record.lockedDomain,
         initialChunk,
         undefined,
@@ -656,17 +651,12 @@ export class RouteConnectionHandler {
     this.connectionManager.initiateCleanupOnce(record, 'route_blocked');
   }
   
-  /**
-   * Legacy connection handling has been removed in favor of pure route-based approach
-   */
-  
   /**
    * Sets up a direct connection to the target
    */
   private setupDirectConnection(
     socket: plugins.net.Socket,
     record: IConnectionRecord,
-    _unused?: any, // kept for backward compatibility
     serverName?: string,
     initialChunk?: Buffer,
     overridePort?: number,

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

@@ -6,12 +6,7 @@ import type {
   TPortRange
 } from './models/route-types.js';
 import type {
-  ISmartProxyOptions,
-  IRoutedSmartProxyOptions
-} from './models/interfaces.js';
-import {
-  isRoutedOptions,
-  isLegacyOptions
+  ISmartProxyOptions
 } from './models/interfaces.js';
 
 /**
@@ -29,12 +24,12 @@ export interface IRouteMatchResult {
 export class RouteManager extends plugins.EventEmitter {
   private routes: IRouteConfig[] = [];
   private portMap: Map<number, IRouteConfig[]> = new Map();
-  private options: IRoutedSmartProxyOptions;
+  private options: ISmartProxyOptions;
   
   constructor(options: ISmartProxyOptions) {
     super();
     
-    // We no longer support legacy options, always use provided options
+    // Store options
     this.options = options;
     
     // Initialize routes from either source
@@ -218,8 +213,8 @@ export class RouteManager extends plugins.EventEmitter {
     }
     
     // Check blocked IPs first
-    if (security.blockedIps && security.blockedIps.length > 0) {
-      for (const pattern of security.blockedIps) {
+    if (security.ipBlockList && security.ipBlockList.length > 0) {
+      for (const pattern of security.ipBlockList) {
         if (this.matchIpPattern(pattern, clientIp)) {
           return false; // IP is blocked
         }
@@ -227,8 +222,8 @@ export class RouteManager extends plugins.EventEmitter {
     }
     
     // If there are allowed IPs, check them
-    if (security.allowedIps && security.allowedIps.length > 0) {
-      for (const pattern of security.allowedIps) {
+    if (security.ipAllowList && security.ipAllowList.length > 0) {
+      for (const pattern of security.ipAllowList) {
         if (this.matchIpPattern(pattern, clientIp)) {
           return true; // IP is allowed
         }