@push.rocks/smartproxy 19.3.2 → 19.3.3

package/ts/proxies/{network-proxy → http-proxy}/websocket-handler.ts

@@ -1,8 +1,8 @@
 import * as plugins from '../../plugins.js';
 import '../../core/models/socket-augmentation.js';
-import { type INetworkProxyOptions, type IWebSocketWithHeartbeat, type ILogger, createLogger, type IReverseProxyConfig } from './models/types.js';
+import { type IHttpProxyOptions, type IWebSocketWithHeartbeat, type ILogger, createLogger, type IReverseProxyConfig } from './models/types.js';
 import { ConnectionPool } from './connection-pool.js';
-import { ProxyRouter, RouteRouter } from '../../http/router/index.js';
+import { ProxyRouter, RouteRouter } from '../../routing/router/index.js';
 import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
 import type { IRouteContext } from '../../core/models/route-context.js';
 import { toBaseContext } from '../../core/models/route-context.js';
@@ -23,7 +23,7 @@ export class WebSocketHandler {
   private securityManager: SecurityManager;
 
   constructor(
-    private options: INetworkProxyOptions,
+    private options: IHttpProxyOptions,
     private connectionPool: ConnectionPool,
     private legacyRouter: ProxyRouter, // Legacy router for backward compatibility
     private routes: IRouteConfig[] = [] // Routes for modern router

package/ts/proxies/index.ts

@@ -2,15 +2,15 @@
  * Proxy implementations module
  */
 
-// Export NetworkProxy with selective imports to avoid conflicts
-export { NetworkProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './network-proxy/index.js';
-export type { IMetricsTracker, MetricsTracker } from './network-proxy/index.js';
-// Export network-proxy models except IAcmeOptions
-export type { INetworkProxyOptions, ICertificateEntry, ILogger } from './network-proxy/models/types.js';
-export { RouteManager as NetworkProxyRouteManager } from './network-proxy/models/types.js';
+// Export HttpProxy with selective imports to avoid conflicts
+export { HttpProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './http-proxy/index.js';
+export type { IMetricsTracker, MetricsTracker } from './http-proxy/index.js';
+// Export http-proxy models except IAcmeOptions
+export type { IHttpProxyOptions, ICertificateEntry, ILogger } from './http-proxy/models/types.js';
+export { RouteManager as HttpProxyRouteManager } from './http-proxy/models/types.js';
 
 // Export SmartProxy with selective imports to avoid conflicts
-export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, NetworkProxyBridge, RouteConnectionHandler } from './smart-proxy/index.js';
+export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, HttpProxyBridge, RouteConnectionHandler } from './smart-proxy/index.js';
 export { RouteManager as SmartProxyRouteManager } from './smart-proxy/route-manager.js';
 export * from './smart-proxy/utils/index.js';
 // Export smart-proxy models except IAcmeOptions

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

@@ -1,5 +1,5 @@
 import * as plugins from '../../plugins.js';
-import { NetworkProxy } from '../network-proxy/index.js';
+import { HttpProxy } from '../http-proxy/index.js';
 import type { IRouteConfig, IRouteTls } from './models/route-types.js';
 import type { IAcmeOptions } from './models/interfaces.js';
 import { CertStore } from './cert-store.js';
@@ -25,7 +25,7 @@ export interface ICertificateData {
 export class SmartCertManager {
   private certStore: CertStore;
   private smartAcme: plugins.smartacme.SmartAcme | null = null;
-  private networkProxy: NetworkProxy | null = null;
+  private httpProxy: HttpProxy | null = null;
   private renewalTimer: NodeJS.Timeout | null = null;
   private pendingChallenges: Map<string, string> = new Map();
   private challengeRoute: IRouteConfig | null = null;
@@ -68,8 +68,8 @@ export class SmartCertManager {
     }
   }
   
-  public setNetworkProxy(networkProxy: NetworkProxy): void {
-    this.networkProxy = networkProxy;
+  public setHttpProxy(httpProxy: HttpProxy): void {
+    this.httpProxy = httpProxy;
   }
   
   
@@ -336,23 +336,23 @@ export class SmartCertManager {
   }
   
   /**
-   * Apply certificate to NetworkProxy
+   * Apply certificate to HttpProxy
    */
   private async applyCertificate(domain: string, certData: ICertificateData): Promise<void> {
-    if (!this.networkProxy) {
-      console.warn('NetworkProxy not set, cannot apply certificate');
+    if (!this.httpProxy) {
+      console.warn('HttpProxy not set, cannot apply certificate');
       return;
     }
     
-    // Apply certificate to NetworkProxy
-    this.networkProxy.updateCertificate(domain, certData.cert, certData.key);
+    // Apply certificate to HttpProxy
+    this.httpProxy.updateCertificate(domain, certData.cert, certData.key);
     
     // Also apply for wildcard if it's a subdomain
     if (domain.includes('.') && !domain.startsWith('*.')) {
       const parts = domain.split('.');
       if (parts.length >= 2) {
         const wildcardDomain = `*.${parts.slice(-2).join('.')}`;
-        this.networkProxy.updateCertificate(wildcardDomain, certData.cert, certData.key);
+        this.httpProxy.updateCertificate(wildcardDomain, certData.cert, certData.key);
       }
     }
   }

package/ts/proxies/smart-proxy/{network-proxy-bridge.ts → http-proxy-bridge.ts}

@@ -1,47 +1,47 @@
 import * as plugins from '../../plugins.js';
-import { NetworkProxy } from '../network-proxy/index.js';
+import { HttpProxy } from '../http-proxy/index.js';
 import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
 import type { IRouteConfig } from './models/route-types.js';
 
-export class NetworkProxyBridge {
-  private networkProxy: NetworkProxy | null = null;
+export class HttpProxyBridge {
+  private httpProxy: HttpProxy | null = null;
 
   constructor(private settings: ISmartProxyOptions) {}
   
   /**
-   * Get the NetworkProxy instance
+   * Get the HttpProxy instance
    */
-  public getNetworkProxy(): NetworkProxy | null {
-    return this.networkProxy;
+  public getHttpProxy(): HttpProxy | null {
+    return this.httpProxy;
   }
   
   /**
-   * Initialize NetworkProxy instance
+   * Initialize HttpProxy instance
    */
   public async initialize(): Promise<void> {
-    if (!this.networkProxy && this.settings.useNetworkProxy && this.settings.useNetworkProxy.length > 0) {
-      const networkProxyOptions: any = {
-        port: this.settings.networkProxyPort!,
+    if (!this.httpProxy && this.settings.useHttpProxy && this.settings.useHttpProxy.length > 0) {
+      const httpProxyOptions: any = {
+        port: this.settings.httpProxyPort!,
         portProxyIntegration: true,
         logLevel: this.settings.enableDetailedLogging ? 'debug' : 'info'
       };
 
-      this.networkProxy = new NetworkProxy(networkProxyOptions);
-      console.log(`Initialized NetworkProxy on port ${this.settings.networkProxyPort}`);
+      this.httpProxy = new HttpProxy(httpProxyOptions);
+      console.log(`Initialized HttpProxy on port ${this.settings.httpProxyPort}`);
 
-      // Apply route configurations to NetworkProxy
-      await this.syncRoutesToNetworkProxy(this.settings.routes || []);
+      // Apply route configurations to HttpProxy
+      await this.syncRoutesToHttpProxy(this.settings.routes || []);
     }
   }
   
   /**
-   * Sync routes to NetworkProxy
+   * Sync routes to HttpProxy
    */
-  public async syncRoutesToNetworkProxy(routes: IRouteConfig[]): Promise<void> {
-    if (!this.networkProxy) return;
+  public async syncRoutesToHttpProxy(routes: IRouteConfig[]): Promise<void> {
+    if (!this.httpProxy) return;
     
-    // Convert routes to NetworkProxy format
-    const networkProxyConfigs = routes
+    // Convert routes to HttpProxy format
+    const httpProxyConfigs = routes
       .filter(route => {
         // Check if this route matches any of the specified network proxy ports
         const routePorts = Array.isArray(route.match.ports) 
@@ -49,20 +49,20 @@ export class NetworkProxyBridge {
           : [route.match.ports];
         
         return routePorts.some(port => 
-          this.settings.useNetworkProxy?.includes(port)
+          this.settings.useHttpProxy?.includes(port)
         );
       })
-      .map(route => this.routeToNetworkProxyConfig(route));
+      .map(route => this.routeToHttpProxyConfig(route));
     
-    // Apply configurations to NetworkProxy
-    await this.networkProxy.updateRouteConfigs(networkProxyConfigs);
+    // Apply configurations to HttpProxy
+    await this.httpProxy.updateRouteConfigs(httpProxyConfigs);
   }
   
   /**
-   * Convert route to NetworkProxy configuration
+   * Convert route to HttpProxy configuration
    */
-  private routeToNetworkProxyConfig(route: IRouteConfig): any {
-    // Convert route to NetworkProxy domain config format
+  private routeToHttpProxyConfig(route: IRouteConfig): any {
+    // Convert route to HttpProxy domain config format
     return {
       domain: route.match.domains?.[0] || '*',
       target: route.action.target,
@@ -72,36 +72,36 @@ export class NetworkProxyBridge {
   }
   
   /**
-   * Check if connection should use NetworkProxy
+   * Check if connection should use HttpProxy
    */
-  public shouldUseNetworkProxy(connection: IConnectionRecord, routeMatch: any): boolean {
-    // Only use NetworkProxy for TLS termination
+  public shouldUseHttpProxy(connection: IConnectionRecord, routeMatch: any): boolean {
+    // Only use HttpProxy for TLS termination
     return (
       routeMatch.route.action.tls?.mode === 'terminate' ||
       routeMatch.route.action.tls?.mode === 'terminate-and-reencrypt'
-    ) && this.networkProxy !== null;
+    ) && this.httpProxy !== null;
   }
   
   /**
-   * Forward connection to NetworkProxy
+   * Forward connection to HttpProxy
    */
-  public async forwardToNetworkProxy(
+  public async forwardToHttpProxy(
     connectionId: string,
     socket: plugins.net.Socket,
     record: IConnectionRecord,
     initialChunk: Buffer,
-    networkProxyPort: number,
+    httpProxyPort: number,
     cleanupCallback: (reason: string) => void
   ): Promise<void> {
-    if (!this.networkProxy) {
-      throw new Error('NetworkProxy not initialized');
+    if (!this.httpProxy) {
+      throw new Error('HttpProxy not initialized');
     }
     
     const proxySocket = new plugins.net.Socket();
     
     await new Promise<void>((resolve, reject) => {
-      proxySocket.connect(networkProxyPort, 'localhost', () => {
-        console.log(`[${connectionId}] Connected to NetworkProxy for termination`);
+      proxySocket.connect(httpProxyPort, 'localhost', () => {
+        console.log(`[${connectionId}] Connected to HttpProxy for termination`);
         resolve();
       });
       
@@ -132,21 +132,21 @@ export class NetworkProxyBridge {
   }
   
   /**
-   * Start NetworkProxy
+   * Start HttpProxy
    */
   public async start(): Promise<void> {
-    if (this.networkProxy) {
-      await this.networkProxy.start();
+    if (this.httpProxy) {
+      await this.httpProxy.start();
     }
   }
   
   /**
-   * Stop NetworkProxy
+   * Stop HttpProxy
    */
   public async stop(): Promise<void> {
-    if (this.networkProxy) {
-      await this.networkProxy.stop();
-      this.networkProxy = null;
+    if (this.httpProxy) {
+      await this.httpProxy.stop();
+      this.httpProxy = null;
     }
   }
 }

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

@@ -14,12 +14,15 @@ export { ConnectionManager } from './connection-manager.js';
 export { SecurityManager } from './security-manager.js';
 export { TimeoutManager } from './timeout-manager.js';
 export { TlsManager } from './tls-manager.js';
-export { NetworkProxyBridge } from './network-proxy-bridge.js';
+export { HttpProxyBridge } from './http-proxy-bridge.js';
 
 // Export route-based components
 export { RouteManager } from './route-manager.js';
 export { RouteConnectionHandler } from './route-connection-handler.js';
 export { NFTablesManager } from './nftables-manager.js';
 
+// Export certificate management
+export { SmartCertManager } from './certificate-manager.js';
+
 // Export all helper functions from the utils directory
 export * from './utils/index.js';

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

@@ -94,9 +94,9 @@ export interface ISmartProxyOptions {
   keepAliveInactivityMultiplier?: number; // Multiplier for inactivity timeout for keep-alive connections
   extendedKeepAliveLifetime?: number; // Extended lifetime for keep-alive connections (ms)
 
-  // NetworkProxy integration
-  useNetworkProxy?: number[]; // Array of ports to forward to NetworkProxy
-  networkProxyPort?: number; // Port where NetworkProxy is listening (default: 8443)
+  // HttpProxy integration
+  useHttpProxy?: number[]; // Array of ports to forward to HttpProxy
+  httpProxyPort?: number; // Port where HttpProxy is listening (default: 8443)
 
   /**
    * Global ACME configuration options for SmartProxy

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

@@ -60,10 +60,10 @@ export class PortManager {
     // Start listening on the port
     return new Promise<void>((resolve, reject) => {
       server.listen(port, () => {
-        const isNetworkProxyPort = this.settings.useNetworkProxy?.includes(port);
+        const isHttpProxyPort = this.settings.useHttpProxy?.includes(port);
         console.log(
           `SmartProxy -> OK: Now listening on port ${port}${
-            isNetworkProxyPort ? ' (NetworkProxy forwarding enabled)' : ''
+            isHttpProxyPort ? ' (HttpProxy forwarding enabled)' : ''
           }`
         );