@push.rocks/smartproxy 15.0.2 → 16.0.3

package/dist_ts/certificate/providers/cert-provisioner.js

@@ -4,21 +4,60 @@ import { Port80Handler } from '../../http/port80/port80-handler.js';
 /**
  * CertProvisioner manages certificate provisioning and renewal workflows,
  * unifying static certificates and HTTP-01 challenges via Port80Handler.
+ *
+ * This class directly works with route configurations instead of converting to domain configs.
  */
 export class CertProvisioner extends plugins.EventEmitter {
     /**
-     * @param domainConfigs Array of domain configuration objects
+     * Extract routes that need certificates
+     * @param routes Route configurations
+     */
+    extractCertificateRoutesFromRoutes(routes) {
+        const certRoutes = [];
+        // Process all HTTPS routes that need certificates
+        for (const route of routes) {
+            // Only process routes with TLS termination that need certificates
+            if (route.action.type === 'forward' &&
+                route.action.tls &&
+                (route.action.tls.mode === 'terminate' || route.action.tls.mode === 'terminate-and-reencrypt') &&
+                route.match.domains) {
+                // Extract domains from the route
+                const domains = Array.isArray(route.match.domains)
+                    ? route.match.domains
+                    : [route.match.domains];
+                // For each domain in the route, create a certRoute entry
+                for (const domain of domains) {
+                    // Skip wildcard domains that can't use ACME unless we have a certProvider
+                    if (domain.includes('*') && (!this.certProvisionFunction || this.certProvisionFunction.length === 0)) {
+                        console.warn(`Skipping wildcard domain that requires a certProvisionFunction: ${domain}`);
+                        continue;
+                    }
+                    certRoutes.push({
+                        domain,
+                        route,
+                        tlsMode: route.action.tls.mode
+                    });
+                }
+            }
+        }
+        return certRoutes;
+    }
+    /**
+     * Constructor for CertProvisioner
+     *
+     * @param routeConfigs Array of route configurations
      * @param port80Handler HTTP-01 challenge handler instance
      * @param networkProxyBridge Bridge for applying external certificates
      * @param certProvider Optional callback returning a static cert or 'http01'
      * @param renewThresholdDays Days before expiry to trigger renewals
      * @param renewCheckIntervalHours Interval in hours to check for renewals
      * @param autoRenew Whether to automatically schedule renewals
-     * @param forwardConfigs Domain forwarding configurations for ACME challenges
+     * @param routeForwards Route-specific forwarding configs for ACME challenges
      */
-    constructor(domainConfigs, port80Handler, networkProxyBridge, certProvider, renewThresholdDays = 30, renewCheckIntervalHours = 24, autoRenew = true, forwardConfigs = []) {
+    constructor(routeConfigs, port80Handler, networkProxyBridge, certProvider, renewThresholdDays = 30, renewCheckIntervalHours = 24, autoRenew = true, routeForwards = []) {
         super();
-        this.domainConfigs = domainConfigs;
+        this.certRoutes = [];
+        this.routeConfigs = routeConfigs;
         this.port80Handler = port80Handler;
         this.networkProxyBridge = networkProxyBridge;
         this.certProvisionFunction = certProvider;
@@ -26,7 +65,9 @@ export class CertProvisioner extends plugins.EventEmitter {
         this.renewCheckIntervalHours = renewCheckIntervalHours;
         this.autoRenew = autoRenew;
         this.provisionMap = new Map();
-        this.forwardConfigs = forwardConfigs;
+        this.routeForwards = routeForwards;
+        // Extract certificate routes during instantiation
+        this.certRoutes = this.extractCertificateRoutesFromRoutes(routeConfigs);
     }
     /**
      * Start initial provisioning and schedule renewals.
@@ -34,10 +75,10 @@ export class CertProvisioner extends plugins.EventEmitter {
     async start() {
         // Subscribe to Port80Handler certificate events
         this.setupEventSubscriptions();
-        // Apply external forwarding for ACME challenges
+        // Apply route forwarding for ACME challenges
         this.setupForwardingConfigs();
-        // Initial provisioning for all domains
-        await this.provisionAllDomains();
+        // Initial provisioning for all domains in routes
+        await this.provisionAllCertificates();
         // Schedule renewals if enabled
         if (this.autoRenew) {
             this.scheduleRenewals();
@@ -47,46 +88,74 @@ export class CertProvisioner extends plugins.EventEmitter {
      * Set up event subscriptions for certificate events
      */
     setupEventSubscriptions() {
-        // We need to reimplement subscribeToPort80Handler here
         this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, (data) => {
-            this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, { ...data, source: 'http01', isRenewal: false });
+            // Add route reference if we have it
+            const routeRef = this.findRouteForDomain(data.domain);
+            const enhancedData = {
+                ...data,
+                source: 'http01',
+                isRenewal: false,
+                routeReference: routeRef ? {
+                    routeId: routeRef.route.name,
+                    routeName: routeRef.route.name
+                } : undefined
+            };
+            this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, enhancedData);
         });
         this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, (data) => {
-            this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, { ...data, source: 'http01', isRenewal: true });
+            // Add route reference if we have it
+            const routeRef = this.findRouteForDomain(data.domain);
+            const enhancedData = {
+                ...data,
+                source: 'http01',
+                isRenewal: true,
+                routeReference: routeRef ? {
+                    routeId: routeRef.route.name,
+                    routeName: routeRef.route.name
+                } : undefined
+            };
+            this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, enhancedData);
         });
         this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, (error) => {
             this.emit(CertProvisionerEvents.CERTIFICATE_FAILED, error);
         });
     }
