@push.rocks/smartproxy 16.0.3 → 17.0.0

package/dist_ts/proxies/smart-proxy/utils/route-patterns.js

@@ -4,8 +4,112 @@
  * This file provides pre-defined route patterns for common use cases.
  * These patterns can be used as templates for creating route configurations.
  */
-import { createHttpRoute, createHttpsTerminateRoute, createHttpsPassthroughRoute, createCompleteHttpsServer } from './route-helpers.js';
 import { mergeRouteConfigs } from './route-utils.js';
+/**
+ * Create a basic HTTP route configuration
+ */
+export function createHttpRoute(domains, target, options = {}) {
+    const route = {
+        match: {
+            domains,
+            ports: 80
+        },
+        action: {
+            type: 'forward',
+            target: {
+                host: target.host,
+                port: target.port
+            }
+        },
+        name: options.name || `HTTP: ${Array.isArray(domains) ? domains.join(', ') : domains}`
+    };
+    return mergeRouteConfigs(route, options);
+}
+/**
+ * Create an HTTPS route with TLS termination
+ */
+export function createHttpsTerminateRoute(domains, target, options = {}) {
+    const route = {
+        match: {
+            domains,
+            ports: 443
+        },
+        action: {
+            type: 'forward',
+            target: {
+                host: target.host,
+                port: target.port
+            },
+            tls: {
+                mode: options.reencrypt ? 'terminate-and-reencrypt' : 'terminate',
+                certificate: options.certificate || 'auto'
+            }
+        },
+        name: options.name || `HTTPS (terminate): ${Array.isArray(domains) ? domains.join(', ') : domains}`
+    };
+    return mergeRouteConfigs(route, options);
+}
+/**
+ * Create an HTTPS route with TLS passthrough
+ */
+export function createHttpsPassthroughRoute(domains, target, options = {}) {
+    const route = {
+        match: {
+            domains,
+            ports: 443
+        },
+        action: {
+            type: 'forward',
+            target: {
+                host: target.host,
+                port: target.port
+            },
+            tls: {
+                mode: 'passthrough'
+            }
+        },
+        name: options.name || `HTTPS (passthrough): ${Array.isArray(domains) ? domains.join(', ') : domains}`
+    };
+    return mergeRouteConfigs(route, options);
+}
+/**
+ * Create an HTTP to HTTPS redirect route
+ */
+export function createHttpToHttpsRedirect(domains, options = {}) {
+    const route = {
+        match: {
+            domains,
+            ports: 80
+        },
+        action: {
+            type: 'redirect',
+            redirect: {
+                to: options.preservePath ? 'https://{domain}{path}' : 'https://{domain}',
+                status: options.redirectCode || 301
+            }
+        },
+        name: options.name || `HTTP to HTTPS redirect: ${Array.isArray(domains) ? domains.join(', ') : domains}`
+    };
+    return mergeRouteConfigs(route, options);
+}
+/**
+ * Create a complete HTTPS server with redirect from HTTP
+ */
+export function createCompleteHttpsServer(domains, target, options = {}) {
+    // Create the TLS route based on the selected mode
+    const tlsRoute = options.tlsMode === 'passthrough'
+        ? createHttpsPassthroughRoute(domains, target, options)
+        : createHttpsTerminateRoute(domains, target, {
+            ...options,
+            reencrypt: options.tlsMode === 'terminate-and-reencrypt'
+        });
+    // Create the HTTP to HTTPS redirect route
+    const redirectRoute = createHttpToHttpsRedirect(domains, {
+        redirectCode: options.redirectCode,
+        preservePath: true
+    });
+    return [tlsRoute, redirectRoute];
+}
 /**
  * Create an API Gateway route pattern
  * @param domains Domain(s) to match
@@ -214,4 +318,4 @@ export function addJwtAuth(baseRoute, jwt) {
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-patterns.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-patterns.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "16.0.3",
+  "version": "17.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",

package/readme.plan.md

@@ -1,103 +1,201 @@
-# SmartProxy Configuration Troubleshooting
+# SmartProxy Codebase Cleanup Plan
 
-## IPv6/IPv4 Mapping Issue
+## Overview
 
-### Problem Identified
-The SmartProxy is failing to match connections for wildcard domains (like `*.lossless.digital`) when IP restrictions are in place. After extensive debugging, the root cause has been identified:
+This document outlines a comprehensive plan to clean up the SmartProxy codebase by removing deprecated and unused code, consolidating functionality, and reducing complexity. The goal is to make the codebase more maintainable, easier to understand, and better positioned for future enhancements.
 
-When a connection comes in from an IPv4 address (e.g., `212.95.99.130`), the Node.js server receives it as an IPv6-mapped IPv4 address with the format `::ffff:212.95.99.130`. However, the route configuration is expecting the exact string `212.95.99.130`, causing a mismatch.
+## Phase 1: Remove Deprecated Code
 
-From the debug logs:
-```
-[DEBUG] Route rejected: clientIp mismatch. Request: ::ffff:212.95.99.130, Route patterns: ["212.95.99.130"]
-```
+### 1.1 Delete Legacy Migration Utilities ✅
 
-### Solution
+The route migration utilities were created to assist in transitioning from the legacy domain-based configuration to the new route-based configuration system. As this migration is now complete, these utilities can be safely removed.
 
-To fix this issue, update the route configurations to include both formats of the IP address. Here's how to modify the affected route:
+- **Action:** ✅ Remove `/ts/proxies/smart-proxy/utils/route-migration-utils.ts`
+- **Impact:** Low - This file is explicitly marked as temporary and for migration purposes only
+- **Dependencies:** ✅ Update any imports of these utilities (check forwarding-types.ts)
 
-```typescript
-// Wildcard domain route for *.lossless.digital
-{
-  match: {
-    ports: 443,
-    domains: ['*.lossless.digital'],
-    clientIp: ['212.95.99.130', '::ffff:212.95.99.130'],  // Include both formats
-  },
-  action: {
-    type: 'forward',
-    target: {
-      host: '212.95.99.130',
-      port: 443
-    },
-    tls: {
-      mode: 'passthrough'
-    },
-    security: {
-      allowedIps: ['212.95.99.130', '::ffff:212.95.99.130']  // Include both formats
-    }
-  },
-  name: 'Wildcard lossless.digital route (IP restricted)'
-}
-```
+### 1.2 Clean Up References to Deleted Files ✅
 
-### Alternative Long-Term Fix
+Several files are marked for deletion in the git status but are still referenced in the codebase.
 
-A more robust solution would be to modify the SmartProxy codebase to automatically handle IPv6-mapped IPv4 addresses by normalizing them before comparison. This would involve:
+- **Action:** ✅ Remove references to deleted route-helpers files:
+  - ✅ Update `/ts/proxies/smart-proxy/utils/index.ts` to remove `export * from './route-helpers.js';`
+  - ✅ Update `/ts/forwarding/config/forwarding-types.ts` to remove imports and re-exports of route helper functions
+- **Impact:** Medium - May break code that still relies on these helpers
+- **Dependencies:** ✅ Ensure route-patterns.js provides equivalent functionality (moved helper functions from route-helpers.js to route-patterns.ts)
 
-1. Modifying the `matchIpPattern` function in `route-manager.ts` to normalize IPv6-mapped IPv4 addresses:
+### 1.3 Remove Deprecated Forwarding Types and Helpers ✅
 
-```typescript
-private matchIpPattern(pattern: string, ip: string): boolean {
-  // Normalize IPv6-mapped IPv4 addresses
-  const normalizedIp = ip.startsWith('::ffff:') ? ip.substring(7) : ip;
-  const normalizedPattern = pattern.startsWith('::ffff:') ? pattern.substring(7) : pattern;
-  
-  // Handle exact match with normalized addresses
-  if (normalizedPattern === normalizedIp) {
-    return true;
-  }
-  
-  // Rest of the existing function...
-}
-```
+Legacy forwarding types and helper functions in forwarding-types.ts are marked as deprecated.
 
-2. Making similar modifications to other IP-related functions in the codebase.
+- **Action:** ✅ 
+  - ✅ Clean up `/ts/forwarding/config/forwarding-types.ts`
+  - ✅ Remove deprecated helper functions: `httpOnly`, `tlsTerminateToHttp`, `tlsTerminateToHttps`, `httpsPassthrough`
+  - ✅ Remove deprecated interfaces: `IDeprecatedForwardConfig`
+- **Impact:** Medium - May break code that still uses these helpers
+- **Dependencies:** ✅ Ensure route patterns provide equivalent functionality
 
-## Wild Card Domain Matching Issue
+## Phase 2: Consolidate and Simplify Code
 
-### Explanation
+### 2.1 Streamline Interface Definitions ✅
 
-The wildcard domain matching in SmartProxy works as follows:
+There are several redundant interfaces that could be simplified.
 
-1. When a pattern like `*.lossless.digital` is specified, it's converted to a regex: `/^.*\.lossless\.digital$/i`
-2. This correctly matches any subdomain like `my.lossless.digital`, `api.lossless.digital`, etc.
-3. However, it does NOT match the apex domain `lossless.digital` (without a subdomain)
+- **Action:** ✅
+  - ✅ Remove legacy type checking functions (`isLegacyOptions`, `isRoutedOptions`) in `/ts/proxies/smart-proxy/models/interfaces.ts`
+  - ✅ Update `ISmartProxyOptions` interface to remove obsolete properties
+  - ✅ Remove backward compatibility aliases like `IRoutedSmartProxyOptions`
+- **Impact:** Medium - May break code that relies on these interfaces
+- **Dependencies:** ✅ Update any code that references these interfaces
 
-If you need to match both the apex domain and subdomains, use a list:
-```typescript
-domains: ['lossless.digital', '*.lossless.digital']
+### 2.2 Consolidate Route Utilities
+
+The route utilities are spread across multiple files with some overlapping functionality.
+
+- **Action:**
+  - Consolidate route utilities into a single coherent structure
+  - Move common functions from route-utils.ts, route-patterns.ts into a single location
+  - Ensure consistent naming conventions for route utility functions
+- **Impact:** Medium - Requires careful refactoring
+- **Dependencies:** Update all references to these utilities
+
+### 2.3 Clean Up Legacy Connection Handling ✅
+
+The route-connection-handler.ts file contains legacy code and parameters kept for backward compatibility.
+
+- **Action:** ✅
+  - ✅ Remove unused parameters and legacy comments from `setupDirectConnection` method
+  - ✅ Simplify connection handling logic by removing special cases for legacy configurations
+- **Impact:** Medium - Requires careful testing to ensure no regressions
+- **Dependencies:** ✅ Test with all current route configurations
+
+## Phase 3: Code Modernization
+
+### 3.1 Standardize on 'preserve' Port Handling ✅
+
+Previously implemented changes to use `port: 'preserve'` instead of `preservePort: true` should be consistently applied.
+
+- **Action:** ✅
+  - ✅ Ensure all code paths handle the 'preserve' value for port
+  - ✅ Remove any remaining references to preservePort in code and documentation
+- **Impact:** Low - Already implemented in most places
+- **Dependencies:** None
+
+### 3.2 Normalize IPv6-Mapped IPv4 Addresses ✅
+
+Implement consistent handling of IPv6-mapped IPv4 addresses throughout the codebase.
+
+- **Action:** ✅
+  - ✅ Ensure any IP address comparisons consistently handle IPv6-mapped IPv4 addresses
+  - ✅ Standardize on a single approach to IP normalization
+- **Impact:** Low - Already partially implemented
+- **Dependencies:** None
+
+### 3.3 Improve Type Safety ✅
+
+Enhance type safety throughout the codebase to catch errors at compile time.
+
+- **Action:** ✅
+  - ✅ Add stronger types where appropriate
+  - ✅ Remove any `any` types that could be replaced with more specific types
+  - ✅ Add explicit return types to functions
+- **Impact:** Medium - May uncover existing issues
+- **Dependencies:** None
+
+## Phase 4: Documentation and Tests
+
+### 4.1 Update API Documentation ✅
+
+Ensure documentation is current and accurately reflects the cleaned-up API.
+
+- **Action:** ✅
+  - ✅ Update comments and JSDoc throughout the codebase
+  - ✅ Ensure porthandling.md and other documentation reflect current implementation
+  - ✅ Remove references to deprecated functionality
+- **Impact:** Low
+- **Dependencies:** None
+
+### 4.2 Add or Update Tests ✅
+
+Ensure test coverage for the cleaned-up codebase.
+
+- **Action:** ✅
+  - ✅ Update existing tests to remove references to deprecated functionality
+  - ✅ Add tests for edge cases in IP normalization
+  - ✅ Add tests for the updated route utility functions
+- **Impact:** Medium
+- **Dependencies:** None
+
+## Implementation Sequence ✅
+
+The changes were implemented in this order:
+
+1. ✅ **Phase 1.1**: Remove Legacy Migration Utilities
+2. ✅ **Phase 1.2**: Clean Up References to Deleted Files
+3. ✅ **Phase 1.3**: Remove Deprecated Forwarding Types and Helpers
+4. ✅ **Phase 2.1**: Streamline Interface Definitions
+5. ✅ **Phase 3.1**: Standardize on 'preserve' Port Handling
+6. ✅ **Phase 3.2**: Normalize IPv6-Mapped IPv4 Addresses
+7. ⏸️ **Phase 2.2**: Consolidate Route Utilities (Postponed - Low priority)
+8. ✅ **Phase 2.3**: Clean Up Legacy Connection Handling
+9. ✅ **Phase 3.3**: Improve Type Safety
+10. ✅ **Phase 4.1**: Update API Documentation
+11. ✅ **Phase 4.2**: Add or Update Tests
+
+## Detailed Implementation Steps
+
+### 1. Remove Legacy Migration Utilities
+
+```bash
+# Delete the file
+git rm ts/proxies/smart-proxy/utils/route-migration-utils.ts
+
+# Remove the export from the index file
+# Edit ts/proxies/smart-proxy/utils/index.ts to remove the export line
 ```
 
-## Debugging SmartProxy
+### 2. Clean Up References to Deleted Files
 
-To debug routing issues in SmartProxy:
+```bash
+# Update forwarding-types.ts to remove imports from route-helpers.js
+# Edit ts/forwarding/config/forwarding-types.ts
 
-1. Add detailed logging to the `route-manager.js` file in the `dist_ts` directory:
-   - `findMatchingRoute` method - to see what criteria are being checked
-   - `matchRouteDomain` method - to see domain matching logic
-   - `matchDomain` method - to see pattern matching
-   - `matchIpPattern` method - to see IP matching logic
+# Remove or update imports in index.ts
+# Edit ts/proxies/smart-proxy/utils/index.ts
+```
+
+### 3. Remove Deprecated Forwarding Types
+
+```bash
+# Edit ts/forwarding/config/forwarding-types.ts to remove deprecated helpers and interfaces
+```
+
+### 4. Streamline Interface Definitions
 
-2. Run the proxy with debugging enabled:
-   ```
-   pnpm run startNew
-   ```
+```bash
+# Edit ts/proxies/smart-proxy/models/interfaces.ts to remove legacy functions and aliases
+```
+
+### 5. Normalize IPv6-Mapped IPv4 Addresses
+
+Ensure all IP matching functions consistently handle IPv6-mapped IPv4 addresses:
+
+```typescript
+// In all IP matching functions:
+const normalizeIp = (ip: string): string => {
+  return ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+};
+```
 
-3. Monitor the logs for detailed information about the routing process and identify where matches are failing.
+## Implementation Results ✅
 
-## Priority and Route Order
+The cleanup implementation was successful, resulting in:
 
-Remember that routes are evaluated in priority order (higher priority first). If multiple routes could match the same request, ensure that the more specific routes have higher priority.
+- **Reduced Codebase Size**: Successfully removed multiple deprecated files and functions
+- **Improved Maintainability**: Cleaner, more focused code without legacy compatibility layers
+- **Reduced Complexity**: Eliminated special cases for legacy config formats
+- **Better Developer Experience**: Standardized on consistent patterns for port handling
+- **Future-Proofing**: Removed deprecated code that would complicate future upgrades
+- **Type Safety**: Fixed multiple TypeScript errors and improved type checking
 
-When routes have the same priority (or none specified), they're evaluated in the order they're defined in the configuration.
+All changes successfully compile and the build process passes with no errors. The codebase is now simpler, more maintainable, and better positioned for future enhancements.

package/ts/00_commitinfo_data.ts

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