@push.rocks/smartproxy 15.0.2 → 16.0.3

package/dist_ts/core/utils/event-system.d.ts

@@ -0,0 +1,200 @@
+import type { ICertificateData, ICertificateFailure, ICertificateExpiring } from '../models/common-types.js';
+import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
+/**
+ * Standardized event names used throughout the system
+ */
+export declare enum ProxyEvents {
+    CERTIFICATE_ISSUED = "certificate:issued",
+    CERTIFICATE_RENEWED = "certificate:renewed",
+    CERTIFICATE_FAILED = "certificate:failed",
+    CERTIFICATE_EXPIRING = "certificate:expiring",
+    COMPONENT_STARTED = "component:started",
+    COMPONENT_STOPPED = "component:stopped",
+    CONNECTION_ESTABLISHED = "connection:established",
+    CONNECTION_CLOSED = "connection:closed",
+    CONNECTION_ERROR = "connection:error",
+    REQUEST_RECEIVED = "request:received",
+    REQUEST_COMPLETED = "request:completed",
+    REQUEST_ERROR = "request:error",
+    ROUTE_MATCHED = "route:matched",
+    ROUTE_UPDATED = "route:updated",
+    ROUTE_ERROR = "route:error",
+    SECURITY_BLOCKED = "security:blocked",
+    SECURITY_BREACH_ATTEMPT = "security:breach-attempt",
+    TLS_HANDSHAKE_STARTED = "tls:handshake-started",
+    TLS_HANDSHAKE_COMPLETED = "tls:handshake-completed",
+    TLS_HANDSHAKE_FAILED = "tls:handshake-failed"
+}
+/**
+ * Component types for event metadata
+ */
+export declare enum ComponentType {
+    SMART_PROXY = "smart-proxy",
+    NETWORK_PROXY = "network-proxy",
+    NFTABLES_PROXY = "nftables-proxy",
+    PORT80_HANDLER = "port80-handler",
+    CERTIFICATE_MANAGER = "certificate-manager",
+    ROUTE_MANAGER = "route-manager",
+    CONNECTION_MANAGER = "connection-manager",
+    TLS_MANAGER = "tls-manager",
+    SECURITY_MANAGER = "security-manager"
+}
+/**
+ * Base event data interface
+ */
+export interface IEventData {
+    timestamp: number;
+    componentType: ComponentType;
+    componentId?: string;
+}
+/**
+ * Certificate event data
+ */
+export interface ICertificateEventData extends IEventData, ICertificateData {
+    isRenewal?: boolean;
+    source?: string;
+}
+/**
+ * Certificate failure event data
+ */
+export interface ICertificateFailureEventData extends IEventData, ICertificateFailure {
+}
+/**
+ * Certificate expiring event data
+ */
+export interface ICertificateExpiringEventData extends IEventData, ICertificateExpiring {
+}
+/**
+ * Component lifecycle event data
+ */
+export interface IComponentEventData extends IEventData {
+    name: string;
+    version?: string;
+}
+/**
+ * Connection event data
+ */
+export interface IConnectionEventData extends IEventData {
+    connectionId: string;
+    clientIp: string;
+    serverIp?: string;
+    port: number;
+    isTls?: boolean;
+    domain?: string;
+}
+/**
+ * Request event data
+ */
+export interface IRequestEventData extends IEventData {
+    connectionId: string;
+    requestId: string;
+    method?: string;
+    path?: string;
+    statusCode?: number;
+    duration?: number;
+    routeId?: string;
+    routeName?: string;
+}
+/**
+ * Route event data
+ */
+export interface IRouteEventData extends IEventData {
+    route: IRouteConfig;
+    context?: any;
+}
+/**
+ * Security event data
+ */
+export interface ISecurityEventData extends IEventData {
+    clientIp: string;
+    reason: string;
+    routeId?: string;
+    routeName?: string;
+}
+/**
+ * TLS event data
+ */
+export interface ITlsEventData extends IEventData {
+    connectionId: string;
+    domain?: string;
+    clientIp: string;
+    tlsVersion?: string;
+    cipherSuite?: string;
+    sniHostname?: string;
+}
+/**
+ * Logger interface for event system
+ */
+export interface IEventLogger {
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    debug?: (message: string, ...args: any[]) => void;
+}
+/**
+ * Event handler type
+ */
+export type EventHandler<T> = (data: T) => void;
+/**
+ * Helper class to standardize event emission and handling
+ * across all system components
+ */
+export declare class EventSystem {
+    private emitter;
+    private componentType;
+    private componentId;
+    private logger?;
+    constructor(componentType: ComponentType, componentId?: string, logger?: IEventLogger);
+    /**
+     * Emit a certificate issued event
+     */
+    emitCertificateIssued(data: Omit<ICertificateEventData, 'timestamp' | 'componentType' | 'componentId'>): void;
+    /**
+     * Emit a certificate renewed event
+     */
+    emitCertificateRenewed(data: Omit<ICertificateEventData, 'timestamp' | 'componentType' | 'componentId'>): void;
+    /**
+     * Emit a certificate failed event
+     */
+    emitCertificateFailed(data: Omit<ICertificateFailureEventData, 'timestamp' | 'componentType' | 'componentId'>): void;
+    /**
+     * Emit a certificate expiring event
+     */
+    emitCertificateExpiring(data: Omit<ICertificateExpiringEventData, 'timestamp' | 'componentType' | 'componentId'>): void;
+    /**
+     * Emit a component started event
+     */
+    emitComponentStarted(name: string, version?: string): void;
+    /**
+     * Emit a component stopped event
+     */
+    emitComponentStopped(name: string): void;
+    /**
+     * Emit a connection established event
+     */
+    emitConnectionEstablished(data: Omit<IConnectionEventData, 'timestamp' | 'componentType' | 'componentId'>): void;
+    /**
+     * Emit a connection closed event
+     */
+    emitConnectionClosed(data: Omit<IConnectionEventData, 'timestamp' | 'componentType' | 'componentId'>): void;
+    /**
+     * Emit a route matched event
+     */
+    emitRouteMatched(data: Omit<IRouteEventData, 'timestamp' | 'componentType' | 'componentId'>): void;
+    /**
+     * Subscribe to an event
+     */
+    on<T>(event: ProxyEvents, handler: EventHandler<T>): void;
+    /**
+     * Subscribe to an event once
+     */
+    once<T>(event: ProxyEvents, handler: EventHandler<T>): void;
+    /**
+     * Unsubscribe from an event
+     */
+    off<T>(event: ProxyEvents, handler: EventHandler<T>): void;
+    /**
+     * Map Port80Handler events to standard proxy events
+     */
+    subscribePort80HandlerEvents(handler: any): void;
+}

