@push.rocks/smartproxy 16.0.2 → 16.0.4

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '16.0.2',
+    version: '16.0.4',
     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.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

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

@@ -2,3 +2,5 @@
  * Core data models and interfaces
  */
 export * from './common-types.js';
+export * from './socket-augmentation.js';
+export * from './route-context.js';

package/dist_ts/core/models/index.js

@@ -2,4 +2,6 @@
  * Core data models and interfaces
  */
 export * from './common-types.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsbUJBQW1CLENBQUMifQ==
+export * from './socket-augmentation.js';
+export * from './route-context.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG9CQUFvQixDQUFDIn0=

package/dist_ts/core/models/route-context.d.ts

@@ -0,0 +1,62 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Shared Route Context Interface
+ *
+ * This interface defines the route context object that is used by both
+ * SmartProxy and NetworkProxy, ensuring consistent context throughout the system.
+ */
+/**
+ * Route context for route matching and function-based target resolution
+ */
+export interface IRouteContext {
+    port: number;
+    domain?: string;
+    clientIp: string;
+    serverIp: string;
+    path?: string;
+    query?: string;
+    headers?: Record<string, string>;
+    isTls: boolean;
+    tlsVersion?: string;
+    routeName?: string;
+    routeId?: string;
+    targetHost?: string | string[];
+    targetPort?: number;
+    timestamp: number;
+    connectionId: string;
+}
+/**
+ * Extended context interface with HTTP-specific objects
+ * Used only in NetworkProxy for HTTP request handling
+ */
+export interface IHttpRouteContext extends IRouteContext {
+    req?: plugins.http.IncomingMessage;
+    res?: plugins.http.ServerResponse;
+    method?: string;
+}
+/**
+ * Extended context interface with HTTP/2-specific objects
+ * Used only in NetworkProxy for HTTP/2 request handling
+ */
+export interface IHttp2RouteContext extends IHttpRouteContext {
+    stream?: plugins.http2.ServerHttp2Stream;
+    headers?: Record<string, string>;
+}
+/**
+ * Create a basic route context from connection information
+ */
+export declare function createBaseRouteContext(options: {
+    port: number;
+    clientIp: string;
+    serverIp: string;
+    domain?: string;
+    isTls: boolean;
+    tlsVersion?: string;
+    connectionId: string;
+}): IRouteContext;
+/**
+ * Convert IHttpRouteContext to IRouteContext
+ * This is used to ensure type compatibility when passing HTTP-specific context
+ * to methods that require the base IRouteContext type
+ */
+export declare function toBaseContext(httpContext: IHttpRouteContext): IRouteContext;

package/dist_ts/core/models/route-context.js

