@push.rocks/smartproxy 19.3.1 → 19.3.3

package/dist_ts/proxies/http-proxy/http2-request-handler.js

@@ -0,0 +1,201 @@
+import * as plugins from '../../plugins.js';
+/**
+ * HTTP/2 Request Handler Helper - handles HTTP/2 streams with specific destinations
+ * This is a helper class for the main RequestHandler
+ */
+export class Http2RequestHandler {
+    /**
+     * Handle HTTP/2 stream with direct HTTP/2 backend
+     */
+    static async handleHttp2WithHttp2Destination(stream, headers, destination, routeContext, sessions, logger, metricsTracker) {
+        const key = `${destination.host}:${destination.port}`;
+        // Get or create a client HTTP/2 session
+        let session = sessions.get(key);
+        if (!session || session.closed || session.destroyed) {
+            try {
+                // Connect to the backend HTTP/2 server
+                session = plugins.http2.connect(`http://${destination.host}:${destination.port}`);
+                sessions.set(key, session);
+                // Handle session errors and cleanup
+                session.on('error', (err) => {
+                    logger.error(`HTTP/2 session error to ${key}: ${err.message}`);
+                    sessions.delete(key);
+                });
+                session.on('close', () => {
+                    logger.debug(`HTTP/2 session closed to ${key}`);
+                    sessions.delete(key);
+                });
+            }
+            catch (err) {
+                logger.error(`Failed to establish HTTP/2 session to ${key}: ${err.message}`);
+                stream.respond({ ':status': 502 });
+                stream.end('Bad Gateway: Failed to establish connection to backend');
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+                return;
+            }
+        }
+        try {
+            // Build headers for backend HTTP/2 request
+            const h2Headers = {
+                ':method': headers[':method'],
+                ':path': headers[':path'],
+                ':authority': `${destination.host}:${destination.port}`
+            };
+            // Copy other headers, excluding pseudo-headers
+            for (const [key, value] of Object.entries(headers)) {
+                if (!key.startsWith(':') && typeof value === 'string') {
+                    h2Headers[key] = value;
+                }
+            }
+            logger.debug(`Proxying HTTP/2 request to ${destination.host}:${destination.port}${headers[':path']}`, { method: headers[':method'] });
+            // Create HTTP/2 request stream to the backend
+            const h2Stream = session.request(h2Headers);
+            // Pipe client stream to backend stream
+            stream.pipe(h2Stream);
+            // Handle responses from the backend
+            h2Stream.on('response', (responseHeaders) => {
+                // Map status and headers to client response
+                const resp = {
+                    ':status': responseHeaders[':status']
+                };
+                // Copy non-pseudo headers
+                for (const [key, value] of Object.entries(responseHeaders)) {
+                    if (!key.startsWith(':') && value !== undefined) {
+                        resp[key] = value;
+                    }
+                }
+                // Send headers to client
+                stream.respond(resp);
+                // Pipe backend response to client
+                h2Stream.pipe(stream);
+                // Track successful requests
+                stream.on('end', () => {
+                    if (metricsTracker)
+                        metricsTracker.incrementRequestsServed();
+                    logger.debug(`HTTP/2 request completed: ${headers[':method']} ${headers[':path']} ${responseHeaders[':status']}`, { method: headers[':method'], status: responseHeaders[':status'] });
+                });
+            });
+            // Handle backend errors
+            h2Stream.on('error', (err) => {
+                logger.error(`HTTP/2 stream error: ${err.message}`);
+                // Only send error response if headers haven't been sent
+                if (!stream.headersSent) {
+                    stream.respond({ ':status': 502 });
+                    stream.end(`Bad Gateway: ${err.message}`);
+                }
+                else {
+                    stream.end();
+                }
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+            // Handle client stream errors
+            stream.on('error', (err) => {
+                logger.debug(`Client HTTP/2 stream error: ${err.message}`);
+                h2Stream.destroy();
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+        }
+        catch (err) {
+            logger.error(`Error handling HTTP/2 request: ${err.message}`);
+            // Only send error response if headers haven't been sent
+            if (!stream.headersSent) {
+                stream.respond({ ':status': 500 });
+                stream.end('Internal Server Error');
+            }
+            else {
+                stream.end();
+            }
+            if (metricsTracker)
+                metricsTracker.incrementFailedRequests();
+        }
+    }
+    /**
+     * Handle HTTP/2 stream with HTTP/1 backend
+     */
+    static async handleHttp2WithHttp1Destination(stream, headers, destination, routeContext, logger, metricsTracker) {
+        try {
+            // Build headers for HTTP/1 proxy request, excluding HTTP/2 pseudo-headers
+            const outboundHeaders = {};
+            for (const [key, value] of Object.entries(headers)) {
+                if (typeof key === 'string' && typeof value === 'string' && !key.startsWith(':')) {
+                    outboundHeaders[key] = value;
+                }
+            }
+            // Always rewrite host header to match target
+            outboundHeaders.host = `${destination.host}:${destination.port}`;
+            logger.debug(`Proxying HTTP/2 request to HTTP/1 backend ${destination.host}:${destination.port}${headers[':path']}`, { method: headers[':method'] });
+            // Create HTTP/1 proxy request
+            const proxyReq = plugins.http.request({
+                hostname: destination.host,
+                port: destination.port,
+                path: headers[':path'],
+                method: headers[':method'],
+                headers: outboundHeaders
+            }, (proxyRes) => {
+                // Map status and headers back to HTTP/2
+                const responseHeaders = {
+                    ':status': proxyRes.statusCode || 500
+                };
+                // Copy headers from HTTP/1 response to HTTP/2 response
+                for (const [key, value] of Object.entries(proxyRes.headers)) {
+                    if (value !== undefined) {
+                        responseHeaders[key] = value;
+                    }
+                }
+                // Send headers to client
+                stream.respond(responseHeaders);
+                // Pipe HTTP/1 response to HTTP/2 stream
+                proxyRes.pipe(stream);
+                // Clean up when client disconnects
+                stream.on('close', () => proxyReq.destroy());
+                stream.on('error', () => proxyReq.destroy());
+                // Track successful requests
+                stream.on('end', () => {
+                    if (metricsTracker)
+                        metricsTracker.incrementRequestsServed();
+                    logger.debug(`HTTP/2 to HTTP/1 request completed: ${headers[':method']} ${headers[':path']} ${proxyRes.statusCode}`, { method: headers[':method'], status: proxyRes.statusCode });
+                });
+            });
+            // Handle proxy request errors
+            proxyReq.on('error', (err) => {
+                logger.error(`HTTP/1 proxy error: ${err.message}`);
+                // Only send error response if headers haven't been sent
+                if (!stream.headersSent) {
+                    stream.respond({ ':status': 502 });
+                    stream.end(`Bad Gateway: ${err.message}`);
+                }
+                else {
+                    stream.end();
+                }
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+            // Pipe client stream to proxy request
+            stream.pipe(proxyReq);
+            // Handle client stream errors
+            stream.on('error', (err) => {
+                logger.debug(`Client HTTP/2 stream error: ${err.message}`);
+                proxyReq.destroy();
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+        }
+        catch (err) {
+            logger.error(`Error handling HTTP/2 to HTTP/1 request: ${err.message}`);
+            // Only send error response if headers haven't been sent
+            if (!stream.headersSent) {
+                stream.respond({ ':status': 500 });
+                stream.end('Internal Server Error');
+            }
+            else {
+                stream.end();
+            }
+            if (metricsTracker)
+                metricsTracker.incrementFailedRequests();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http2-request-handler.js","sourceRoot":"","sources":["../../../ts/proxies/http-proxy/http2-request-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/{network-proxy → http-proxy}/index.d.ts

@@ -1,8 +1,8 @@
 /**
- * NetworkProxy implementation
+ * HttpProxy implementation
  */
 export * from './models/index.js';
-export { NetworkProxy } from './network-proxy.js';
+export { HttpProxy } from './http-proxy.js';
 export { CertificateManager } from './certificate-manager.js';
 export { ConnectionPool } from './connection-pool.js';
 export { RequestHandler } from './request-handler.js';

package/dist_ts/proxies/http-proxy/index.js

@@ -0,0 +1,12 @@
+/**
+ * HttpProxy implementation
+ */
+// Re-export models
+export * from './models/index.js';
+// Export HttpProxy and supporting classes
+export { HttpProxy } from './http-proxy.js';
+export { CertificateManager } from './certificate-manager.js';
+export { ConnectionPool } from './connection-pool.js';
+export { RequestHandler } from './request-handler.js';
+export { WebSocketHandler } from './websocket-handler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL2h0dHAtcHJveHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxtQkFBbUI7QUFDbkIsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQywwQ0FBMEM7QUFDMUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzVDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzlELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFdEQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0JBQXdCLENBQUMifQ==

package/dist_ts/proxies/http-proxy/models/http-types.d.ts

@@ -0,0 +1,119 @@
+import * as plugins from '../../../plugins.js';
+/**
+ * HTTP-specific event types
+ */
+export declare enum HttpEvents {
+    REQUEST_RECEIVED = "request-received",
+    REQUEST_FORWARDED = "request-forwarded",
+    REQUEST_HANDLED = "request-handled",
+    REQUEST_ERROR = "request-error"
+}
+/**
+ * HTTP status codes as an enum for better type safety
+ */
+export declare enum HttpStatus {
+    OK = 200,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    REQUEST_TIMEOUT = 408,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504
+}
+/**
+ * Base error class for HTTP-related errors
+ */
+export declare class HttpError extends Error {
+    readonly statusCode: HttpStatus;
+    constructor(message: string, statusCode?: HttpStatus);
+}
+/**
+ * Error related to certificate operations
+ */
+export declare class CertificateError extends HttpError {
+    readonly domain: string;
+    readonly isRenewal: boolean;
+    constructor(message: string, domain: string, isRenewal?: boolean);
+}
+/**
+ * Error related to server operations
+ */
+export declare class ServerError extends HttpError {
+    readonly code?: string;
+    constructor(message: string, code?: string, statusCode?: HttpStatus);
+}
+/**
+ * Error for bad requests
+ */
+export declare class BadRequestError extends HttpError {
+    constructor(message: string);
+}
+/**
+ * Error for not found resources
+ */
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string);
+}
+/**
+ * Redirect configuration for HTTP requests
+ */
+export interface IRedirectConfig {
+    source: string;
+    destination: string;
+    type: HttpStatus;
+    preserveQuery?: boolean;
+}
+/**
+ * HTTP router configuration
+ */
+export interface IRouterConfig {
+    routes: Array<{
+        path: string;
+        method?: string;
+        handler: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void | Promise<void>;
+    }>;
+    notFoundHandler?: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+    errorHandler?: (error: Error, req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+}
+/**
+ * HTTP request method types
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+/**
+ * Helper function to get HTTP status text
+ */
+export declare function getStatusText(status: HttpStatus): string;
+export interface IDomainOptions {
+    domainName: string;
+    sslRedirect: boolean;
+    acmeMaintenance: boolean;
+    forward?: {
+        ip: string;
+        port: number;
+    };
+    acmeForward?: {
+        ip: string;
+        port: number;
+    };
+}
+export interface IDomainCertificate {
+    options: IDomainOptions;
+    certObtained: boolean;
+    obtainingInProgress: boolean;
+    certificate?: string;
+    privateKey?: string;
+    expiryDate?: Date;
+    lastRenewalAttempt?: Date;
+}
+export { HttpError as Port80HandlerError };
+export { CertificateError as CertError };

package/dist_ts/proxies/http-proxy/models/http-types.js

@@ -0,0 +1,112 @@
+import * as plugins from '../../../plugins.js';
+/**
+ * HTTP-specific event types
+ */
+export var HttpEvents;
+(function (HttpEvents) {
+    HttpEvents["REQUEST_RECEIVED"] = "request-received";
+    HttpEvents["REQUEST_FORWARDED"] = "request-forwarded";
+    HttpEvents["REQUEST_HANDLED"] = "request-handled";
+    HttpEvents["REQUEST_ERROR"] = "request-error";
+})(HttpEvents || (HttpEvents = {}));
+/**
+ * HTTP status codes as an enum for better type safety
+ */
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+})(HttpStatus || (HttpStatus = {}));
+/**
+ * Base error class for HTTP-related errors
+ */
+export class HttpError extends Error {
+    constructor(message, statusCode = HttpStatus.INTERNAL_SERVER_ERROR) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'HttpError';
+    }
+}
+/**
+ * Error related to certificate operations
+ */
+export class CertificateError extends HttpError {
+    constructor(message, domain, isRenewal = false) {
+        super(`${message} for domain ${domain}${isRenewal ? ' (renewal)' : ''}`, HttpStatus.INTERNAL_SERVER_ERROR);
+        this.domain = domain;
+        this.isRenewal = isRenewal;
+        this.name = 'CertificateError';
+    }
+}
+/**
+ * Error related to server operations
+ */
+export class ServerError extends HttpError {
+    constructor(message, code, statusCode = HttpStatus.INTERNAL_SERVER_ERROR) {
+        super(message, statusCode);
+        this.code = code;
+        this.name = 'ServerError';
+    }
+}
+/**
+ * Error for bad requests
+ */
+export class BadRequestError extends HttpError {
+    constructor(message) {
+        super(message, HttpStatus.BAD_REQUEST);
+        this.name = 'BadRequestError';
+    }
+}
+/**
+ * Error for not found resources
+ */
+export class NotFoundError extends HttpError {
+    constructor(message = 'Resource not found') {
+        super(message, HttpStatus.NOT_FOUND);
+        this.name = 'NotFoundError';
+    }
+}
+/**
+ * Helper function to get HTTP status text
+ */
+export function getStatusText(status) {
+    const statusTexts = {
+        [HttpStatus.OK]: 'OK',
+        [HttpStatus.MOVED_PERMANENTLY]: 'Moved Permanently',
+        [HttpStatus.FOUND]: 'Found',
+        [HttpStatus.TEMPORARY_REDIRECT]: 'Temporary Redirect',
+        [HttpStatus.PERMANENT_REDIRECT]: 'Permanent Redirect',
+        [HttpStatus.BAD_REQUEST]: 'Bad Request',
+        [HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+        [HttpStatus.FORBIDDEN]: 'Forbidden',
+        [HttpStatus.NOT_FOUND]: 'Not Found',
+        [HttpStatus.METHOD_NOT_ALLOWED]: 'Method Not Allowed',
+        [HttpStatus.REQUEST_TIMEOUT]: 'Request Timeout',
+        [HttpStatus.TOO_MANY_REQUESTS]: 'Too Many Requests',
+        [HttpStatus.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+        [HttpStatus.NOT_IMPLEMENTED]: 'Not Implemented',
+        [HttpStatus.BAD_GATEWAY]: 'Bad Gateway',
+        [HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable',
+        [HttpStatus.GATEWAY_TIMEOUT]: 'Gateway Timeout',
+    };
+    return statusTexts[status] || 'Unknown';
+}
+// Backward compatibility exports
+export { HttpError as Port80HandlerError };
+export { CertificateError as CertError };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvaHR0cC1wcm94eS9tb2RlbHMvaHR0cC10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBRS9DOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksVUFLWDtBQUxELFdBQVksVUFBVTtJQUNwQixtREFBcUMsQ0FBQTtJQUNyQyxxREFBdUMsQ0FBQTtJQUN2QyxpREFBbUMsQ0FBQTtJQUNuQyw2Q0FBK0IsQ0FBQTtBQUNqQyxDQUFDLEVBTFcsVUFBVSxLQUFWLFVBQVUsUUFLckI7QUFFRDs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLFVBa0JYO0FBbEJELFdBQVksVUFBVTtJQUNwQix5Q0FBUSxDQUFBO0lBQ1IsdUVBQXVCLENBQUE7SUFDdkIsK0NBQVcsQ0FBQTtJQUNYLHlFQUF3QixDQUFBO0lBQ3hCLHlFQUF3QixDQUFBO0lBQ3hCLDJEQUFpQixDQUFBO0lBQ2pCLDZEQUFrQixDQUFBO0lBQ2xCLHVEQUFlLENBQUE7SUFDZix1REFBZSxDQUFBO0lBQ2YseUVBQXdCLENBQUE7SUFDeEIsbUVBQXFCLENBQUE7SUFDckIsdUVBQXVCLENBQUE7SUFDdkIsK0VBQTJCLENBQUE7SUFDM0IsbUVBQXFCLENBQUE7SUFDckIsMkRBQWlCLENBQUE7SUFDakIsMkVBQXlCLENBQUE7SUFDekIsbUVBQXFCLENBQUE7QUFDdkIsQ0FBQyxFQWxCVyxVQUFVLEtBQVYsVUFBVSxRQWtCckI7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxTQUFVLFNBQVEsS0FBSztJQUNsQyxZQUFZLE9BQWUsRUFBa0IsYUFBeUIsVUFBVSxDQUFDLHFCQUFxQjtRQUNwRyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFENEIsZUFBVSxHQUFWLFVBQVUsQ0FBK0M7UUFFcEcsSUFBSSxDQUFDLElBQUksR0FBRyxXQUFXLENBQUM7SUFDMUIsQ0FBQztDQUNGO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sZ0JBQWlCLFNBQVEsU0FBUztJQUM3QyxZQUNFLE9BQWUsRUFDQyxNQUFjLEVBQ2QsWUFBcUIsS0FBSztRQUUxQyxLQUFLLENBQUMsR0FBRyxPQUFPLGVBQWUsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxVQUFVLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUgzRixXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQ2QsY0FBUyxHQUFULFNBQVMsQ0FBaUI7UUFHMUMsSUFBSSxDQUFDLElBQUksR0FBRyxrQkFBa0IsQ0FBQztJQUNqQyxDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxXQUFZLFNBQVEsU0FBUztJQUN4QyxZQUFZLE9BQWUsRUFBa0IsSUFBYSxFQUFFLGFBQXlCLFVBQVUsQ0FBQyxxQkFBcUI7UUFDbkgsS0FBSyxDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQztRQURnQixTQUFJLEdBQUosSUFBSSxDQUFTO1FBRXhELElBQUksQ0FBQyxJQUFJLEdBQUcsYUFBYSxDQUFDO0lBQzVCLENBQUM7Q0FDRjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGVBQWdCLFNBQVEsU0FBUztJQUM1QyxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDdkMsSUFBSSxDQUFDLElBQUksR0FBRyxpQkFBaUIsQ0FBQztJQUNoQyxDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxhQUFjLFNBQVEsU0FBUztJQUMxQyxZQUFZLFVBQWtCLG9CQUFvQjtRQUNoRCxLQUFLLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNyQyxJQUFJLENBQUMsSUFBSSxHQUFHLGVBQWUsQ0FBQztJQUM5QixDQUFDO0NBQ0Y7QUE4QkQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUFDLE1BQWtCO0lBQzlDLE1BQU0sV0FBVyxHQUErQjtRQUM5QyxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUMsRUFBRSxJQUFJO1FBQ3JCLENBQUMsVUFBVSxDQUFDLGlCQUFpQixDQUFDLEVBQUUsbUJBQW1CO1FBQ25ELENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxFQUFFLE9BQU87UUFDM0IsQ0FBQyxVQUFVLENBQUMsa0JBQWtCLENBQUMsRUFBRSxvQkFBb0I7UUFDckQsQ0FBQyxVQUFVLENBQUMsa0JBQWtCLENBQUMsRUFBRSxvQkFBb0I7UUFDckQsQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLEVBQUUsYUFBYTtRQUN2QyxDQUFDLFVBQVUsQ0FBQyxZQUFZLENBQUMsRUFBRSxjQUFjO1FBQ3pDLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxFQUFFLFdBQVc7UUFDbkMsQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLEVBQUUsV0FBVztRQUNuQyxDQUFDLFVBQVUsQ0FBQyxrQkFBa0IsQ0FBQyxFQUFFLG9CQUFvQjtRQUNyRCxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsRUFBRSxpQkFBaUI7UUFDL0MsQ0FBQyxVQUFVLENBQUMsaUJBQWlCLENBQUMsRUFBRSxtQkFBbUI7UUFDbkQsQ0FBQyxVQUFVLENBQUMscUJBQXFCLENBQUMsRUFBRSx1QkFBdUI7UUFDM0QsQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLEVBQUUsaUJBQWlCO1FBQy9DLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxFQUFFLGFBQWE7UUFDdkMsQ0FBQyxVQUFVLENBQUMsbUJBQW1CLENBQUMsRUFBRSxxQkFBcUI7UUFDdkQsQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLEVBQUUsaUJBQWlCO0tBQ2hELENBQUM7SUFDRixPQUFPLFdBQVcsQ0FBQyxNQUFNLENBQUMsSUFBSSxTQUFTLENBQUM7QUFDMUMsQ0FBQztBQXFCRCxpQ0FBaUM7QUFDakMsT0FBTyxFQUFFLFNBQVMsSUFBSSxrQkFBa0IsRUFBRSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxnQkFBZ0IsSUFBSSxTQUFTLEVBQUUsQ0FBQyJ9

package/dist_ts/proxies/http-proxy/models/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * HttpProxy models
+ */
+export * from './types.js';
+export * from './http-types.js';

package/dist_ts/proxies/http-proxy/models/index.js

@@ -0,0 +1,6 @@
+/**
+ * HttpProxy models
+ */
+export * from './types.js';
+export * from './http-types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL2h0dHAtcHJveHkvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxpQkFBaUIsQ0FBQyJ9

package/dist_ts/proxies/{network-proxy → http-proxy}/models/types.d.ts

@@ -14,9 +14,9 @@ export interface IAcmeOptions {
 import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
 import type { IRouteContext } from '../../../core/models/route-context.js';
 /**
- * Configuration options for NetworkProxy
+ * Configuration options for HttpProxy
  */
-export interface INetworkProxyOptions {
+export interface IHttpProxyOptions {
     port: number;
     maxConnections?: number;
     keepAliveTimeout?: number;