package/dist_ts/core/utils/event-system.js

@@ -0,0 +1,224 @@
+import * as plugins from '../../plugins.js';
+import { Port80HandlerEvents } from '../models/common-types.js';
+/**
+ * Standardized event names used throughout the system
+ */
+export var ProxyEvents;
+(function (ProxyEvents) {
+    // Certificate events
+    ProxyEvents["CERTIFICATE_ISSUED"] = "certificate:issued";
+    ProxyEvents["CERTIFICATE_RENEWED"] = "certificate:renewed";
+    ProxyEvents["CERTIFICATE_FAILED"] = "certificate:failed";
+    ProxyEvents["CERTIFICATE_EXPIRING"] = "certificate:expiring";
+    // Component lifecycle events
+    ProxyEvents["COMPONENT_STARTED"] = "component:started";
+    ProxyEvents["COMPONENT_STOPPED"] = "component:stopped";
+    // Connection events
+    ProxyEvents["CONNECTION_ESTABLISHED"] = "connection:established";
+    ProxyEvents["CONNECTION_CLOSED"] = "connection:closed";
+    ProxyEvents["CONNECTION_ERROR"] = "connection:error";
+    // Request events
+    ProxyEvents["REQUEST_RECEIVED"] = "request:received";
+    ProxyEvents["REQUEST_COMPLETED"] = "request:completed";
+    ProxyEvents["REQUEST_ERROR"] = "request:error";
+    // Route events
+    ProxyEvents["ROUTE_MATCHED"] = "route:matched";
+    ProxyEvents["ROUTE_UPDATED"] = "route:updated";
+    ProxyEvents["ROUTE_ERROR"] = "route:error";
+    // Security events
+    ProxyEvents["SECURITY_BLOCKED"] = "security:blocked";
+    ProxyEvents["SECURITY_BREACH_ATTEMPT"] = "security:breach-attempt";
+    // TLS events
+    ProxyEvents["TLS_HANDSHAKE_STARTED"] = "tls:handshake-started";
+    ProxyEvents["TLS_HANDSHAKE_COMPLETED"] = "tls:handshake-completed";
+    ProxyEvents["TLS_HANDSHAKE_FAILED"] = "tls:handshake-failed";
+})(ProxyEvents || (ProxyEvents = {}));
+/**
+ * Component types for event metadata
+ */
+export var ComponentType;
+(function (ComponentType) {
+    ComponentType["SMART_PROXY"] = "smart-proxy";
+    ComponentType["NETWORK_PROXY"] = "network-proxy";
+    ComponentType["NFTABLES_PROXY"] = "nftables-proxy";
+    ComponentType["PORT80_HANDLER"] = "port80-handler";
+    ComponentType["CERTIFICATE_MANAGER"] = "certificate-manager";
+    ComponentType["ROUTE_MANAGER"] = "route-manager";
+    ComponentType["CONNECTION_MANAGER"] = "connection-manager";
+    ComponentType["TLS_MANAGER"] = "tls-manager";
+    ComponentType["SECURITY_MANAGER"] = "security-manager";
+})(ComponentType || (ComponentType = {}));
+/**
+ * Helper class to standardize event emission and handling
+ * across all system components
+ */
+export class EventSystem {
+    constructor(componentType, componentId = '', logger) {
+        this.emitter = new plugins.EventEmitter();
+        this.componentType = componentType;
+        this.componentId = componentId;
+        this.logger = logger;
+    }
+    /**
+     * Emit a certificate issued event
+     */
+    emitCertificateIssued(data) {
+        const eventData = {
+            ...data,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.info?.(`Certificate issued for ${data.domain}`);
+        this.emitter.emit(ProxyEvents.CERTIFICATE_ISSUED, eventData);
+    }
+    /**
+     * Emit a certificate renewed event
+     */
+    emitCertificateRenewed(data) {
+        const eventData = {
+            ...data,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.info?.(`Certificate renewed for ${data.domain}`);
+        this.emitter.emit(ProxyEvents.CERTIFICATE_RENEWED, eventData);
+    }
+    /**
+     * Emit a certificate failed event
+     */
+    emitCertificateFailed(data) {
+        const eventData = {
+            ...data,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.error?.(`Certificate issuance failed for ${data.domain}: ${data.error}`);
+        this.emitter.emit(ProxyEvents.CERTIFICATE_FAILED, eventData);
+    }
+    /**
+     * Emit a certificate expiring event
+     */
+    emitCertificateExpiring(data) {
+        const eventData = {
+            ...data,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.warn?.(`Certificate expiring for ${data.domain} in ${data.daysRemaining} days`);
+        this.emitter.emit(ProxyEvents.CERTIFICATE_EXPIRING, eventData);
+    }
+    /**
+     * Emit a component started event
+     */
+    emitComponentStarted(name, version) {
+        const eventData = {
+            name,
+            version,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.info?.(`Component ${name} started${version ? ` (v${version})` : ''}`);
+        this.emitter.emit(ProxyEvents.COMPONENT_STARTED, eventData);
+    }
+    /**
+     * Emit a component stopped event
+     */
+    emitComponentStopped(name) {
+        const eventData = {
+            name,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.info?.(`Component ${name} stopped`);
+        this.emitter.emit(ProxyEvents.COMPONENT_STOPPED, eventData);
+    }
+    /**
+     * Emit a connection established event
+     */
+    emitConnectionEstablished(data) {
+        const eventData = {
+            ...data,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.debug?.(`Connection ${data.connectionId} established from ${data.clientIp} on port ${data.port}`);
+        this.emitter.emit(ProxyEvents.CONNECTION_ESTABLISHED, eventData);
+    }
+    /**
+     * Emit a connection closed event
+     */
+    emitConnectionClosed(data) {
+        const eventData = {
+            ...data,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.debug?.(`Connection ${data.connectionId} closed`);
+        this.emitter.emit(ProxyEvents.CONNECTION_CLOSED, eventData);
+    }
+    /**
+     * Emit a route matched event
+     */
+    emitRouteMatched(data) {
+        const eventData = {
+            ...data,
+            timestamp: Date.now(),
+            componentType: this.componentType,
+            componentId: this.componentId
+        };
+        this.logger?.debug?.(`Route matched: ${data.route.name || data.route.id || 'unnamed'}`);
+        this.emitter.emit(ProxyEvents.ROUTE_MATCHED, eventData);
+    }
+    /**
+     * Subscribe to an event
+     */
+    on(event, handler) {
+        this.emitter.on(event, handler);
+    }
+    /**
+     * Subscribe to an event once
+     */
+    once(event, handler) {
+        this.emitter.once(event, handler);
+    }
+    /**
+     * Unsubscribe from an event
+     */
+    off(event, handler) {
+        this.emitter.off(event, handler);
+    }
+    /**
+     * Map Port80Handler events to standard proxy events
+     */
+    subscribePort80HandlerEvents(handler) {
+        handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, (data) => {
+            this.emitCertificateIssued({
+                ...data,
+                isRenewal: false,
+                source: 'port80handler'
+            });
+        });
+        handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, (data) => {
+            this.emitCertificateRenewed({
+                ...data,
+                isRenewal: true,
+                source: 'port80handler'
+            });
+        });
+        handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, (data) => {
+            this.emitCertificateFailed(data);
+        });
+        handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, (data) => {
+            this.emitCertificateExpiring(data);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/utils/index.d.ts

@@ -4,3 +4,10 @@
 export * from './event-utils.js';
 export * from './validation-utils.js';
 export * from './ip-utils.js';
+export * from './template-utils.js';
+export * from './route-manager.js';
+export * from './route-utils.js';
+export * from './security-utils.js';
+export * from './shared-security-manager.js';
+export * from './event-system.js';
+export * from './websocket-utils.js';

package/dist_ts/core/utils/index.js

@@ -4,4 +4,11 @@
 export * from './event-utils.js';
 export * from './validation-utils.js';
 export * from './ip-utils.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZUFBZSxDQUFDIn0=
+export * from './template-utils.js';
+export * from './route-manager.js';
+export * from './route-utils.js';
+export * from './security-utils.js';
+export * from './shared-security-manager.js';
+export * from './event-system.js';
+export * from './websocket-utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsc0JBQXNCLENBQUMifQ==

package/dist_ts/core/utils/route-manager.d.ts

@@ -0,0 +1,118 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../proxies/smart-proxy/models/route-types.js';
+/**
+ * Result of route matching
+ */
+export interface IRouteMatchResult {
+    route: IRouteConfig;
+    params?: Record<string, string>;
+}
+/**
+ * Logger interface for RouteManager
+ */
+export interface ILogger {
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    debug?: (message: string, ...args: any[]) => void;
+}
+/**
+ * Shared RouteManager used by both SmartProxy and NetworkProxy
+ *
+ * This provides a unified implementation for route management,
+ * route matching, and port handling.
+ */
+export declare class SharedRouteManager extends plugins.EventEmitter {
+    private routes;
+    private portMap;
+    private logger;
+    private enableDetailedLogging;
+    /**
+     * Memoization cache for expanded port ranges
+     */
+    private portRangeCache;
+    constructor(options: {
+        logger?: ILogger;
+        enableDetailedLogging?: boolean;
+        routes?: IRouteConfig[];
+    });
+    /**
+     * Update routes with new configuration
+     */
+    updateRoutes(routes?: IRouteConfig[]): void;
+    /**
+     * Get all routes
+     */
+    getRoutes(): IRouteConfig[];
+    /**
+     * Rebuild the port mapping for fast lookups
+     * Also logs information about the ports being listened on
+     */
+    private rebuildPortMap;
+    /**
+     * Expand a port range specification into an array of individual ports
+     * Uses caching to improve performance for frequently used port ranges
+     *
+     * @public - Made public to allow external code to interpret port ranges
+     */
+    expandPortRange(portRange: TPortRange): number[];
+    /**
+     * Get all ports that should be listened on
+     * This method automatically infers all required ports from route configurations
+     */
+    getListeningPorts(): number[];
+    /**
+     * Get all routes for a given port
+     */
+    getRoutesForPort(port: number): IRouteConfig[];
+    /**
+     * Find the matching route for a connection
+     */
+    findMatchingRoute(context: IRouteContext): IRouteMatchResult | null;
+    /**
+     * Check if a route matches the given context
+     */
+    private matchesRoute;
+    /**
+     * Match a domain pattern against a domain
+     * @deprecated Use the matchDomain function from route-utils.js instead
+     */
+    matchDomain(pattern: string, domain: string): boolean;
+    /**
+     * Match a path pattern against a path
+     * @deprecated Use the matchPath function from route-utils.js instead
+     */
+    matchPath(pattern: string, path: string): boolean;
+    /**
+     * Match an IP pattern against a pattern
+     * @deprecated Use the matchIpPattern function from route-utils.js instead
+     */
+    matchIpPattern(pattern: string, ip: string): boolean;
+    /**
+     * Match an IP against a CIDR pattern
+     * @deprecated Use the matchIpCidr function from route-utils.js instead
+     */
+    matchIpCidr(cidr: string, ip: string): boolean;
+    /**
+     * Convert an IP address to a numeric value
+     * @deprecated Use the ipToNumber function from route-utils.js instead
+     */
+    private ipToNumber;
+    /**
+     * Validate the route configuration and return any warnings
+     */
+    validateConfiguration(): string[];
+    /**
+     * Check if two route matches are similar (potential conflict)
+     */
+    private areMatchesSimilar;
+    /**
+     * Check if a route is completely shadowed by a higher priority route
+     */
+    private isRouteShadowed;
+    /**
+     * Check if route1 is more specific than route2
+     * @deprecated Use the calculateRouteSpecificity function from route-utils.js instead
+     */
+    private isRouteMoreSpecific;
+}