@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/forwarding/handlers/https-terminate-to-https-handler.js

@@ -0,0 +1,254 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+/**
+ * Handler for HTTPS termination with HTTPS backend
+ */
+export class HttpsTerminateToHttpsHandler extends ForwardingHandler {
+    /**
+     * Create a new HTTPS termination with HTTPS backend handler
+     * @param config The forwarding configuration
+     */
+    constructor(config) {
+        super(config);
+        this.secureContext = null;
+        // Validate that this is an HTTPS terminate to HTTPS configuration
+        if (config.type !== 'https-terminate-to-https') {
+            throw new Error(`Invalid configuration type for HttpsTerminateToHttpsHandler: ${config.type}`);
+        }
+    }
+    /**
+     * Initialize the handler, setting up TLS context
+     */
+    async initialize() {
+        // We need to load or create TLS certificates for termination
+        if (this.config.https?.customCert) {
+            // Use custom certificate from configuration
+            this.secureContext = plugins.tls.createSecureContext({
+                key: this.config.https.customCert.key,
+                cert: this.config.https.customCert.cert
+            });
+            this.emit(ForwardingHandlerEvents.CERTIFICATE_LOADED, {
+                source: 'config',
+                domain: this.config.target.host
+            });
+        }
+        else if (this.config.acme?.enabled) {
+            // Request certificate through ACME if needed
+            this.emit(ForwardingHandlerEvents.CERTIFICATE_NEEDED, {
+                domain: Array.isArray(this.config.target.host)
+                    ? this.config.target.host[0]
+                    : this.config.target.host,
+                useProduction: this.config.acme.production || false
+            });
+            // In a real implementation, we would wait for the certificate to be issued
+            // For now, we'll use a dummy context
+            this.secureContext = plugins.tls.createSecureContext({
+                key: '-----BEGIN PRIVATE KEY-----\nDummy key\n-----END PRIVATE KEY-----',
+                cert: '-----BEGIN CERTIFICATE-----\nDummy cert\n-----END CERTIFICATE-----'
+            });
+        }
+        else {
+            throw new Error('HTTPS termination requires either a custom certificate or ACME enabled');
+        }
+    }
+    /**
+     * Set the secure context for TLS termination
+     * Called when a certificate is available
+     * @param context The secure context
+     */
+    setSecureContext(context) {
+        this.secureContext = context;
+    }
+    /**
+     * Handle a TLS/SSL socket connection by terminating TLS and creating a new TLS connection to backend
+     * @param clientSocket The incoming socket from the client
+     */
+    handleConnection(clientSocket) {
+        // Make sure we have a secure context
+        if (!this.secureContext) {
+            clientSocket.destroy(new Error('TLS secure context not initialized'));
+            return;
+        }
+        const remoteAddress = clientSocket.remoteAddress || 'unknown';
+        const remotePort = clientSocket.remotePort || 0;
+        // Create a TLS socket using our secure context
+        const tlsSocket = new plugins.tls.TLSSocket(clientSocket, {
+            secureContext: this.secureContext,
+            isServer: true
+        });
+        this.emit(ForwardingHandlerEvents.CONNECTED, {
+            remoteAddress,
+            remotePort,
+            tls: true
+        });
+        // Handle TLS errors
+        tlsSocket.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: `TLS error: ${error.message}`
+            });
+            if (!tlsSocket.destroyed) {
+                tlsSocket.destroy();
+            }
+        });
+        // The TLS socket will now emit HTTP traffic that can be processed
+        // In a real implementation, we would create an HTTP parser and handle
+        // the requests here, but for simplicity, we'll just forward the data
+        // Get the target from configuration
+        const target = this.getTargetFromConfig();
+        // Set up the connection to the HTTPS backend
+        const connectToBackend = () => {
+            const backendSocket = plugins.tls.connect({
+                host: target.host,
+                port: target.port,
+                // In a real implementation, we would configure TLS options
+                rejectUnauthorized: false // For testing only, never use in production
+            }, () => {
+                this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
+                    direction: 'outbound',
+                    target: `${target.host}:${target.port}`,
+                    tls: true
+                });
+                // Set up bidirectional data flow
+                tlsSocket.pipe(backendSocket);
+                backendSocket.pipe(tlsSocket);
+            });
+            backendSocket.on('error', (error) => {
+                this.emit(ForwardingHandlerEvents.ERROR, {
+                    remoteAddress,
+                    error: `Backend connection error: ${error.message}`
+                });
+                if (!tlsSocket.destroyed) {
+                    tlsSocket.destroy();
+                }
+            });
+            // Handle close
+            backendSocket.on('close', () => {
+                if (!tlsSocket.destroyed) {
+                    tlsSocket.destroy();
+                }
+            });
+            // Set timeout
+            const timeout = this.getTimeout();
+            backendSocket.setTimeout(timeout);
+            backendSocket.on('timeout', () => {
+                this.emit(ForwardingHandlerEvents.ERROR, {
+                    remoteAddress,
+                    error: 'Backend connection timeout'
+                });
+                if (!backendSocket.destroyed) {
+                    backendSocket.destroy();
+                }
+            });
+        };
+        // Wait for the TLS handshake to complete before connecting to backend
+        tlsSocket.on('secure', () => {
+            connectToBackend();
+        });
+        // Handle close
+        tlsSocket.on('close', () => {
+            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+                remoteAddress
+            });
+        });
+        // Set timeout
+        const timeout = this.getTimeout();
+        tlsSocket.setTimeout(timeout);
+        tlsSocket.on('timeout', () => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: 'TLS connection timeout'
+            });
+            if (!tlsSocket.destroyed) {
+                tlsSocket.destroy();
+            }
+        });
+    }
+    /**
+     * Handle an HTTP request by forwarding to the HTTPS backend
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req, res) {
+        // Check if we should redirect to HTTPS
+        if (this.config.http?.redirectToHttps) {
+            this.redirectToHttps(req, res);
+            return;
+        }
+        // Get the target from configuration
+        const target = this.getTargetFromConfig();
+        // Create custom headers with variable substitution
+        const variables = {
+            clientIp: req.socket.remoteAddress || 'unknown'
+        };
+        // Prepare headers, merging with any custom headers from config
+        const headers = this.applyCustomHeaders(req.headers, variables);
+        // Create the proxy request options
+        const options = {
+            hostname: target.host,
+            port: target.port,
+            path: req.url,
+            method: req.method,
+            headers,
+            // In a real implementation, we would configure TLS options
+            rejectUnauthorized: false // For testing only, never use in production
+        };
+        // Create the proxy request using HTTPS
+        const proxyReq = plugins.https.request(options, (proxyRes) => {
+            // Copy status code and headers from the proxied response
+            res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+            // Pipe the proxy response to the client response
+            proxyRes.pipe(res);
+            // Track response size for logging
+            let responseSize = 0;
+            proxyRes.on('data', (chunk) => {
+                responseSize += chunk.length;
+            });
+            proxyRes.on('end', () => {
+                this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
+                    statusCode: proxyRes.statusCode,
+                    headers: proxyRes.headers,
+                    size: responseSize
+                });
+            });
+        });
+        // Handle errors in the proxy request
+        proxyReq.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress: req.socket.remoteAddress,
+                error: `Proxy request error: ${error.message}`
+            });
+            // Send an error response if headers haven't been sent yet
+            if (!res.headersSent) {
+                res.writeHead(502, { 'Content-Type': 'text/plain' });
+                res.end(`Error forwarding request: ${error.message}`);
+            }
+            else {
+                // Just end the response if headers have already been sent
+                res.end();
+            }
+        });
+        // Track request details for logging
+        let requestSize = 0;
+        req.on('data', (chunk) => {
+            requestSize += chunk.length;
+        });
+        // Log the request
+        this.emit(ForwardingHandlerEvents.HTTP_REQUEST, {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            remoteAddress: req.socket.remoteAddress,
+            target: `${target.host}:${target.port}`
+        });
+        // Pipe the client request to the proxy request
+        if (req.readable) {
+            req.pipe(proxyReq);
+        }
+        else {
+            proxyReq.end();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"https-terminate-to-https-handler.js","sourceRoot":"","sources":["../../../ts/forwarding/handlers/https-terminate-to-https-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/forwarding/handlers/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Forwarding handler implementations
+ */
+export { ForwardingHandler } from './base-handler.js';
+export { HttpForwardingHandler } from './http-handler.js';
+export { HttpsPassthroughHandler } from './https-passthrough-handler.js';
+export { HttpsTerminateToHttpHandler } from './https-terminate-to-http-handler.js';
+export { HttpsTerminateToHttpsHandler } from './https-terminate-to-https-handler.js';

