@push.rocks/smartproxy 3.10.4 → 3.12.0

package/dist_ts/classes.port80handler.js

@@ -0,0 +1,186 @@
+import * as http from 'http';
+import * as acme from 'acme-client';
+export class Port80Handler {
+    constructor() {
+        this.acmeClient = null;
+        this.accountKey = null;
+        this.domainCertificates = new Map();
+        // Create and start an HTTP server on port 80.
+        this.server = http.createServer((req, res) => this.handleRequest(req, res));
+        this.server.listen(80, () => {
+            console.log('Port80Handler is listening on port 80');
+        });
+    }
+    /**
+     * Adds a domain to be managed.
+     * @param domain The domain to add.
+     */
+    addDomain(domain) {
+        if (!this.domainCertificates.has(domain)) {
+            this.domainCertificates.set(domain, { certObtained: false, obtainingInProgress: false });
+            console.log(`Domain added: ${domain}`);
+        }
+    }
+    /**
+     * Removes a domain from management.
+     * @param domain The domain to remove.
+     */
+    removeDomain(domain) {
+        if (this.domainCertificates.delete(domain)) {
+            console.log(`Domain removed: ${domain}`);
+        }
+    }
+    /**
+     * Lazy initialization of the ACME client.
+     * Uses Let’s Encrypt’s production directory (for testing you might switch to staging).
+     */
+    async getAcmeClient() {
+        if (this.acmeClient) {
+            return this.acmeClient;
+        }
+        // Generate a new account key and convert Buffer to string.
+        this.accountKey = (await acme.forge.createPrivateKey()).toString();
+        this.acmeClient = new acme.Client({
+            directoryUrl: acme.directory.letsencrypt.production, // Use production for a real certificate
+            // For testing, you could use:
+            // directoryUrl: acme.directory.letsencrypt.staging,
+            accountKey: this.accountKey,
+        });
+        // Create a new account. Make sure to update the contact email.
+        await this.acmeClient.createAccount({
+            termsOfServiceAgreed: true,
+            contact: ['mailto:admin@example.com'],
+        });
+        return this.acmeClient;
+    }
+    /**
+     * Handles incoming HTTP requests on port 80.
+     * If the request is for an ACME challenge, it responds with the key authorization.
+     * If the domain has a certificate, it redirects to HTTPS; otherwise, it initiates certificate issuance.
+     */
+    handleRequest(req, res) {
+        const hostHeader = req.headers.host;
+        if (!hostHeader) {
+            res.statusCode = 400;
+            res.end('Bad Request: Host header is missing');
+            return;
+        }
+        // Extract domain (ignoring any port in the Host header)
+        const domain = hostHeader.split(':')[0];
+        // If the request is for an ACME HTTP-01 challenge, handle it.
+        if (req.url && req.url.startsWith('/.well-known/acme-challenge/')) {
+            this.handleAcmeChallenge(req, res, domain);
+            return;
+        }
+        if (!this.domainCertificates.has(domain)) {
+            res.statusCode = 404;
+            res.end('Domain not configured');
+            return;
+        }
+        const domainInfo = this.domainCertificates.get(domain);
+        // If certificate exists, redirect to HTTPS on port 443.
+        if (domainInfo.certObtained) {
+            const redirectUrl = `https://${domain}:443${req.url}`;
+            res.statusCode = 301;
+            res.setHeader('Location', redirectUrl);
+            res.end(`Redirecting to ${redirectUrl}`);
+        }
+        else {
+            // Trigger certificate issuance if not already running.
+            if (!domainInfo.obtainingInProgress) {
+                domainInfo.obtainingInProgress = true;
+                this.obtainCertificate(domain).catch(err => {
+                    console.error(`Error obtaining certificate for ${domain}:`, err);
+                });
+            }
+            res.statusCode = 503;
+            res.end('Certificate issuance in progress, please try again later.');
+        }
+    }
+    /**
+     * Serves the ACME HTTP-01 challenge response.
+     */
+    handleAcmeChallenge(req, res, domain) {
+        const domainInfo = this.domainCertificates.get(domain);
+        if (!domainInfo) {
+            res.statusCode = 404;
+            res.end('Domain not configured');
+            return;
+        }
+        // The token is the last part of the URL.
+        const urlParts = req.url?.split('/');
+        const token = urlParts ? urlParts[urlParts.length - 1] : '';
+        if (domainInfo.challengeToken === token && domainInfo.challengeKeyAuthorization) {
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end(domainInfo.challengeKeyAuthorization);
+            console.log(`Served ACME challenge response for ${domain}`);
+        }
+        else {
+            res.statusCode = 404;
+            res.end('Challenge token not found');
+        }
+    }
+    /**
+     * Uses acme-client to perform a full ACME HTTP-01 challenge to obtain a certificate.
+     * On success, it stores the certificate and key in memory and clears challenge data.
+     */
+    async obtainCertificate(domain) {
+        try {
+            const client = await this.getAcmeClient();
+            // Create a new order for the domain.
+            const order = await client.createOrder({
+                identifiers: [{ type: 'dns', value: domain }],
+            });
+            // Get the authorizations for the order.
+            const authorizations = await client.getAuthorizations(order);
+            for (const authz of authorizations) {
+                const challenge = authz.challenges.find(ch => ch.type === 'http-01');
+                if (!challenge) {
+                    throw new Error('HTTP-01 challenge not found');
+                }
+                // Get the key authorization for the challenge.
+                const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
+                const domainInfo = this.domainCertificates.get(domain);
+                domainInfo.challengeToken = challenge.token;
+                domainInfo.challengeKeyAuthorization = keyAuthorization;
+                // Notify the ACME server that the challenge is ready.
+                // The acme-client examples show that verifyChallenge takes three arguments:
+                // (authorization, challenge, keyAuthorization). However, the official TypeScript
+                // types appear to be out-of-sync. As a workaround, we cast client to 'any'.
+                await client.verifyChallenge(authz, challenge, keyAuthorization);
+                await client.completeChallenge(challenge);
+                // Wait until the challenge is validated.
+                await client.waitForValidStatus(challenge);
+                console.log(`HTTP-01 challenge completed for ${domain}`);
+            }
+            // Generate a CSR and a new private key for the domain.
+            // Convert the resulting Buffers to strings.
+            const [csrBuffer, privateKeyBuffer] = await acme.forge.createCsr({
+                commonName: domain,
+            });
+            const csr = csrBuffer.toString();
+            const privateKey = privateKeyBuffer.toString();
+            // Finalize the order and obtain the certificate.
+            await client.finalizeOrder(order, csr);
+            const certificate = await client.getCertificate(order);
+            const domainInfo = this.domainCertificates.get(domain);
+            domainInfo.certificate = certificate;
+            domainInfo.privateKey = privateKey;
+            domainInfo.certObtained = true;
+            domainInfo.obtainingInProgress = false;
+            delete domainInfo.challengeToken;
+            delete domainInfo.challengeKeyAuthorization;
+            console.log(`Certificate obtained for ${domain}`);
+            // In a production system, persist the certificate and key and reload your TLS server.
+        }
+        catch (error) {
+            console.error(`Error during certificate issuance for ${domain}:`, error);
+            const domainInfo = this.domainCertificates.get(domain);
+            if (domainInfo) {
+                domainInfo.obtainingInProgress = false;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.portproxy.d.ts

@@ -0,0 +1,26 @@
+import * as plugins from './plugins.js';
+export interface IDomainConfig {
+    domain: string;
+    allowedIPs: string[];
+    targetIP?: string;
+}
+export interface IPortProxySettings extends plugins.tls.TlsOptions {
+    fromPort: number;
+    toPort: number;
+    toHost?: string;
+    domains: IDomainConfig[];
+    sniEnabled?: boolean;
+    defaultAllowedIPs?: string[];
+    preserveSourceIP?: boolean;
+}
+export declare class PortProxy {
+    netServer: plugins.net.Server;
+    settings: IPortProxySettings;
+    private connectionRecords;
+    private connectionLogger;
+    private terminationStats;
+    constructor(settings: IPortProxySettings);
+    private incrementTerminationStat;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist_ts/classes.portproxy.js

@@ -0,0 +1,295 @@
+import * as plugins from './plugins.js';
+/**
+ * Extracts the SNI (Server Name Indication) from a TLS ClientHello packet.
+ * @param buffer - Buffer containing the TLS ClientHello.
+ * @returns The server name if found, otherwise undefined.
+ */
+function extractSNI(buffer) {
+    let offset = 0;
+    if (buffer.length < 5)
+        return undefined;
+    const recordType = buffer.readUInt8(0);
+    if (recordType !== 22)
+        return undefined; // 22 = handshake
+    const recordLength = buffer.readUInt16BE(3);
+    if (buffer.length < 5 + recordLength)
+        return undefined;
+    offset = 5;
+    const handshakeType = buffer.readUInt8(offset);
+    if (handshakeType !== 1)
+        return undefined; // 1 = ClientHello
+    offset += 4; // Skip handshake header (type + length)
+    offset += 2 + 32; // Skip client version and random
+    const sessionIDLength = buffer.readUInt8(offset);
+    offset += 1 + sessionIDLength; // Skip session ID
+    const cipherSuitesLength = buffer.readUInt16BE(offset);
+    offset += 2 + cipherSuitesLength; // Skip cipher suites
+    const compressionMethodsLength = buffer.readUInt8(offset);
+    offset += 1 + compressionMethodsLength; // Skip compression methods
+    if (offset + 2 > buffer.length)
+        return undefined;
+    const extensionsLength = buffer.readUInt16BE(offset);
+    offset += 2;
+    const extensionsEnd = offset + extensionsLength;
+    while (offset + 4 <= extensionsEnd) {
+        const extensionType = buffer.readUInt16BE(offset);
+        const extensionLength = buffer.readUInt16BE(offset + 2);
+        offset += 4;
+        if (extensionType === 0x0000) { // SNI extension
+            if (offset + 2 > buffer.length)
+                return undefined;
+            const sniListLength = buffer.readUInt16BE(offset);
+            offset += 2;
+            const sniListEnd = offset + sniListLength;
+            while (offset + 3 < sniListEnd) {
+                const nameType = buffer.readUInt8(offset++);
+                const nameLen = buffer.readUInt16BE(offset);
+                offset += 2;
+                if (nameType === 0) { // host_name
+                    if (offset + nameLen > buffer.length)
+                        return undefined;
+                    return buffer.toString('utf8', offset, offset + nameLen);
+                }
+                offset += nameLen;
+            }
+            break;
+        }
+        else {
+            offset += extensionLength;
+        }
+    }
+    return undefined;
+}
+export class PortProxy {
+    constructor(settings) {
+        // Unified record tracking each connection pair.
+        this.connectionRecords = new Set();
+        this.connectionLogger = null;
+        this.terminationStats = {
+            incoming: {},
+            outgoing: {},
+        };
+        this.settings = {
+            ...settings,
+            toHost: settings.toHost || 'localhost',
+        };
+    }
+    incrementTerminationStat(side, reason) {
+        this.terminationStats[side][reason] = (this.terminationStats[side][reason] || 0) + 1;
+    }
+    async start() {
+        // Helper to forcefully destroy sockets.
+        const cleanUpSockets = (socketA, socketB) => {
+            if (!socketA.destroyed)
+                socketA.destroy();
+            if (socketB && !socketB.destroyed)
+                socketB.destroy();
+        };
+        // Normalize an IP to include both IPv4 and IPv6 representations.
+        const normalizeIP = (ip) => {
+            if (ip.startsWith('::ffff:')) {
+                const ipv4 = ip.slice(7);
+                return [ip, ipv4];
+            }
+            if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
+                return [ip, `::ffff:${ip}`];
+            }
+            return [ip];
+        };
+        // Check if a given IP matches any of the glob patterns.
+        const isAllowed = (ip, patterns) => {
+            const normalizedIPVariants = normalizeIP(ip);
+            const expandedPatterns = patterns.flatMap(normalizeIP);
+            return normalizedIPVariants.some(ipVariant => expandedPatterns.some(pattern => plugins.minimatch(ipVariant, pattern)));
+        };
+        // Find a matching domain config based on the SNI.
+        const findMatchingDomain = (serverName) => this.settings.domains.find(config => plugins.minimatch(serverName, config.domain));
+        this.netServer = plugins.net.createServer((socket) => {
+            const remoteIP = socket.remoteAddress || '';
+            const connectionRecord = {
+                incoming: socket,
+                outgoing: null,
+                incomingStartTime: Date.now(),
+                connectionClosed: false,
+            };
+            this.connectionRecords.add(connectionRecord);
+            console.log(`New connection from ${remoteIP}. Active connections: ${this.connectionRecords.size}`);
+            let initialDataReceived = false;
+            let incomingTerminationReason = null;
+            let outgoingTerminationReason = null;
+            // Ensure cleanup happens only once for the entire connection record.
+            const cleanupOnce = () => {
+                if (!connectionRecord.connectionClosed) {
+                    connectionRecord.connectionClosed = true;
+                    cleanUpSockets(connectionRecord.incoming, connectionRecord.outgoing || undefined);
+                    this.connectionRecords.delete(connectionRecord);
+                    console.log(`Connection from ${remoteIP} terminated. Active connections: ${this.connectionRecords.size}`);
+                }
+            };
+            // Helper to reject an incoming connection.
+            const rejectIncomingConnection = (reason, logMessage) => {
+                console.log(logMessage);
+                socket.end();
+                if (incomingTerminationReason === null) {
+                    incomingTerminationReason = reason;
+                    this.incrementTerminationStat('incoming', reason);
+                }
+                cleanupOnce();
+            };
+            socket.on('error', (err) => {
+                const errorMessage = initialDataReceived
+                    ? `(Immediate) Incoming socket error from ${remoteIP}: ${err.message}`
+                    : `(Premature) Incoming socket error from ${remoteIP} before data received: ${err.message}`;
+                console.log(errorMessage);
+            });
+            const handleError = (side) => (err) => {
+                const code = err.code;
+                let reason = 'error';
+                if (code === 'ECONNRESET') {
+                    reason = 'econnreset';
+                    console.log(`ECONNRESET on ${side} side from ${remoteIP}: ${err.message}`);
+                }
+                else {
+                    console.log(`Error on ${side} side from ${remoteIP}: ${err.message}`);
+                }
+                if (side === 'incoming' && incomingTerminationReason === null) {
+                    incomingTerminationReason = reason;
+                    this.incrementTerminationStat('incoming', reason);
+                }
+                else if (side === 'outgoing' && outgoingTerminationReason === null) {
+                    outgoingTerminationReason = reason;
+                    this.incrementTerminationStat('outgoing', reason);
+                }
+                cleanupOnce();
+            };
+            const handleClose = (side) => () => {
+                console.log(`Connection closed on ${side} side from ${remoteIP}`);
+                if (side === 'incoming' && incomingTerminationReason === null) {
+                    incomingTerminationReason = 'normal';
+                    this.incrementTerminationStat('incoming', 'normal');
+                }
+                else if (side === 'outgoing' && outgoingTerminationReason === null) {
+                    outgoingTerminationReason = 'normal';
+                    this.incrementTerminationStat('outgoing', 'normal');
+                }
+                cleanupOnce();
+            };
+            const setupConnection = (serverName, initialChunk) => {
+                const defaultAllowed = this.settings.defaultAllowedIPs && isAllowed(remoteIP, this.settings.defaultAllowedIPs);
+                if (!defaultAllowed && serverName) {
+                    const domainConfig = findMatchingDomain(serverName);
+                    if (!domainConfig) {
+                        return rejectIncomingConnection('rejected', `Connection rejected: No matching domain config for ${serverName} from ${remoteIP}`);
+                    }
+                    if (!isAllowed(remoteIP, domainConfig.allowedIPs)) {
+                        return rejectIncomingConnection('rejected', `Connection rejected: IP ${remoteIP} not allowed for domain ${serverName}`);
+                    }
+                }
+                else if (!defaultAllowed && !serverName) {
+                    return rejectIncomingConnection('rejected', `Connection rejected: No SNI and IP ${remoteIP} not in default allowed list`);
+                }
+                else if (defaultAllowed && !serverName) {
+                    console.log(`Connection allowed: IP ${remoteIP} is in default allowed list`);
+                }
+                const domainConfig = serverName ? findMatchingDomain(serverName) : undefined;
+                const targetHost = domainConfig?.targetIP || this.settings.toHost;
+                const connectionOptions = {
+                    host: targetHost,
+                    port: this.settings.toPort,
+                };
+                if (this.settings.preserveSourceIP) {
+                    connectionOptions.localAddress = remoteIP.replace('::ffff:', '');
+                }
+                const targetSocket = plugins.net.connect(connectionOptions);
+                connectionRecord.outgoing = targetSocket;
+                connectionRecord.outgoingStartTime = Date.now();
+                console.log(`Connection established: ${remoteIP} -> ${targetHost}:${this.settings.toPort}` +
+                    `${serverName ? ` (SNI: ${serverName})` : ''}`);
+                if (initialChunk) {
+                    socket.unshift(initialChunk);
+                }
+                socket.setTimeout(120000);
+                socket.pipe(targetSocket);
+                targetSocket.pipe(socket);
+                socket.on('error', handleError('incoming'));
+                targetSocket.on('error', handleError('outgoing'));
+                socket.on('close', handleClose('incoming'));
+                targetSocket.on('close', handleClose('outgoing'));
+                socket.on('timeout', () => {
+                    console.log(`Timeout on incoming side from ${remoteIP}`);
+                    if (incomingTerminationReason === null) {
+                        incomingTerminationReason = 'timeout';
+                        this.incrementTerminationStat('incoming', 'timeout');
+                    }
+                    cleanupOnce();
+                });
+                targetSocket.on('timeout', () => {
+                    console.log(`Timeout on outgoing side from ${remoteIP}`);
+                    if (outgoingTerminationReason === null) {
+                        outgoingTerminationReason = 'timeout';
+                        this.incrementTerminationStat('outgoing', 'timeout');
+                    }
+                    cleanupOnce();
+                });
+                socket.on('end', handleClose('incoming'));
+                targetSocket.on('end', handleClose('outgoing'));
+            };
+            if (this.settings.sniEnabled) {
+                socket.setTimeout(5000, () => {
+                    console.log(`Initial data timeout for ${remoteIP}`);
+                    socket.end();
+                    cleanupOnce();
+                });
+                socket.once('data', (chunk) => {
+                    socket.setTimeout(0);
+                    initialDataReceived = true;
+                    const serverName = extractSNI(chunk) || '';
+                    console.log(`Received connection from ${remoteIP} with SNI: ${serverName}`);
+                    setupConnection(serverName, chunk);
+                });
+            }
+            else {
+                initialDataReceived = true;
+                if (!this.settings.defaultAllowedIPs || !isAllowed(remoteIP, this.settings.defaultAllowedIPs)) {
+                    return rejectIncomingConnection('rejected', `Connection rejected: IP ${remoteIP} not allowed for non-SNI connection`);
+                }
+                setupConnection('');
+            }
+        })
+            .on('error', (err) => {
+            console.log(`Server Error: ${err.message}`);
+        })
+            .listen(this.settings.fromPort, () => {
+            console.log(`PortProxy -> OK: Now listening on port ${this.settings.fromPort}` +
+                `${this.settings.sniEnabled ? ' (SNI passthrough enabled)' : ''}`);
+        });
+        // Every 10 seconds log active connection count and longest running durations.
+        this.connectionLogger = setInterval(() => {
+            const now = Date.now();
+            let maxIncoming = 0;
+            let maxOutgoing = 0;
+            for (const record of this.connectionRecords) {
+                maxIncoming = Math.max(maxIncoming, now - record.incomingStartTime);
+                if (record.outgoingStartTime) {
+                    maxOutgoing = Math.max(maxOutgoing, now - record.outgoingStartTime);
+                }
+            }
+            console.log(`(Interval Log) Active connections: ${this.connectionRecords.size}. ` +
+                `Longest running incoming: ${plugins.prettyMs(maxIncoming)}, outgoing: ${plugins.prettyMs(maxOutgoing)}. ` +
+                `Termination stats (incoming): ${JSON.stringify(this.terminationStats.incoming)}, ` +
+                `(outgoing): ${JSON.stringify(this.terminationStats.outgoing)}`);
+        }, 10000);
+    }
+    async stop() {
+        const done = plugins.smartpromise.defer();
+        this.netServer.close(() => {
+            done.resolve();
+        });
+        if (this.connectionLogger) {
+            clearInterval(this.connectionLogger);
+            this.connectionLogger = null;
+        }
+        await done.promise;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.portproxy.js","sourceRoot":"","sources":["../ts/classes.portproxy.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.router.d.ts

@@ -0,0 +1,13 @@
+import * as plugins from './plugins.js';
+export declare class ProxyRouter {
+    reverseProxyConfigs: plugins.tsclass.network.IReverseProxyConfig[];
+    /**
+     * sets a new set of reverse configs to be routed to
+     * @param reverseCandidatesArg
+     */
+    setNewProxyConfigs(reverseCandidatesArg: plugins.tsclass.network.IReverseProxyConfig[]): void;
+    /**
+     * routes a request
+     */
+    routeReq(req: plugins.http.IncomingMessage): plugins.tsclass.network.IReverseProxyConfig;
+}

package/dist_ts/classes.router.js

@@ -0,0 +1,33 @@
+import * as plugins from './plugins.js';
+export class ProxyRouter {
+    constructor() {
+        this.reverseProxyConfigs = [];
+    }
+    /**
+     * sets a new set of reverse configs to be routed to
+     * @param reverseCandidatesArg
+     */
+    setNewProxyConfigs(reverseCandidatesArg) {
+        this.reverseProxyConfigs = reverseCandidatesArg;
+    }
+    /**
+     * routes a request
+     */
+    routeReq(req) {
+        const originalHost = req.headers.host;
+        if (!originalHost) {
+            console.error('No host header found in request');
+            return undefined;
+        }
+        // Strip port from host if present
+        const hostWithoutPort = originalHost.split(':')[0];
+        const correspodingReverseProxyConfig = this.reverseProxyConfigs.find((reverseConfig) => {
+            return reverseConfig.hostName === hostWithoutPort;
+        });
+        if (!correspodingReverseProxyConfig) {
+            console.error(`No config found for host: ${hostWithoutPort}`);
+        }
+        return correspodingReverseProxyConfig;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5yb3V0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLnJvdXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLE9BQU8sV0FBVztJQUF4QjtRQUNTLHdCQUFtQixHQUFrRCxFQUFFLENBQUM7SUE2QmpGLENBQUM7SUEzQkM7OztPQUdHO0lBQ0ksa0JBQWtCLENBQUMsb0JBQW1FO1FBQzNGLElBQUksQ0FBQyxtQkFBbUIsR0FBRyxvQkFBb0IsQ0FBQztJQUNsRCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxRQUFRLENBQUMsR0FBaUM7UUFDL0MsTUFBTSxZQUFZLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7UUFDdEMsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ2xCLE9BQU8sQ0FBQyxLQUFLLENBQUMsaUNBQWlDLENBQUMsQ0FBQztZQUNqRCxPQUFPLFNBQVMsQ0FBQztRQUNuQixDQUFDO1FBQ0Qsa0NBQWtDO1FBQ2xDLE1BQU0sZUFBZSxHQUFHLFlBQVksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDbkQsTUFBTSw4QkFBOEIsR0FBRyxJQUFJLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLENBQUMsYUFBYSxFQUFFLEVBQUU7WUFDckYsT0FBTyxhQUFhLENBQUMsUUFBUSxLQUFLLGVBQWUsQ0FBQztRQUNwRCxDQUFDLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyw4QkFBOEIsRUFBRSxDQUFDO1lBQ3BDLE9BQU8sQ0FBQyxLQUFLLENBQUMsNkJBQTZCLGVBQWUsRUFBRSxDQUFDLENBQUM7UUFDaEUsQ0FBQztRQUNELE9BQU8sOEJBQThCLENBQUM7SUFDeEMsQ0FBQztDQUNGIn0=

package/dist_ts/classes.sslredirect.d.ts

@@ -0,0 +1,8 @@
+import * as plugins from './plugins.js';
+export declare class SslRedirect {
+    httpServer: plugins.http.Server;
+    port: number;
+    constructor(portArg: number);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist_ts/classes.sslredirect.js

@@ -0,0 +1,28 @@
+import * as plugins from './plugins.js';
+export class SslRedirect {
+    constructor(portArg) {
+        this.port = portArg;
+    }
+    async start() {
+        this.httpServer = plugins.http.createServer((request, response) => {
+            const requestUrl = new URL(request.url, `http://${request.headers.host}`);
+            const completeUrlWithoutProtocol = `${requestUrl.host}${requestUrl.pathname}${requestUrl.search}`;
+            const redirectUrl = `https://${completeUrlWithoutProtocol}`;
+            console.log(`Got http request for http://${completeUrlWithoutProtocol}`);
+            console.log(`Redirecting to ${redirectUrl}`);
+            response.writeHead(302, {
+                Location: redirectUrl,
+            });
+            response.end();
+        });
+        this.httpServer.listen(this.port);
+    }
+    async stop() {
+        const done = plugins.smartpromise.defer();
+        this.httpServer.close(() => {
+            done.resolve();
+        });
+        await done.promise;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zc2xyZWRpcmVjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMuc3NscmVkaXJlY3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFFeEMsTUFBTSxPQUFPLFdBQVc7SUFHdEIsWUFBWSxPQUFlO1FBQ3pCLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDO0lBQ3RCLENBQUM7SUFFTSxLQUFLLENBQUMsS0FBSztRQUNoQixJQUFJLENBQUMsVUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFO1lBQ2hFLE1BQU0sVUFBVSxHQUFHLElBQUksR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsVUFBVSxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7WUFDMUUsTUFBTSwwQkFBMEIsR0FBRyxHQUFHLFVBQVUsQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLFFBQVEsR0FBRyxVQUFVLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDbEcsTUFBTSxXQUFXLEdBQUcsV0FBVywwQkFBMEIsRUFBRSxDQUFDO1lBQzVELE9BQU8sQ0FBQyxHQUFHLENBQUMsK0JBQStCLDBCQUEwQixFQUFFLENBQUMsQ0FBQztZQUN6RSxPQUFPLENBQUMsR0FBRyxDQUFDLGtCQUFrQixXQUFXLEVBQUUsQ0FBQyxDQUFDO1lBQzdDLFFBQVEsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFO2dCQUN0QixRQUFRLEVBQUUsV0FBVzthQUN0QixDQUFDLENBQUM7WUFDSCxRQUFRLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDakIsQ0FBQyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUVNLEtBQUssQ0FBQyxJQUFJO1FBQ2YsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMxQyxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUU7WUFDekIsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2pCLENBQUMsQ0FBQyxDQUFDO1FBQ0gsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3JCLENBQUM7Q0FDRiJ9

package/dist_ts/helpers.certificates.d.ts

@@ -0,0 +1,5 @@
+export interface ICertificates {
+    privateKey: string;
+    publicKey: string;
+}
+export declare function loadDefaultCertificates(): ICertificates;