@@ -0,0 +1,43 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Create a basic route context from connection information
+ */
+export function createBaseRouteContext(options) {
+    return {
+        ...options,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Convert IHttpRouteContext to IRouteContext
+ * This is used to ensure type compatibility when passing HTTP-specific context
+ * to methods that require the base IRouteContext type
+ */
+export function toBaseContext(httpContext) {
+    // Create a new object with only the properties from IRouteContext
+    const baseContext = {
+        port: httpContext.port,
+        domain: httpContext.domain,
+        clientIp: httpContext.clientIp,
+        serverIp: httpContext.serverIp,
+        path: httpContext.path,
+        query: httpContext.query,
+        headers: httpContext.headers,
+        isTls: httpContext.isTls,
+        tlsVersion: httpContext.tlsVersion,
+        routeName: httpContext.routeName,
+        routeId: httpContext.routeId,
+        timestamp: httpContext.timestamp,
+        connectionId: httpContext.connectionId
+    };
+    // Only copy targetHost if it's a string
+    if (httpContext.targetHost) {
+        baseContext.targetHost = httpContext.targetHost;
+    }
+    // Copy targetPort if it exists
+    if (httpContext.targetPort) {
+        baseContext.targetPort = httpContext.targetPort;
+    }
+    return baseContext;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2NvcmUvbW9kZWxzL3JvdXRlLWNvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQTRENUM7O0dBRUc7QUFDSCxNQUFNLFVBQVUsc0JBQXNCLENBQUMsT0FRdEM7SUFDQyxPQUFPO1FBQ0wsR0FBRyxPQUFPO1FBQ1YsU0FBUyxFQUFFLElBQUksQ0FBQyxHQUFHLEVBQUU7S0FDdEIsQ0FBQztBQUNKLENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FBQyxXQUE4QjtJQUMxRCxrRUFBa0U7SUFDbEUsTUFBTSxXQUFXLEdBQWtCO1FBQ2pDLElBQUksRUFBRSxXQUFXLENBQUMsSUFBSTtRQUN0QixNQUFNLEVBQUUsV0FBVyxDQUFDLE1BQU07UUFDMUIsUUFBUSxFQUFFLFdBQVcsQ0FBQyxRQUFRO1FBQzlCLFFBQVEsRUFBRSxXQUFXLENBQUMsUUFBUTtRQUM5QixJQUFJLEVBQUUsV0FBVyxDQUFDLElBQUk7UUFDdEIsS0FBSyxFQUFFLFdBQVcsQ0FBQyxLQUFLO1FBQ3hCLE9BQU8sRUFBRSxXQUFXLENBQUMsT0FBTztRQUM1QixLQUFLLEVBQUUsV0FBVyxDQUFDLEtBQUs7UUFDeEIsVUFBVSxFQUFFLFdBQVcsQ0FBQyxVQUFVO1FBQ2xDLFNBQVMsRUFBRSxXQUFXLENBQUMsU0FBUztRQUNoQyxPQUFPLEVBQUUsV0FBVyxDQUFDLE9BQU87UUFDNUIsU0FBUyxFQUFFLFdBQVcsQ0FBQyxTQUFTO1FBQ2hDLFlBQVksRUFBRSxXQUFXLENBQUMsWUFBWTtLQUN2QyxDQUFDO0lBRUYsd0NBQXdDO0lBQ3hDLElBQUksV0FBVyxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQzNCLFdBQVcsQ0FBQyxVQUFVLEdBQUcsV0FBVyxDQUFDLFVBQVUsQ0FBQztJQUNsRCxDQUFDO0lBRUQsK0JBQStCO0lBQy9CLElBQUksV0FBVyxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQzNCLFdBQVcsQ0FBQyxVQUFVLEdBQUcsV0FBVyxDQUFDLFVBQVUsQ0FBQztJQUNsRCxDQUFDO0lBRUQsT0FBTyxXQUFXLENBQUM7QUFDckIsQ0FBQyJ9

package/dist_ts/core/models/socket-augmentation.d.ts

@@ -0,0 +1,12 @@
+import * as plugins from '../../plugins.js';
+declare module 'net' {
+    interface Socket {
+        encrypted?: boolean;
+        authorizationError?: Error;
+        getTLSVersion?(): string;
+        getPeerCertificate?(detailed?: boolean): any;
+        getSession?(): Buffer;
+    }
+}
+export declare function isTLSSocket(socket: plugins.net.Socket): boolean;
+export declare function getTLSVersion(socket: plugins.net.Socket): string | null;

package/dist_ts/core/models/socket-augmentation.js

@@ -0,0 +1,18 @@
+import * as plugins from '../../plugins.js';
+// Export a utility function to check if a socket is a TLS socket
+export function isTLSSocket(socket) {
+    return 'encrypted' in socket && !!socket.encrypted;
+}
+// Export a utility function to safely get the TLS version
+export function getTLSVersion(socket) {
+    if (socket.getTLSVersion) {
+        try {
+            return socket.getTLSVersion();
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ja2V0LWF1Z21lbnRhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2NvcmUvbW9kZWxzL3NvY2tldC1hdWdtZW50YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQWlCNUMsaUVBQWlFO0FBQ2pFLE1BQU0sVUFBVSxXQUFXLENBQUMsTUFBMEI7SUFDcEQsT0FBTyxXQUFXLElBQUksTUFBTSxJQUFJLENBQUMsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDO0FBQ3JELENBQUM7QUFFRCwwREFBMEQ7QUFDMUQsTUFBTSxVQUFVLGFBQWEsQ0FBQyxNQUEwQjtJQUN0RCxJQUFJLE1BQU0sQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUN6QixJQUFJLENBQUM7WUFDSCxPQUFPLE1BQU0sQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUNoQyxDQUFDO1FBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztZQUNYLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMifQ==

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==