package/dist_ts/forwarding/handlers/index.js

@@ -0,0 +1,9 @@
+/**
+ * Forwarding handler implementations
+ */
+export { ForwardingHandler } from './base-handler.js';
+export { HttpForwardingHandler } from './http-handler.js';
+export { HttpsPassthroughHandler } from './https-passthrough-handler.js';
+export { HttpsTerminateToHttpHandler } from './https-terminate-to-http-handler.js';
+export { HttpsTerminateToHttpsHandler } from './https-terminate-to-https-handler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9mb3J3YXJkaW5nL2hhbmRsZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDdEQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekUsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDbkYsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sdUNBQXVDLENBQUMifQ==

package/dist_ts/forwarding/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Forwarding system module
+ * Provides a flexible and type-safe way to configure and manage various forwarding strategies
+ */
+export * from './config/forwarding-types.js';
+export * from './config/domain-config.js';
+export * from './config/domain-manager.js';
+export { ForwardingHandler } from './handlers/base-handler.js';
+export * from './handlers/http-handler.js';
+export * from './handlers/https-passthrough-handler.js';
+export * from './handlers/https-terminate-to-http-handler.js';
+export * from './handlers/https-terminate-to-https-handler.js';
+export * from './factory/forwarding-factory.js';
+export declare const helpers: {
+    httpOnly: (partialConfig: Partial<import("./config/forwarding-types.js").IForwardConfig> & Pick<import("./config/forwarding-types.js").IForwardConfig, "target">) => import("./config/forwarding-types.js").IForwardConfig;
+    tlsTerminateToHttp: (partialConfig: Partial<import("./config/forwarding-types.js").IForwardConfig> & Pick<import("./config/forwarding-types.js").IForwardConfig, "target">) => import("./config/forwarding-types.js").IForwardConfig;
+    tlsTerminateToHttps: (partialConfig: Partial<import("./config/forwarding-types.js").IForwardConfig> & Pick<import("./config/forwarding-types.js").IForwardConfig, "target">) => import("./config/forwarding-types.js").IForwardConfig;
+    httpsPassthrough: (partialConfig: Partial<import("./config/forwarding-types.js").IForwardConfig> & Pick<import("./config/forwarding-types.js").IForwardConfig, "target">) => import("./config/forwarding-types.js").IForwardConfig;
+};