+    /**
+     * Find a route for a given domain
+     */
+    findRouteForDomain(domain) {
+        return this.certRoutes.find(certRoute => certRoute.domain === domain);
+    }
     /**
      * Set up forwarding configurations for the Port80Handler
      */
     setupForwardingConfigs() {
-        for (const config of this.forwardConfigs) {
+        for (const config of this.routeForwards) {
             const domainOptions = {
                 domainName: config.domain,
                 sslRedirect: config.sslRedirect || false,
                 acmeMaintenance: false,
-                forward: config.forwardConfig,
-                acmeForward: config.acmeForwardConfig
+                forward: config.target ? {
+                    ip: config.target.host,
+                    port: config.target.port
+                } : undefined
             };
             this.port80Handler.addDomain(domainOptions);
         }
     }
     /**
-     * Provision certificates for all configured domains
+     * Provision certificates for all routes that need them
      */
-    async provisionAllDomains() {
-        const domains = this.domainConfigs.flatMap(cfg => cfg.domains);
-        for (const domain of domains) {
-            await this.provisionDomain(domain);
+    async provisionAllCertificates() {
+        for (const certRoute of this.certRoutes) {
+            await this.provisionCertificateForRoute(certRoute);
         }
     }
     /**
-     * Provision a certificate for a single domain
-     * @param domain Domain to provision
+     * Provision a certificate for a route
      */
-    async provisionDomain(domain) {
+    async provisionCertificateForRoute(certRoute) {
+        const { domain, route } = certRoute;
         const isWildcard = domain.includes('*');
         let provision = 'http01';
         // Try to get a certificate from the provision function
@@ -95,7 +164,7 @@ export class CertProvisioner extends plugins.EventEmitter {
                 provision = await this.certProvisionFunction(domain);
             }
             catch (err) {
-                console.error(`certProvider error for ${domain}:`, err);
+                console.error(`certProvider error for ${domain} on route ${route.name || 'unnamed'}:`, err);
             }
         }
         else if (isWildcard) {
@@ -103,27 +172,34 @@ export class CertProvisioner extends plugins.EventEmitter {
             console.warn(`Skipping wildcard domain without certProvisionFunction: ${domain}`);
             return;
         }
+        // Store the route reference with the provision type
+        this.provisionMap.set(domain, {
+            type: provision === 'http01' || provision === 'dns01' ? provision : 'static',
+            routeRef: certRoute
+        });
         // Handle different provisioning methods
         if (provision === 'http01') {
             if (isWildcard) {
                 console.warn(`Skipping HTTP-01 for wildcard domain: ${domain}`);
                 return;
             }
-            this.provisionMap.set(domain, 'http01');
             this.port80Handler.addDomain({
                 domainName: domain,
                 sslRedirect: true,
-                acmeMaintenance: true
+                acmeMaintenance: true,
+                routeReference: {
+                    routeId: route.name || domain,
+                    routeName: route.name
+                }
             });
         }
         else if (provision === 'dns01') {
             // DNS-01 challenges would be handled by the certProvisionFunction
-            this.provisionMap.set(domain, 'dns01');
             // DNS-01 handling would go here if implemented
+            console.log(`DNS-01 challenge type set for ${domain}`);
         }
         else {
             // Static certificate (e.g., DNS-01 provisioned or user-provided)
-            this.provisionMap.set(domain, 'static');
             const certObj = provision;
             const certData = {
                 domain: certObj.domainName,
@@ -131,7 +207,11 @@ export class CertProvisioner extends plugins.EventEmitter {
                 privateKey: certObj.privateKey,
                 expiryDate: new Date(certObj.validUntil),
                 source: 'static',
-                isRenewal: false
+                isRenewal: false,
+                routeReference: {
+                    routeId: route.name || domain,
+                    routeName: route.name
+                }
             };
             this.networkProxyBridge.applyExternalCertificate(certData);
             this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
@@ -155,12 +235,12 @@ export class CertProvisioner extends plugins.EventEmitter {
      * Perform renewals for all domains that need it
      */
     async performRenewals() {
-        for (const [domain, type] of this.provisionMap.entries()) {
+        for (const [domain, info] of this.provisionMap.entries()) {
             // Skip wildcard domains for HTTP-01 challenges
-            if (domain.includes('*') && type === 'http01')
+            if (domain.includes('*') && info.type === 'http01')
                 continue;
             try {
-                await this.renewDomain(domain, type);
+                await this.renewCertificateForDomain(domain, info.type, info.routeRef);
             }
             catch (err) {
                 console.error(`Renewal error for ${domain}:`, err);
@@ -171,8 +251,9 @@ export class CertProvisioner extends plugins.EventEmitter {
      * Renew a certificate for a specific domain
      * @param domain Domain to renew
      * @param provisionType Type of provisioning for this domain
+     * @param certRoute The route reference for this domain
      */
-    async renewDomain(domain, provisionType) {
+    async renewCertificateForDomain(domain, provisionType, certRoute) {
         if (provisionType === 'http01') {
             await this.port80Handler.renewCertificate(domain);
         }
@@ -180,13 +261,18 @@ export class CertProvisioner extends plugins.EventEmitter {
             const provision = await this.certProvisionFunction(domain);
             if (provision !== 'http01' && provision !== 'dns01') {
                 const certObj = provision;
+                const routeRef = certRoute?.route;
                 const certData = {
                     domain: certObj.domainName,
                     certificate: certObj.publicKey,
                     privateKey: certObj.privateKey,
                     expiryDate: new Date(certObj.validUntil),
                     source: 'static',
-                    isRenewal: true
+                    isRenewal: true,
+                    routeReference: routeRef ? {
+                        routeId: routeRef.name || domain,
+                        routeName: routeRef.name
+                    } : undefined
                 };
                 this.networkProxyBridge.applyExternalCertificate(certData);
                 this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, certData);
@@ -203,10 +289,14 @@ export class CertProvisioner extends plugins.EventEmitter {
     }
     /**
      * Request a certificate on-demand for the given domain.
+     * This will look for a matching route configuration and provision accordingly.
+     *
      * @param domain Domain name to provision
      */
     async requestCertificate(domain) {
         const isWildcard = domain.includes('*');
+        // Find matching route
+        const certRoute = this.findRouteForDomain(domain);
         // Determine provisioning method
         let provision = 'http01';
         if (this.certProvisionFunction) {
@@ -224,7 +314,6 @@ export class CertProvisioner extends plugins.EventEmitter {
         }
         else if (provision === 'dns01') {
             // DNS-01 challenges would be handled by external mechanisms
-            // This is a placeholder for future implementation
             console.log(`DNS-01 challenge requested for ${domain}`);
         }
         else {
@@ -236,7 +325,11 @@ export class CertProvisioner extends plugins.EventEmitter {
                 privateKey: certObj.privateKey,
                 expiryDate: new Date(certObj.validUntil),
                 source: 'static',
-                isRenewal: false
+                isRenewal: false,
+                routeReference: certRoute ? {
+                    routeId: certRoute.route.name || domain,
+                    routeName: certRoute.route.name
+                } : undefined
             };
             this.networkProxyBridge.applyExternalCertificate(certData);
             this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
@@ -244,19 +337,86 @@ export class CertProvisioner extends plugins.EventEmitter {
     }
     /**
      * Add a new domain for certificate provisioning
+     *
      * @param domain Domain to add
      * @param options Domain configuration options
      */
     async addDomain(domain, options) {
         const domainOptions = {
             domainName: domain,
-            sslRedirect: options?.sslRedirect || true,
-            acmeMaintenance: options?.acmeMaintenance || true
+            sslRedirect: options?.sslRedirect ?? true,
+            acmeMaintenance: options?.acmeMaintenance ?? true,
+            routeReference: {
+                routeId: options?.routeId,
+                routeName: options?.routeName
+            }
         };
         this.port80Handler.addDomain(domainOptions);
-        await this.provisionDomain(domain);
+        // Find matching route or create a generic one
+        const existingRoute = this.findRouteForDomain(domain);
+        if (existingRoute) {
+            await this.provisionCertificateForRoute(existingRoute);
+        }
+        else {
+            // We don't have a route, just provision the domain
+            const isWildcard = domain.includes('*');
+            let provision = 'http01';
+            if (this.certProvisionFunction) {
+                provision = await this.certProvisionFunction(domain);
+            }
+            else if (isWildcard) {
+                throw new Error(`Cannot request certificate for wildcard domain without certProvisionFunction: ${domain}`);
+            }
+            this.provisionMap.set(domain, {
+                type: provision === 'http01' || provision === 'dns01' ? provision : 'static'
+            });
+            if (provision !== 'http01' && provision !== 'dns01') {
+                const certObj = provision;
+                const certData = {
+                    domain: certObj.domainName,
+                    certificate: certObj.publicKey,
+                    privateKey: certObj.privateKey,
+                    expiryDate: new Date(certObj.validUntil),
+                    source: 'static',
+                    isRenewal: false,
+                    routeReference: {
+                        routeId: options?.routeId,
+                        routeName: options?.routeName
+                    }
+                };
+                this.networkProxyBridge.applyExternalCertificate(certData);
+                this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
+            }
+        }
+    }
+    /**
+     * Update routes with new configurations
+     * This replaces all existing routes with new ones and re-provisions certificates as needed
+     *
+     * @param newRoutes New route configurations to use
+     */
+    async updateRoutes(newRoutes) {
+        // Store the new route configs
+        this.routeConfigs = newRoutes;
+        // Extract new certificate routes
+        const newCertRoutes = this.extractCertificateRoutesFromRoutes(newRoutes);
+        // Find domains that no longer need certificates
+        const oldDomains = new Set(this.certRoutes.map(r => r.domain));
+        const newDomains = new Set(newCertRoutes.map(r => r.domain));
+        // Domains to remove
+        const domainsToRemove = [...oldDomains].filter(d => !newDomains.has(d));
+        // Remove obsolete domains from provision map
+        for (const domain of domainsToRemove) {
+            this.provisionMap.delete(domain);
+        }
+        // Update the cert routes
+        this.certRoutes = newCertRoutes;
+        // Provision certificates for new routes
+        for (const certRoute of newCertRoutes) {
+            if (!oldDomains.has(certRoute.domain)) {
+                await this.provisionCertificateForRoute(certRoute);
+            }
+        }
     }
 }
-// For backward compatibility
-export { CertProvisioner as CertificateProvisioner };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cert-provisioner.js","sourceRoot":"","sources":["../../../ts/certificate/providers/cert-provisioner.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cert-provisioner.js","sourceRoot":"","sources":["../../../ts/certificate/providers/cert-provisioner.ts"],"names":[],"mappings":"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"}

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