@push.rocks/smartproxy 6.0.1 → 7.1.0

package/dist_ts/redirect/classes.redirect.js

@@ -0,0 +1,194 @@
+import * as plugins from '../plugins.js';
+export class Redirect {
+    /**
+     * Create a new Redirect instance
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        this.rules = [];
+        this.httpPort = 80;
+        this.httpsPort = 443;
+        if (options.httpPort)
+            this.httpPort = options.httpPort;
+        if (options.httpsPort)
+            this.httpsPort = options.httpsPort;
+        if (options.sslOptions)
+            this.sslOptions = options.sslOptions;
+        if (options.rules)
+            this.rules = options.rules;
+    }
+    /**
+     * Add a redirect rule
+     */
+    addRule(rule) {
+        this.rules.push(rule);
+    }
+    /**
+     * Remove all redirect rules
+     */
+    clearRules() {
+        this.rules = [];
+    }
+    /**
+     * Set SSL options for HTTPS redirects
+     */
+    setSslOptions(options) {
+        this.sslOptions = options;
+    }
+    /**
+     * Process a request according to the configured rules
+     */
+    handleRequest(request, response, protocol) {
+        const requestUrl = new URL(request.url || '/', `${protocol}://${request.headers.host || 'localhost'}`);
+        const host = requestUrl.hostname;
+        const path = requestUrl.pathname + requestUrl.search;
+        // Find matching rule
+        const matchedRule = this.findMatchingRule(protocol, host, path);
+        if (matchedRule) {
+            const targetUrl = this.buildTargetUrl(matchedRule, host, path);
+            console.log(`Redirecting ${protocol}://${host}${path} to ${targetUrl}`);
+            response.writeHead(matchedRule.statusCode || 302, {
+                Location: targetUrl,
+            });
+            response.end();
+        }
+        else {
+            // No matching rule, send 404
+            response.writeHead(404, { 'Content-Type': 'text/plain' });
+            response.end('Not Found');
+        }
+    }
+    /**
+     * Find a matching redirect rule for the given request
+     */
+    findMatchingRule(protocol, host, path) {
+        return this.rules.find((rule) => {
+            // Check protocol match
+            if (rule.fromProtocol && rule.fromProtocol !== protocol) {
+                return false;
+            }
+            // Check host match
+            if (rule.fromHost) {
+                const pattern = rule.fromHost.replace(/\*/g, '(.*)');
+                const regex = new RegExp(`^${pattern}$`);
+                if (!regex.test(host)) {
+                    return false;
+                }
+            }
+            // Check path match
+            if (rule.fromPath && !path.startsWith(rule.fromPath)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Build the target URL for a redirect
+     */
+    buildTargetUrl(rule, originalHost, originalPath) {
+        let targetHost = rule.toHost;
+        // Replace wildcards in host
+        if (rule.fromHost && rule.fromHost.includes('*')) {
+            const pattern = rule.fromHost.replace(/\*/g, '(.*)');
+            const regex = new RegExp(`^${pattern}$`);
+            const matches = originalHost.match(regex);
+            if (matches) {
+                for (let i = 1; i < matches.length; i++) {
+                    targetHost = targetHost.replace(`$${i}`, matches[i]);
+                }
+            }
+        }
+        // Build target path
+        let targetPath = originalPath;
+        if (rule.toPath) {
+            if (rule.toPath.includes('$path')) {
+                // Replace $path with original path, optionally removing the fromPath prefix
+                const pathSuffix = rule.fromPath ?
+                    originalPath.substring(rule.fromPath.length) :
+                    originalPath;
+                targetPath = rule.toPath.replace('$path', pathSuffix);
+            }
+            else {
+                targetPath = rule.toPath;
+            }
+        }
+        return `${rule.toProtocol}://${targetHost}${targetPath}`;
+    }
+    /**
+     * Start the redirect server(s)
+     */
+    async start() {
+        const tasks = [];
+        // Create and start HTTP server if we have a port
+        if (this.httpPort) {
+            this.httpServer = plugins.http.createServer((req, res) => this.handleRequest(req, res, 'http'));
+            const httpStartPromise = new Promise((resolve) => {
+                this.httpServer?.listen(this.httpPort, () => {
+                    console.log(`HTTP redirect server started on port ${this.httpPort}`);
+                    resolve();
+                });
+            });
+            tasks.push(httpStartPromise);
+        }
+        // Create and start HTTPS server if we have SSL options and a port
+        if (this.httpsPort && this.sslOptions) {
+            this.httpsServer = plugins.https.createServer(this.sslOptions, (req, res) => this.handleRequest(req, res, 'https'));
+            const httpsStartPromise = new Promise((resolve) => {
+                this.httpsServer?.listen(this.httpsPort, () => {
+                    console.log(`HTTPS redirect server started on port ${this.httpsPort}`);
+                    resolve();
+                });
+            });
+            tasks.push(httpsStartPromise);
+        }
+        // Wait for all servers to start
+        await Promise.all(tasks);
+    }
+    /**
+     * Stop the redirect server(s)
+     */
+    async stop() {
+        const tasks = [];
+        if (this.httpServer) {
+            const httpStopPromise = new Promise((resolve) => {
+                this.httpServer?.close(() => {
+                    console.log('HTTP redirect server stopped');
+                    resolve();
+                });
+            });
+            tasks.push(httpStopPromise);
+        }
+        if (this.httpsServer) {
+            const httpsStopPromise = new Promise((resolve) => {
+                this.httpsServer?.close(() => {
+                    console.log('HTTPS redirect server stopped');
+                    resolve();
+                });
+            });
+            tasks.push(httpsStopPromise);
+        }
+        await Promise.all(tasks);
+    }
+}
+// For backward compatibility
+export class SslRedirect {
+    constructor(portArg) {
+        this.port = portArg;
+        this.redirect = new Redirect({
+            httpPort: portArg,
+            rules: [{
+                    fromProtocol: 'http',
+                    toProtocol: 'https',
+                    toHost: '$1',
+                    statusCode: 302
+                }]
+        });
+    }
+    async start() {
+        await this.redirect.start();
+    }
+    async stop() {
+        await this.redirect.stop();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "6.0.1",
+  "version": "7.1.0",
   "private": false,
   "description": "A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, dynamic routing with authentication options, and automatic ACME certificate management.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -197,7 +197,27 @@ sequenceDiagram
 - **HTTP to HTTPS Redirection** - Automatically redirect HTTP requests to HTTPS
 - **Let's Encrypt Integration** - Automatic certificate management using ACME protocol
 - **IP Filtering** - Control access with IP allow/block lists using glob patterns
-- **NfTables Integration** - Direct manipulation of nftables for advanced low-level port forwarding
+ - **NfTables Integration** - Direct manipulation of nftables for advanced low-level port forwarding
+
+## Configuration Options
+
+### backendProtocol
+
+Type: 'http1' | 'http2' (default: 'http1')
+
+Controls the protocol used when proxying requests to backend services. By default, the proxy uses HTTP/1.x (`http.request`). Setting `backendProtocol: 'http2'` establishes HTTP/2 client sessions (`http2.connect`) to your backends for full end-to-end HTTP/2 support (assuming your backend servers support HTTP/2).
+
+Example:
+```js
+import { NetworkProxy } from '@push.rocks/smartproxy';
+
+const proxy = new NetworkProxy({
+  port: 8443,
+  backendProtocol: 'http2',
+  // other options...
+});
+proxy.start();
+```
 - **Basic Authentication** - Support for basic auth on proxied routes
 - **Connection Management** - Intelligent connection tracking and cleanup with configurable timeouts
 - **Browser Compatibility** - Optimized for modern browsers with fixes for common TLS handshake issues

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '6.0.1',
+  version: '7.1.0',
   description: 'A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, dynamic routing with authentication options, and automatic ACME certificate management.'
 }

package/ts/index.ts

@@ -1,7 +1,7 @@
 export * from './nfttablesproxy/classes.nftablesproxy.js';
 export * from './networkproxy/classes.np.networkproxy.js';
 export * from './port80handler/classes.port80handler.js';
-export * from './classes.sslredirect.js';
+export * from './redirect/classes.redirect.js';
 export * from './smartproxy/classes.smartproxy.js';
 export * from './smartproxy/classes.pp.snihandler.js';
 export * from './smartproxy/classes.pp.interfaces.js';

package/ts/networkproxy/classes.np.networkproxy.ts

@@ -16,8 +16,8 @@ export class NetworkProxy implements IMetricsTracker {
   public options: INetworkProxyOptions;
   public proxyConfigs: IReverseProxyConfig[] = [];
   
-  // Server instances
-  public httpsServer: plugins.https.Server;
+  // Server instances (HTTP/2 with HTTP/1 fallback)
+  public httpsServer: any;
   
   // Core components
   private certificateManager: CertificateManager;
@@ -66,6 +66,8 @@ export class NetworkProxy implements IMetricsTracker {
       connectionPoolSize: optionsArg.connectionPoolSize || 50,
       portProxyIntegration: optionsArg.portProxyIntegration || false,
       useExternalPort80Handler: optionsArg.useExternalPort80Handler || false,
+      // Backend protocol (http1 or http2)
+      backendProtocol: optionsArg.backendProtocol || 'http1',
       // Default ACME options
       acme: {
         enabled: optionsArg.acme?.enabled || false,
@@ -185,33 +187,35 @@ export class NetworkProxy implements IMetricsTracker {
       await this.certificateManager.initializePort80Handler();
     }
     
-    // Create the HTTPS server
-    this.httpsServer = plugins.https.createServer(
+    // Create HTTP/2 server with HTTP/1 fallback
+    this.httpsServer = plugins.http2.createSecureServer(
       {
         key: this.certificateManager.getDefaultCertificates().key,
         cert: this.certificateManager.getDefaultCertificates().cert,
-        SNICallback: (domain, cb) => this.certificateManager.handleSNI(domain, cb)
-      },
-      (req, res) => this.requestHandler.handleRequest(req, res)
+        allowHTTP1: true,
+        ALPNProtocols: ['h2', 'http/1.1']
+      }
     );
 
-    // Configure server timeouts
-    this.httpsServer.keepAliveTimeout = this.options.keepAliveTimeout;
-    this.httpsServer.headersTimeout = this.options.headersTimeout;
-    
-    // Setup connection tracking
+    // Track raw TCP connections for metrics and limits
     this.setupConnectionTracking();
-    
-    // Share HTTPS server with certificate manager
+
+    // Handle incoming HTTP/2 streams
+    this.httpsServer.on('stream', (stream: any, headers: any) => {
+      this.requestHandler.handleHttp2(stream, headers);
+    });
+    // Handle HTTP/1.x fallback requests
+    this.httpsServer.on('request', (req: any, res: any) => {
+      this.requestHandler.handleRequest(req, res);
+    });
+
+    // Share server with certificate manager for dynamic contexts
     this.certificateManager.setHttpsServer(this.httpsServer);
-    
-    // Setup WebSocket support
+    // Setup WebSocket support on HTTP/1 fallback
     this.webSocketHandler.initialize(this.httpsServer);
-    
-    // Start metrics collection
+    // Start metrics logging
     this.setupMetricsCollection();
-    
-    // Setup connection pool cleanup interval
+    // Start periodic connection pool cleanup
     this.connectionPoolCleanupInterval = this.connectionPool.setupPeriodicCleanup();
 
     // Start the server

package/ts/networkproxy/classes.np.requesthandler.ts

@@ -18,6 +18,8 @@ export class RequestHandler {
   private defaultHeaders: { [key: string]: string } = {};
   private logger: ILogger;
   private metricsTracker: IMetricsTracker | null = null;
+  // HTTP/2 client sessions for backend proxying
+  private h2Sessions: Map<string, plugins.http2.ClientHttp2Session> = new Map();
   
   constructor(
     private options: INetworkProxyOptions,
@@ -130,6 +132,70 @@ export class RequestHandler {
     
     // Apply default headers
     this.applyDefaultHeaders(res);
+    // If configured to proxy to backends over HTTP/2, use HTTP/2 client sessions
+    if (this.options.backendProtocol === 'http2') {
+      // Route and validate config
+      const proxyConfig = this.router.routeReq(req);
+      if (!proxyConfig) {
+        this.logger.warn(`No proxy configuration for host: ${req.headers.host}`);
+        res.statusCode = 404;
+        res.end('Not Found: No proxy configuration for this host');
+        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
+        return;
+      }
+      // Determine backend target
+      const destination = this.connectionPool.getNextTarget(
+        proxyConfig.destinationIps,
+        proxyConfig.destinationPorts[0]
+      );
+      // Obtain or create HTTP/2 session
+      const key = `${destination.host}:${destination.port}`;
+      let session = this.h2Sessions.get(key);
+      if (!session || session.closed || (session as any).destroyed) {
+        session = plugins.http2.connect(`http://${destination.host}:${destination.port}`);
+        this.h2Sessions.set(key, session);
+        session.on('error', () => this.h2Sessions.delete(key));
+        session.on('close', () => this.h2Sessions.delete(key));
+      }
+      // Build headers for HTTP/2 request
+      const h2Headers: Record<string, string> = {
+        ':method': req.method || 'GET',
+        ':path': req.url || '/',
+        ':authority': `${destination.host}:${destination.port}`
+      };
+      for (const [k, v] of Object.entries(req.headers)) {
+        if (typeof v === 'string' && !k.startsWith(':')) {
+          h2Headers[k] = v;
+        }
+      }
+      // Open HTTP/2 stream
+      const h2Stream = session.request(h2Headers);
+      // Pipe client request body to backend
+      req.pipe(h2Stream);
+      // Handle backend response
+      h2Stream.on('response', (headers, flags) => {
+        const status = headers[':status'] as number || 502;
+        // Map headers
+        for (const [hk, hv] of Object.entries(headers)) {
+          if (!hk.startsWith(':') && hv) {
+            res.setHeader(hk, hv as string);
+          }
+        }
+        res.statusCode = status;
+        h2Stream.pipe(res);
+      });
+      h2Stream.on('error', (err) => {
+        this.logger.error(`HTTP/2 proxy error: ${err.message}`);
+        if (!res.headersSent) {
+          res.statusCode = 502;
+          res.end(`Bad Gateway: ${err.message}`);
+        } else {
+          res.end();
+        }
+        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
+      });
+      return;
+    }
     
     try {
       // Find target based on hostname
@@ -275,4 +341,119 @@ export class RequestHandler {
       }
     }
   }
+
+  /**
+   * Handle HTTP/2 stream requests by proxying to HTTP/1 backends
+   */
+  public async handleHttp2(stream: any, headers: any): Promise<void> {
+    const startTime = Date.now();
+    const method = headers[':method'] || 'GET';
+    const path = headers[':path'] || '/';
+    // If configured to proxy to backends over HTTP/2, use HTTP/2 client sessions
+    if (this.options.backendProtocol === 'http2') {
+      const authority = headers[':authority'] as string || '';
+      const host = authority.split(':')[0];
+      const fakeReq: any = { headers: { host }, method: headers[':method'], url: headers[':path'], socket: (stream.session as any).socket };
+      const proxyConfig = this.router.routeReq(fakeReq);
+      if (!proxyConfig) {
+        stream.respond({ ':status': 404 });
+        stream.end('Not Found');
+        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
+        return;
+      }
+      const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+      const key = `${destination.host}:${destination.port}`;
+      let session = this.h2Sessions.get(key);
+      if (!session || session.closed || (session as any).destroyed) {
+        session = plugins.http2.connect(`http://${destination.host}:${destination.port}`);
+        this.h2Sessions.set(key, session);
+        session.on('error', () => this.h2Sessions.delete(key));
+        session.on('close', () => this.h2Sessions.delete(key));
+      }
+      // Build headers for backend HTTP/2 request
+      const h2Headers: Record<string, any> = {
+        ':method': headers[':method'],
+        ':path': headers[':path'],
+        ':authority': `${destination.host}:${destination.port}`
+      };
+      for (const [k, v] of Object.entries(headers)) {
+        if (!k.startsWith(':') && typeof v === 'string') {
+          h2Headers[k] = v;
+        }
+      }
+      const h2Stream2 = session.request(h2Headers);
+      stream.pipe(h2Stream2);
+      h2Stream2.on('response', (hdrs: any) => {
+        // Map status and headers to client
+        const resp: Record<string, any> = { ':status': hdrs[':status'] as number };
+        for (const [hk, hv] of Object.entries(hdrs)) {
+          if (!hk.startsWith(':') && hv) resp[hk] = hv;
+        }
+        stream.respond(resp);
+        h2Stream2.pipe(stream);
+      });
+      h2Stream2.on('error', (err) => {
+        stream.respond({ ':status': 502 });
+        stream.end(`Bad Gateway: ${err.message}`);
+        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
+      });
+      return;
+    }
+    try {
+      // Determine host for routing
+      const authority = headers[':authority'] as string || '';
+      const host = authority.split(':')[0];
+      // Fake request object for routing
+      const fakeReq: any = { headers: { host }, method, url: path, socket: (stream.session as any).socket };
+      const proxyConfig = this.router.routeReq(fakeReq as any);
+      if (!proxyConfig) {
+        stream.respond({ ':status': 404 });
+        stream.end('Not Found');
+        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
+        return;
+      }
+      // Select backend target
+      const destination = this.connectionPool.getNextTarget(
+        proxyConfig.destinationIps,
+        proxyConfig.destinationPorts[0]
+      );
+      // Build headers for HTTP/1 proxy
+      const outboundHeaders: Record<string,string> = {};
+      for (const [key, value] of Object.entries(headers)) {
+        if (typeof key === 'string' && typeof value === 'string' && !key.startsWith(':')) {
+          outboundHeaders[key] = value;
+        }
+      }
+      if (outboundHeaders.host && (proxyConfig as any).rewriteHostHeader) {
+        outboundHeaders.host = `${destination.host}:${destination.port}`;
+      }
+      // Create HTTP/1 proxy request
+      const proxyReq = plugins.http.request(
+        { hostname: destination.host, port: destination.port, path, method, headers: outboundHeaders },
+        (proxyRes) => {
+          // Map status and headers back to HTTP/2
+          const responseHeaders: Record<string, number|string|string[]> = {};
+          for (const [k, v] of Object.entries(proxyRes.headers)) {
+            if (v !== undefined) responseHeaders[k] = v;
+          }
+          stream.respond({ ':status': proxyRes.statusCode || 500, ...responseHeaders });
+          proxyRes.pipe(stream);
+          stream.on('close', () => proxyReq.destroy());
+          stream.on('error', () => proxyReq.destroy());
+          if (this.metricsTracker) stream.on('end', () => this.metricsTracker.incrementRequestsServed());
+        }
+      );
+      proxyReq.on('error', (err) => {
+        stream.respond({ ':status': 502 });
+        stream.end(`Bad Gateway: ${err.message}`);
+        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
+      });
+      // Pipe client stream to backend
+      stream.pipe(proxyReq);
+    } catch (err: any) {
+      stream.respond({ ':status': 500 });
+      stream.end('Internal Server Error');
+      if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
+    }
+  }
 }

package/ts/networkproxy/classes.np.types.ts

@@ -20,6 +20,8 @@ export interface INetworkProxyOptions {
   connectionPoolSize?: number; // Maximum connections to maintain in the pool to each backend
   portProxyIntegration?: boolean; // Flag to indicate this proxy is used by PortProxy
   useExternalPort80Handler?: boolean; // Flag to indicate using external Port80Handler
+  // Protocol to use when proxying to backends: HTTP/1.x or HTTP/2
+  backendProtocol?: 'http1' | 'http2';
   
   // ACME certificate management options
   acme?: {

package/ts/plugins.ts

@@ -5,9 +5,10 @@ import * as https from 'https';
 import * as net from 'net';
 import * as tls from 'tls';
 import * as url from 'url';
+import * as http2 from 'http2';
 
 
-export { EventEmitter, http, https, net, tls, url };
+export { EventEmitter, http, https, net, tls, url, http2 };
 
 // tsclass scope
 import * as tsclass from '@tsclass/tsclass';