package/dist_ts/forwarding/index.js

@@ -0,0 +1,25 @@
+/**
+ * Forwarding system module
+ * Provides a flexible and type-safe way to configure and manage various forwarding strategies
+ */
+// Export types and configuration
+export * from './config/forwarding-types.js';
+export * from './config/domain-config.js';
+export * from './config/domain-manager.js';
+// Export handlers
+export { ForwardingHandler } from './handlers/base-handler.js';
+export * from './handlers/http-handler.js';
+export * from './handlers/https-passthrough-handler.js';
+export * from './handlers/https-terminate-to-http-handler.js';
+export * from './handlers/https-terminate-to-https-handler.js';
+// Export factory
+export * from './factory/forwarding-factory.js';
+// Helper functions as a convenience object
+import { httpOnly, tlsTerminateToHttp, tlsTerminateToHttps, httpsPassthrough } from './config/forwarding-types.js';
+export const helpers = {
+    httpOnly,
+    tlsTerminateToHttp,
+    tlsTerminateToHttps,
+    httpsPassthrough
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9mb3J3YXJkaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILGlDQUFpQztBQUNqQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQztBQUUzQyxrQkFBa0I7QUFDbEIsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDL0QsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyxnREFBZ0QsQ0FBQztBQUUvRCxpQkFBaUI7QUFDakIsY0FBYyxpQ0FBaUMsQ0FBQztBQUVoRCwyQ0FBMkM7QUFDM0MsT0FBTyxFQUNMLFFBQVEsRUFDUixrQkFBa0IsRUFDbEIsbUJBQW1CLEVBQ25CLGdCQUFnQixFQUNqQixNQUFNLDhCQUE4QixDQUFDO0FBRXRDLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRztJQUNyQixRQUFRO0lBQ1Isa0JBQWtCO0lBQ2xCLG1CQUFtQjtJQUNuQixnQkFBZ0I7Q0FDakIsQ0FBQyJ9

package/dist_ts/http/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * HTTP functionality module
+ */
+export * from './models/http-types.js';
+export * from './port80/index.js';
+export * from './router/index.js';
+export * from './redirects/index.js';
+import { Port80Handler } from './port80/port80-handler.js';
+import { ChallengeResponder } from './port80/challenge-responder.js';
+export declare const Http: {
+    Port80: {
+        Handler: typeof Port80Handler;
+        ChallengeResponder: typeof ChallengeResponder;
+    };
+};

package/dist_ts/http/index.js

@@ -0,0 +1,20 @@
+/**
+ * HTTP functionality module
+ */
+// Export types and models
+export * from './models/http-types.js';
+// Export submodules
+export * from './port80/index.js';
+export * from './router/index.js';
+export * from './redirects/index.js';
+// Import the components we need for the namespace
+import { Port80Handler } from './port80/port80-handler.js';
+import { ChallengeResponder } from './port80/challenge-responder.js';
+// Convenience namespace exports
+export const Http = {
+    Port80: {
+        Handler: Port80Handler,
+        ChallengeResponder: ChallengeResponder
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9odHRwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsMEJBQTBCO0FBQzFCLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsb0JBQW9CO0FBQ3BCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLGtEQUFrRDtBQUNsRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFckUsZ0NBQWdDO0FBQ2hDLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRztJQUNsQixNQUFNLEVBQUU7UUFDTixPQUFPLEVBQUUsYUFBYTtRQUN0QixrQkFBa0IsRUFBRSxrQkFBa0I7S0FDdkM7Q0FDRixDQUFDIn0=

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

@@ -0,0 +1,81 @@
+import * as plugins from '../../plugins.js';
+import type { IDomainOptions } from '../../certificate/models/certificate-types.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,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    SERVICE_UNAVAILABLE = 503
+}
+/**
+ * Represents a domain configuration with certificate status information
+ */
+export interface IDomainCertificate {
+    options: IDomainOptions;
+    certObtained: boolean;
+    obtainingInProgress: boolean;
+    certificate?: string;
+    privateKey?: string;
+    expiryDate?: Date;
+    lastRenewalAttempt?: Date;
+}
+/**
+ * Base error class for HTTP-related errors
+ */
+export declare class HttpError extends Error {
+    constructor(message: string);
+}
+/**
+ * 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);
+}
+/**
+ * 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;
+        handler: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+    }>;
+    notFoundHandler?: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+}
+export { HttpError as Port80HandlerError };
+export { CertificateError as CertError };

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

@@ -0,0 +1,62 @@
+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["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+})(HttpStatus || (HttpStatus = {}));
+/**
+ * Base error class for HTTP-related errors
+ */
+export class HttpError extends Error {
+    constructor(message) {
+        super(message);
+        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)' : ''}`);
+        this.domain = domain;
+        this.isRenewal = isRenewal;
+        this.name = 'CertificateError';
+    }
+}
+/**
+ * Error related to server operations
+ */
+export class ServerError extends HttpError {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ServerError';
+    }
+}
+// Backward compatibility interfaces
+export { HttpError as Port80HandlerError };
+export { CertificateError as CertError };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2h0dHAvbW9kZWxzL2h0dHAtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQU81Qzs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLFVBS1g7QUFMRCxXQUFZLFVBQVU7SUFDcEIsbURBQXFDLENBQUE7SUFDckMscURBQXVDLENBQUE7SUFDdkMsaURBQW1DLENBQUE7SUFDbkMsNkNBQStCLENBQUE7QUFDakMsQ0FBQyxFQUxXLFVBQVUsS0FBVixVQUFVLFFBS3JCO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSxVQVlYO0FBWkQsV0FBWSxVQUFVO0lBQ3BCLHlDQUFRLENBQUE7SUFDUix1RUFBdUIsQ0FBQTtJQUN2QiwrQ0FBVyxDQUFBO0lBQ1gseUVBQXdCLENBQUE7SUFDeEIseUVBQXdCLENBQUE7SUFDeEIsMkRBQWlCLENBQUE7SUFDakIsdURBQWUsQ0FBQTtJQUNmLHlFQUF3QixDQUFBO0lBQ3hCLCtFQUEyQixDQUFBO0lBQzNCLG1FQUFxQixDQUFBO0lBQ3JCLDJFQUF5QixDQUFBO0FBQzNCLENBQUMsRUFaVyxVQUFVLEtBQVYsVUFBVSxRQVlyQjtBQWVEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFNBQVUsU0FBUSxLQUFLO0lBQ2xDLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLFdBQVcsQ0FBQztJQUMxQixDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxTQUFTO0lBQzdDLFlBQ0UsT0FBZSxFQUNDLE1BQWMsRUFDZCxZQUFxQixLQUFLO1FBRTFDLEtBQUssQ0FBQyxHQUFHLE9BQU8sZUFBZSxNQUFNLEdBQUcsU0FBUyxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFIekQsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUNkLGNBQVMsR0FBVCxTQUFTLENBQWlCO1FBRzFDLElBQUksQ0FBQyxJQUFJLEdBQUcsa0JBQWtCLENBQUM7SUFDakMsQ0FBQztDQUNGO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sV0FBWSxTQUFRLFNBQVM7SUFDeEMsWUFBWSxPQUFlLEVBQWtCLElBQWE7UUFDeEQsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBRDRCLFNBQUksR0FBSixJQUFJLENBQVM7UUFFeEQsSUFBSSxDQUFDLElBQUksR0FBRyxhQUFhLENBQUM7SUFDNUIsQ0FBQztDQUNGO0FBdUJELG9DQUFvQztBQUNwQyxPQUFPLEVBQUUsU0FBUyxJQUFJLGtCQUFrQixFQUFFLENBQUM7QUFDM0MsT0FBTyxFQUFFLGdCQUFnQixJQUFJLFNBQVMsRUFBRSxDQUFDIn0=

