@push.rocks/smartproxy 26.2.4 → 27.0.0

package/dist_ts/proxies/smart-proxy/utils/socket-handlers.js

@@ -0,0 +1,268 @@
+/**
+ * Socket Handler Functions
+ *
+ * This module provides pre-built socket handlers for common use cases
+ * like echoing, proxying, HTTP responses, and redirects.
+ */
+import * as plugins from '../../../plugins.js';
+import { createSocketTracker } from '../../../core/utils/socket-tracker.js';
+/**
+ * Minimal HTTP request parser for socket handlers.
+ * Parses method, path, and optionally headers from a raw buffer.
+ */
+function parseHttpRequest(data, extractHeaders = false) {
+    const str = data.toString('utf8');
+    const headerEnd = str.indexOf('\r\n\r\n');
+    const isComplete = headerEnd !== -1;
+    const headerSection = isComplete ? str.slice(0, headerEnd) : str;
+    const lines = headerSection.split('\r\n');
+    const requestLine = lines[0];
+    if (!requestLine)
+        return null;
+    const parts = requestLine.split(' ');
+    if (parts.length < 2)
+        return null;
+    const method = parts[0];
+    const path = parts[1];
+    // Quick check: valid HTTP method
+    const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS', 'CONNECT', 'TRACE'];
+    if (!validMethods.includes(method))
+        return null;
+    const headers = {};
+    if (extractHeaders) {
+        for (let i = 1; i < lines.length; i++) {
+            const colonIdx = lines[i].indexOf(':');
+            if (colonIdx > 0) {
+                const name = lines[i].slice(0, colonIdx).trim().toLowerCase();
+                const value = lines[i].slice(colonIdx + 1).trim();
+                headers[name] = value;
+            }
+        }
+    }
+    const body = isComplete ? str.slice(headerEnd + 4) : undefined;
+    return { method, path, headers, isComplete, body };
+}
+/**
+ * Pre-built socket handlers for common use cases
+ */
+export const SocketHandlers = {
+    /**
+     * Simple echo server handler
+     */
+    echo: (socket, context) => {
+        socket.write('ECHO SERVER READY\n');
+        socket.on('data', data => socket.write(data));
+    },
+    /**
+     * TCP proxy handler
+     */
+    proxy: (targetHost, targetPort) => (socket, context) => {
+        const target = plugins.net.connect(targetPort, targetHost);
+        socket.pipe(target);
+        target.pipe(socket);
+        socket.on('close', () => target.destroy());
+        target.on('close', () => socket.destroy());
+        target.on('error', (err) => {
+            console.error('Proxy target error:', err);
+            socket.destroy();
+        });
+    },
+    /**
+     * Line-based protocol handler
+     */
+    lineProtocol: (handler) => (socket, context) => {
+        let buffer = '';
+        socket.on('data', (data) => {
+            buffer += data.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            lines.forEach(line => {
+                if (line.trim()) {
+                    handler(line.trim(), socket);
+                }
+            });
+        });
+    },
+    /**
+     * Simple HTTP response handler (for testing)
+     */
+    httpResponse: (statusCode, body) => (socket, context) => {
+        const response = [
+            `HTTP/1.1 ${statusCode} ${statusCode === 200 ? 'OK' : 'Error'}`,
+            'Content-Type: text/plain',
+            `Content-Length: ${body.length}`,
+            'Connection: close',
+            '',
+            body
+        ].join('\r\n');
+        socket.write(response);
+        socket.end();
+    },
+    /**
+     * Block connection immediately
+     */
+    block: (message) => (socket, context) => {
+        const finalMessage = message || `Connection blocked from ${context.clientIp}`;
+        if (finalMessage) {
+            socket.write(finalMessage);
+        }
+        socket.end();
+    },
+    /**
+     * HTTP block response
+     */
+    httpBlock: (statusCode = 403, message) => (socket, context) => {
+        const defaultMessage = `Access forbidden for ${context.domain || context.clientIp}`;
+        const finalMessage = message || defaultMessage;
+        const response = [
+            `HTTP/1.1 ${statusCode} ${finalMessage}`,
+            'Content-Type: text/plain',
+            `Content-Length: ${finalMessage.length}`,
+            'Connection: close',
+            '',
+            finalMessage
+        ].join('\r\n');
+        socket.write(response);
+        socket.end();
+    },
+    /**
+     * HTTP redirect handler
+     */
+    httpRedirect: (locationTemplate, statusCode = 301) => (socket, context) => {
+        const tracker = createSocketTracker(socket);
+        const handleData = (data) => {
+            const parsed = parseHttpRequest(data);
+            if (parsed) {
+                const path = parsed.path || '/';
+                const domain = context.domain || 'localhost';
+                const port = context.port;
+                const finalLocation = locationTemplate
+                    .replace('{domain}', domain)
+                    .replace('{port}', String(port))
+                    .replace('{path}', path)
+                    .replace('{clientIp}', context.clientIp);
+                const message = `Redirecting to ${finalLocation}`;
+                const response = [
+                    `HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
+                    `Location: ${finalLocation}`,
+                    'Content-Type: text/plain',
+                    `Content-Length: ${message.length}`,
+                    'Connection: close',
+                    '',
+                    message
+                ].join('\r\n');
+                socket.write(response);
+            }
+            else {
+                socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+            }
+            socket.end();
+            tracker.cleanup();
+        };
+        socket.once('data', handleData);
+        tracker.addListener('error', (err) => {
+            tracker.safeDestroy(err);
+        });
+        tracker.addListener('close', () => {
+            tracker.cleanup();
+        });
+    },
+    /**
+     * HTTP server handler for ACME challenges and other HTTP needs
+     */
+    httpServer: (handler) => (socket, context) => {
+        const tracker = createSocketTracker(socket);
+        let requestParsed = false;
+        let responseTimer = null;
+        const processData = (data) => {
+            if (requestParsed)
+                return;
+            const parsed = parseHttpRequest(data, true);
+            if (!parsed || !parsed.isComplete) {
+                return; // Not a complete HTTP request yet
+            }
+            requestParsed = true;
+            socket.removeListener('data', processData);
+            const req = {
+                method: parsed.method,
+                url: parsed.path,
+                headers: parsed.headers,
+                body: parsed.body || ''
+            };
+            let statusCode = 200;
+            const responseHeaders = {};
+            let ended = false;
+            const res = {
+                status: (code) => {
+                    statusCode = code;
+                },
+                header: (name, value) => {
+                    responseHeaders[name] = value;
+                },
+                send: (data) => {
+                    if (ended)
+                        return;
+                    ended = true;
+                    if (responseTimer) {
+                        clearTimeout(responseTimer);
+                        responseTimer = null;
+                    }
+                    if (!responseHeaders['content-type']) {
+                        responseHeaders['content-type'] = 'text/plain';
+                    }
+                    responseHeaders['content-length'] = String(data.length);
+                    responseHeaders['connection'] = 'close';
+                    const statusText = statusCode === 200 ? 'OK' :
+                        statusCode === 404 ? 'Not Found' :
+                            statusCode === 500 ? 'Internal Server Error' : 'Response';
+                    let response = `HTTP/1.1 ${statusCode} ${statusText}\r\n`;
+                    for (const [name, value] of Object.entries(responseHeaders)) {
+                        response += `${name}: ${value}\r\n`;
+                    }
+                    response += '\r\n';
+                    response += data;
+                    socket.write(response);
+                    socket.end();
+                },
+                end: () => {
+                    if (ended)
+                        return;
+                    ended = true;
+                    socket.write('HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n');
+                    socket.end();
+                }
+            };
+            try {
+                handler(req, res);
+                responseTimer = setTimeout(() => {
+                    if (!ended) {
+                        res.send('');
+                    }
+                    responseTimer = null;
+                }, 1000);
+                tracker.addTimer(responseTimer);
+            }
+            catch (error) {
+                if (!ended) {
+                    res.status(500);
+                    res.send('Internal Server Error');
+                }
+                tracker.safeDestroy(error instanceof Error ? error : new Error('Handler error'));
+            }
+        };
+        tracker.addListener('data', processData);
+        tracker.addListener('error', (err) => {
+            if (!requestParsed) {
+                tracker.safeDestroy(err);
+            }
+        });
+        tracker.addListener('close', () => {
+            if (responseTimer) {
+                clearTimeout(responseTimer);
+                responseTimer = null;
+            }
+            tracker.cleanup();
+        });
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"socket-handlers.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/socket-handlers.ts"],"names":[],"mappings":"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"}

package/dist_ts/routing/models/http-types.js

@@ -38,6 +38,7 @@ export const HttpStatus = {
  * Base error class for HTTP-related errors
  */
 export class HttpError extends Error {
+    statusCode;
     constructor(message, statusCode = HttpStatus.INTERNAL_SERVER_ERROR) {
         super(message);
         this.statusCode = statusCode;
@@ -48,6 +49,8 @@ export class HttpError extends Error {
  * Error related to certificate operations
  */
 export class CertificateError extends HttpError {
+    domain;
+    isRenewal;
     constructor(message, domain, isRenewal = false) {
         super(`${message} for domain ${domain}${isRenewal ? ' (renewal)' : ''}`, HttpStatus.INTERNAL_SERVER_ERROR);
         this.domain = domain;
@@ -59,6 +62,7 @@ export class CertificateError extends HttpError {
  * Error related to server operations
  */
 export class ServerError extends HttpError {
+    code;
     constructor(message, code, statusCode = HttpStatus.INTERNAL_SERVER_ERROR) {
         super(message, statusCode);
         this.code = code;
@@ -92,4 +96,4 @@ export function getStatusText(status) {
 // Backward compatibility exports
 export { HttpError as Port80HandlerError };
 export { CertificateError as CertError };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "26.2.4",
+  "version": "27.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",
@@ -28,6 +28,7 @@
   "dependencies": {
     "@push.rocks/smartcrypto": "^2.0.4",
     "@push.rocks/smartlog": "^3.2.1",
+    "@push.rocks/smartnftables": "^1.0.1",
     "@push.rocks/smartrust": "^1.3.2",
     "@tsclass/tsclass": "^9.5.0",
     "minimatch": "^10.2.4"

package/readme.hints.md

@@ -462,35 +462,57 @@ For TLS termination modes (`terminate` and `terminate-and-reencrypt`), SmartProx
 
 **HTTP to HTTPS Redirect**:
 ```typescript
-import { createHttpToHttpsRedirect } from '@push.rocks/smartproxy';
+import { SocketHandlers } from '@push.rocks/smartproxy';
 
-const redirectRoute = createHttpToHttpsRedirect(['example.com', 'www.example.com']);
+const redirectRoute = {
+  name: 'http-to-https',
+  match: { ports: 80, domains: ['example.com', 'www.example.com'] },
+  action: {
+    type: 'socket-handler' as const,
+    socketHandler: SocketHandlers.httpRedirect('https://{domain}:443{path}', 301)
+  }
+};
 ```
 
 **Complete HTTPS Server (with redirect)**:
 ```typescript
-import { createCompleteHttpsServer } from '@push.rocks/smartproxy';
-
-const routes = createCompleteHttpsServer(
-  'example.com',
-  { host: 'localhost', port: 8080 },
-  { certificate: 'auto' }
-);
+const routes = [
+  {
+    name: 'https-server',
+    match: { ports: 443, domains: 'example.com' },
+    action: {
+      type: 'forward' as const,
+      targets: [{ host: 'localhost', port: 8080 }],
+      tls: { mode: 'terminate' as const, certificate: 'auto' as const }
+    }
+  },
+  {
+    name: 'http-redirect',
+    match: { ports: 80, domains: 'example.com' },
+    action: {
+      type: 'socket-handler' as const,
+      socketHandler: SocketHandlers.httpRedirect('https://{domain}:443{path}', 301)
+    }
+  }
+];
 ```
 
 **Load Balancer with Health Checks**:
 ```typescript
-import { createLoadBalancerRoute } from '@push.rocks/smartproxy';
-
-const lbRoute = createLoadBalancerRoute(
-  'api.example.com',
-  [
-    { host: 'backend1', port: 8080 },
-    { host: 'backend2', port: 8080 },
-    { host: 'backend3', port: 8080 }
-  ],
-  { tls: { mode: 'terminate', certificate: 'auto' } }
-);
+const lbRoute = {
+  name: 'load-balancer',
+  match: { ports: 443, domains: 'api.example.com' },
+  action: {
+    type: 'forward' as const,
+    targets: [
+      { host: 'backend1', port: 8080 },
+      { host: 'backend2', port: 8080 },
+      { host: 'backend3', port: 8080 }
+    ],
+    tls: { mode: 'terminate' as const, certificate: 'auto' as const },
+    loadBalancing: { algorithm: 'round-robin' as const }
+  }
+};
 ```
 
 ### Smart SNI Requirement (v22.3+)