package/dist_ts/http/port80/acme-interfaces.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Type definitions for SmartAcme interfaces used by ChallengeResponder
+ * These reflect the actual SmartAcme API based on the documentation
+ */
+import * as plugins from '../../plugins.js';
+/**
+ * Structure for SmartAcme certificate result
+ */
+export interface ISmartAcmeCert {
+    id?: string;
+    domainName: string;
+    created?: number | Date | string;
+    privateKey: string;
+    publicKey: string;
+    csr?: string;
+    validUntil: number | Date | string;
+}
+/**
+ * Structure for SmartAcme options
+ */
+export interface ISmartAcmeOptions {
+    accountEmail: string;
+    certManager: ICertManager;
+    environment: 'production' | 'integration';
+    challengeHandlers: IChallengeHandler<any>[];
+    challengePriority?: string[];
+    retryOptions?: {
+        retries?: number;
+        factor?: number;
+        minTimeoutMs?: number;
+        maxTimeoutMs?: number;
+    };
+}
+/**
+ * Interface for certificate manager
+ */
+export interface ICertManager {
+    init(): Promise<void>;
+    get(domainName: string): Promise<ISmartAcmeCert | null>;
+    put(cert: ISmartAcmeCert): Promise<ISmartAcmeCert>;
+    delete(domainName: string): Promise<void>;
+    close?(): Promise<void>;
+}
+/**
+ * Interface for challenge handler
+ */
+export interface IChallengeHandler<T> {
+    getSupportedTypes(): string[];
+    prepare(ch: T): Promise<void>;
+    verify?(ch: T): Promise<void>;
+    cleanup(ch: T): Promise<void>;
+    checkWetherDomainIsSupported(domain: string): Promise<boolean>;
+}
+/**
+ * HTTP-01 challenge type
+ */
+export interface IHttp01Challenge {
+    type: string;
+    token: string;
+    keyAuthorization: string;
+    webPath: string;
+}
+/**
+ * HTTP-01 Memory Handler Interface
+ */
+export interface IHttp01MemoryHandler extends IChallengeHandler<IHttp01Challenge> {
+    handleRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse, next?: () => void): void;
+}
+/**
+ * SmartAcme main class interface
+ */
+export interface ISmartAcme {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getCertificateForDomain(domain: string): Promise<ISmartAcmeCert>;
+    on?(event: string, listener: (data: any) => void): void;
+    eventEmitter?: plugins.EventEmitter;
+}

package/dist_ts/http/port80/acme-interfaces.js

@@ -0,0 +1,6 @@
+/**
+ * Type definitions for SmartAcme interfaces used by ChallengeResponder
+ * These reflect the actual SmartAcme API based on the documentation
+ */
+import * as plugins from '../../plugins.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNtZS1pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaHR0cC9wb3J0ODAvYWNtZS1pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUMifQ==

package/dist_ts/http/port80/challenge-responder.d.ts

@@ -0,0 +1,53 @@
+import * as plugins from '../../plugins.js';
+import { IncomingMessage, ServerResponse } from 'http';
+import type { ICertificateData } from '../../certificate/models/certificate-types.js';
+/**
+ * ChallengeResponder handles ACME HTTP-01 challenges by leveraging SmartAcme
+ * It acts as a bridge between the HTTP server and the ACME challenge verification process
+ */
+export declare class ChallengeResponder extends plugins.EventEmitter {
+    private readonly useProduction;
+    private readonly email;
+    private readonly certificateStore;
+    private smartAcme;
+    private http01Handler;
+    /**
+     * Creates a new challenge responder
+     * @param useProduction Whether to use production ACME servers
+     * @param email Account email for ACME
+     * @param certificateStore Directory to store certificates
+     */
+    constructor(useProduction?: boolean, email?: string, certificateStore?: string);
+    /**
+     * Initialize the ACME client
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure the certificate store directory exists
+     */
+    private ensureCertificateStore;
+    /**
+     * Setup event listeners to forward SmartACME events to our own event emitter
+     */
+    private setupEventListeners;
+    /**
+     * Handle HTTP request by checking if it's an ACME challenge
+     * @param req HTTP request object
+     * @param res HTTP response object
+     * @returns true if the request was handled, false otherwise
+     */
+    handleRequest(req: IncomingMessage, res: ServerResponse): boolean;
+    /**
+     * Request a certificate for a domain
+     * @param domain Domain name to request a certificate for
+     * @param isRenewal Whether this is a renewal request
+     */
+    requestCertificate(domain: string, isRenewal?: boolean): Promise<ICertificateData>;
+    /**
+     * Check if a certificate is expiring soon and trigger renewal if needed
+     * @param domain Domain name
+     * @param certificate Certificate data
+     * @param thresholdDays Days before expiry to trigger renewal
+     */
+    checkCertificateExpiry(domain: string, certificate: ICertificateData, thresholdDays?: number): void;
+}