bdy 1.14.1-dev → 1.14.2-dev

package/distTs/src/tunnel.js

@@ -1,656 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const basic_auth_1 = __importDefault(require("basic-auth"));
-const utils_1 = require("./utils");
-const latency_1 = __importDefault(require("./tunnel/latency"));
-const client_1 = __importDefault(require("./ssh/client"));
-const events_1 = __importDefault(require("events"));
-const tcp_1 = __importDefault(require("./tunnel/tcp"));
-const tls_1 = __importDefault(require("./server/tls"));
-const ssh_1 = __importDefault(require("./server/ssh"));
-const logger_1 = __importDefault(require("./logger"));
-const identification_1 = __importDefault(require("./tunnel/identification"));
-const http_1 = __importDefault(require("./tunnel/http"));
-const http2_1 = __importDefault(require("./server/http2"));
-const http1_1 = __importDefault(require("./server/http1"));
-const log_1 = __importDefault(require("./tunnel/http/log"));
-const format_1 = __importDefault(require("./format"));
-const texts_js_1 = require("./texts.js");
-const dns_js_1 = __importDefault(require("./tunnel/dns.js"));
-class Tunnel extends events_1.default {
-    constructor({ agent, id, type, target, region, timeout, domain, customDomain, name, subdomain, whitelist, tlsSettings, httpSettings, sshSettings, sshHostKey, }) {
-        super();
-        if (!sshHostKey)
-            sshHostKey = (0, utils_1.createSshHostKey)();
-        this.agent = agent;
-        this.id = id;
-        this.sshHostKey = sshHostKey;
-        this.create({
-            type,
-            target,
-            region,
-            timeout,
-            domain,
-            customDomain,
-            subdomain,
-            name,
-            whitelist,
-            tlsSettings,
-            httpSettings,
-            sshSettings,
-        });
-    }
-    create({ type, target, region, timeout, domain, customDomain, subdomain, name, whitelist, tlsSettings, httpSettings, sshSettings, }) {
-        this.type = type;
-        this.region = region;
-        this.target = target;
-        this.whitelist = whitelist || [];
-        this.domain = domain;
-        this.customDomain = !!customDomain;
-        this.subdomain = subdomain;
-        this.name = name;
-        this.timeout = timeout || utils_1.DEFAULT_TIMEOUT;
-        this.useragents = [];
-        this.headers = [];
-        this.responseHeaders = [];
-        if (tlsSettings) {
-            this.terminate = tlsSettings.terminate;
-            this.key = tlsSettings.key;
-            this.cert = tlsSettings.cert;
-            this.ca = tlsSettings.ca;
-        }
-        if (httpSettings) {
-            this.host = httpSettings.host;
-            this.login = httpSettings.login;
-            this.password = httpSettings.password;
-            this.ca = httpSettings.ca;
-            this.serve = httpSettings.serve;
-            this.useragents = httpSettings.userAgents || [];
-            this.headers = httpSettings.headers || [];
-            this.responseHeaders = httpSettings.responseHeaders || [];
-            this.circuitBreaker = httpSettings.circuitBreaker;
-            this.log = httpSettings.log;
-            this.verify = httpSettings.verify;
-            this.compression = httpSettings.compression;
-            this.http2 = httpSettings.http2;
-        }
-        if (sshSettings) {
-            this.sshIp = sshSettings.ip;
-            this.sshId = sshSettings.sshId;
-            this.sshPort = sshSettings.port;
-            this.sshUser = sshSettings.user;
-            this.sshPassword = sshSettings.password;
-            this.sshForwardPort = sshSettings.forwardPort;
-            this.sshClientUser = sshSettings.clientUser;
-            this.sshClientPassword = sshSettings.clientPassword;
-        }
-        this.targetProto = 'http';
-        this.targetHost = 'localhost';
-        this.targetPort = 80;
-        this.targetAuth = null;
-        if (this.type === utils_1.TUNNEL_HTTP) {
-            let m = this.target.match(utils_1.TARGET_ONLY_PORT_REGEX);
-            if (m) {
-                this.targetPort = parseInt(m[0], 10);
-            }
-            else {
-                m = this.target.match(utils_1.TARGET_HTTP_REGEX);
-                if (m) {
-                    if (m[2])
-                        this.targetProto = m[2];
-                    if (m[6])
-                        this.targetPort = parseInt(m[6], 10);
-                    else if (this.targetProto === 'https')
-                        this.targetPort = 443;
-                    if (m[4])
-                        this.targetHost = m[4];
-                    if (m[3])
-                        this.targetAuth = m[3].replace(/@$/, '');
-                }
-            }
-        }
-        else if (this.type === utils_1.TUNNEL_SSH) {
-            this.targetHost = 'localhost';
-            this.targetProto = 'ssh://';
-            this.targetPort = 22;
-        }
-        else {
-            const m = this.target.match(utils_1.TARGET_TCP_TLS_REGEX);
-            if (m) {
-                this.targetPort = parseInt(m[3], 10);
-                if (m[2])
-                    this.targetHost = m[2];
-            }
-        }
-        this.connections = {};
-        this.totalConnections = 0;
-        this.status = utils_1.TUNNEL_CLOSED;
-        this.dns = null;
-        this.regionLatency = null;
-        this.targetLatency = null;
-        this.tls = null;
-        this.httpLog = null;
-        this.identify = null;
-        this.http2server = null;
-        this.http1server = null;
-        this.sshServer = null;
-        this.ssh = null;
-        this.started = false;
-    }
-    recreate({ type, target, region, timeout, domain, customDomain, subdomain, name, whitelist, tlsSettings, httpSettings, sshSettings, }) {
-        const started = this.started;
-        this.stop(false);
-        this.create({
-            type,
-            target,
-            region,
-            timeout,
-            domain,
-            customDomain,
-            subdomain,
-            name,
-            whitelist,
-            tlsSettings,
-            httpSettings,
-            sshSettings,
-        });
-        if (started)
-            this.start();
-    }
-    hasChanged(data) {
-        const tunnel = new Tunnel({
-            ...data,
-            sshHostKey: this.sshHostKey,
-        });
-        if (this.type !== tunnel.type)
-            return true;
-        if (this.target !== tunnel.target)
-            return true;
-        if (this.region !== tunnel.region)
-            return true;
-        if (this.timeout !== tunnel.timeout)
-            return true;
-        if (this.domain !== tunnel.domain)
-            return true;
-        if (this.subdomain !== tunnel.subdomain)
-            return true;
-        if (this.terminate !== tunnel.terminate)
-            return true;
-        if (this.key !== tunnel.key)
-            return true;
-        if (this.cert !== tunnel.cert)
-            return true;
-        if (this.ca !== tunnel.ca)
-            return true;
-        if (this.host !== tunnel.host)
-            return true;
-        if (this.login !== tunnel.login)
-            return true;
-        if (this.password !== tunnel.password)
-            return true;
-        if (this.serve !== tunnel.serve)
-            return true;
-        if (this.circuitBreaker !== tunnel.circuitBreaker)
-            return true;
-        if (this.log !== tunnel.log)
-            return true;
-        if (this.verify !== tunnel.verify)
-            return true;
-        if (this.http2 !== tunnel.http2)
-            return true;
-        if (this.compression !== tunnel.compression)
-            return true;
-        if (this.sshIp !== tunnel.sshIp)
-            return true;
-        if (this.sshId !== tunnel.sshId)
-            return true;
-        if (this.sshPort !== tunnel.sshPort)
-            return true;
-        if (this.sshUser !== tunnel.sshUser)
-            return true;
-        if (this.sshPassword !== tunnel.sshPassword)
-            return true;
-        if (this.sshForwardPort !== tunnel.sshForwardPort)
-            return true;
-        if (this.sshClientPassword !== tunnel.sshClientPassword)
-            return true;
-        if (this.sshClientUser !== tunnel.sshClientUser)
-            return true;
-        if (this.whitelist.length !== tunnel.whitelist.length)
-            return true;
-        this.whitelist.sort();
-        tunnel.whitelist.sort();
-        for (let i = 0; i < this.whitelist.length; i += 1) {
-            if (this.whitelist[i] !== tunnel.whitelist[i])
-                return true;
-        }
-        if (this.useragents.length !== tunnel.useragents.length)
-            return true;
-        this.useragents.sort();
-        tunnel.useragents.sort();
-        for (let i = 0; i < this.useragents.length; i += 1) {
-            if (this.useragents[i] !== tunnel.useragents[i])
-                return true;
-        }
-        const sortHeaders = (a, b) => a.name.localeCompare(b.name);
-        if (this.headers.length !== tunnel.headers.length)
-            return true;
-        this.headers.sort(sortHeaders);
-        tunnel.headers.sort(sortHeaders);
-        for (let i = 0; i < this.headers.length; i += 1) {
-            const thisH = this.headers[i];
-            const tunnelH = tunnel.headers[i];
-            if (thisH.name !== tunnelH.name)
-                return true;
-            if (thisH.value !== tunnelH.value)
-                return true;
-        }
-        if (this.responseHeaders.length !== tunnel.responseHeaders.length)
-            return true;
-        this.responseHeaders.sort(sortHeaders);
-        tunnel.responseHeaders.sort(sortHeaders);
-        for (let i = 0; i < this.responseHeaders.length; i += 1) {
-            const thisRH = this.responseHeaders[i];
-            const tunnelRH = tunnel.responseHeaders[i];
-            if (thisRH.name !== tunnelRH.name)
-                return true;
-            if (thisRH.value !== tunnelRH.value)
-                return true;
-        }
-        return false;
-    }
-    async sshConnected() {
-        try {
-            logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_CONNECTED)(this.id, this.sshForwardPort));
-            await this.ssh.forwardIn(this.sshForwardPort);
-            this.status = utils_1.TUNNEL_OPEN;
-        }
-        catch (err) {
-            // reconnect
-            logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_FAILED)(this.id));
-            logger_1.default.debug(err);
-            this.ssh.close();
-            return;
-        }
-        this.emit(utils_1.TUNNEL_EVENT_OPEN, this);
-    }
-    sshDisconnected() {
-        if (this.status !== utils_1.TUNNEL_CLOSED) {
-            logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_DISCONNECTED)(this.id));
-            this.status = utils_1.TUNNEL_CLOSED;
-            this.emit(utils_1.TUNNEL_EVENT_CLOSED, this);
-        }
-    }
-    tunnelToTarget(stream, onClose) {
-        this.totalConnections += 1;
-        const tcp = new tcp_1.default(this.targetHost, this.targetPort, stream);
-        this.connections[tcp.id] = tcp;
-        tcp.on(utils_1.TCP_EVENT_CLOSED, () => {
-            this.connections[tcp.id].removeAllListeners();
-            delete this.connections[tcp.id];
-            onClose();
-        });
-        tcp.pipe();
-    }
-    httpIdentified(type) {
-        logger_1.default.info((0, texts_js_1.LOG_TUNNEL_IDENTIFIED)(this.id, type));
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, this, type);
-    }
-    httpConnectionOpen(s) {
-        this.totalConnections += 1;
-        this.connections[s.id] = s;
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_OPEN, this);
-    }
-    httpConnectionClosed(s) {
-        delete this.connections[s.id];
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_CLOSED, this);
-    }
-    httpBasicAuth(req, res) {
-        if (this.login || this.password) {
-            const user = (0, basic_auth_1.default)(req);
-            if (!user || user.name !== this.login || user.pass !== this.password) {
-                logger_1.default.debug(texts_js_1.LOG_TUNNEL_HTTP_WRON_AUTH);
-                this.httpEndFast(req, res, 401, 'Unauthorised', {
-                    'WWW-Authenticate': 'Basic real="Buddy"',
-                });
-                return false;
-            }
-        }
-        return true;
-    }
-    httpEndFast(req, res, statusCode, msg, headers = {}) {
-        const log = this.httpLog.newRequest(req.method, req.headers, req.url, req.httpVersion, req);
-        if (!log) {
-            this.httpLog.newResponse(req, statusCode, headers);
-            res.statusCode = statusCode;
-            Object.keys(headers).forEach((k) => {
-                res.setHeader(k, headers[k]);
-            });
-            res.end(msg);
-        }
-        else {
-            req.pipe(log.requestBody);
-            log.requestBody.pipeToNothing(() => {
-                this.httpLog.newResponse(req, statusCode, headers, log);
-                res.statusCode = statusCode;
-                Object.keys(headers).forEach((k) => {
-                    res.setHeader(k, headers[k]);
-                });
-                res.end(msg);
-            });
-        }
-    }
-    httpRateLimit(req, res) {
-        const isRateLimited = this.httpLog.isRateLimited(req);
-        if (isRateLimited) {
-            logger_1.default.debug(texts_js_1.LOG_TUNNEL_HTTP_RATE_LIMIT);
-            this.httpEndFast(req, res, 429, 'Too Many Requests', {
-                'Retry-After': '60',
-            });
-            return false;
-        }
-        return true;
-    }
-    httpCircuitBreaker(req, res) {
-        const isOpen = this.httpLog.isCircuitBreakerOpen();
-        if (isOpen) {
-            logger_1.default.debug(texts_js_1.LOG_TUNNEL_HTTP_CIRCUIT_BREAKER_OPEN);
-            this.httpEndFast(req, res, 504, 'Service Unavailable', {});
-            return false;
-        }
-        return true;
-    }
-    httpUserAgent(req, res) {
-        if (this.useragents && this.useragents.length > 0) {
-            const ua = req.headers['user-agent'] || '';
-            for (let i = 0; i < this.useragents.length; i += 1) {
-                const str = this.useragents[i];
-                if ((0, utils_1.isStringRegExp)(str)) {
-                    try {
-                        const r = new RegExp(str, 'i');
-                        if (r.test(ua))
-                            return true;
-                    }
-                    catch {
-                        // do nothing
-                    }
-                }
-                else if (ua.includes(str)) {
-                    return true;
-                }
-            }
-            logger_1.default.debug(texts_js_1.LOG_TUNNEL_HTTP_WRONG_USER_AGENTS);
-            this.httpEndFast(req, res, 401, 'Unauthorised', {});
-            return false;
-        }
-        return true;
-    }
-    targetReconnected() {
-        if (this.identify)
-            this.identify.identify();
-    }
-    httpLogRequest(logRequest) {
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_REQUEST, this, logRequest);
-    }
-    httpLogResponse(logRequest) {
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_RESPONSE, this, logRequest);
-    }
-    retryHttpLogRequest(logRequest) {
-        if (logRequest.requestBody.tooLarge)
-            return;
-        if (logRequest.httpVersion === '2.0')
-            return this.http2server.retryRequest(logRequest);
-        return this.http1server.retryRequest(logRequest);
-    }
-    httpRequest(req, res) {
-        const isAuth = this.httpBasicAuth(req, res) &&
-            this.httpUserAgent(req, res) &&
-            this.httpRateLimit(req, res) &&
-            this.httpCircuitBreaker(req, res);
-        if (!isAuth)
-            return;
-        const http = new http_1.default({
-            req,
-            res,
-            auth: this.targetAuth,
-            proto: this.targetProto,
-            host: this.targetHost,
-            port: this.targetPort,
-            hostHeader: this.host,
-            timeout: this.timeout,
-            verify: this.verify,
-            compression: this.compression,
-            headers: this.headers,
-            serve: this.serve,
-            responseHeaders: this.responseHeaders,
-            httpIdentify: this.identify.type,
-            httpLog: this.httpLog,
-        });
-        http.once(utils_1.HTTP1_SOCKET_CLOSED, (socket) => this.httpConnectionClosed(socket));
-        http.pipe().then();
-    }
-    tlsSocket(tlsSocket) {
-        this.tunnelToTarget(tlsSocket, () => {
-            this.emit(utils_1.TUNNEL_EVENT_TLS_CLOSED, this);
-        });
-        this.emit(utils_1.TUNNEL_EVENT_TLS_OPEN, this);
-    }
-    canStreamTcp() {
-        if (this.type === utils_1.TUNNEL_TCP)
-            return true;
-        return (this.type === utils_1.TUNNEL_TLS &&
-            [utils_1.TLS_TERMINATE_AT_TARGET, utils_1.TLS_TERMINATE_AT_REGION].includes(this.terminate));
-    }
-    canStreamTls() {
-        return this.type === utils_1.TUNNEL_TLS;
-    }
-    canStreamSsh() {
-        return this.type === utils_1.TUNNEL_SSH;
-    }
-    canStreamHttp() {
-        return this.type === utils_1.TUNNEL_HTTP;
-    }
-    safeEndStream(stream) {
-        try {
-            stream.removeAllListeners();
-            stream.once('error', () => { });
-            stream.end();
-        }
-        catch {
-            // do nothing
-        }
-        setTimeout(() => {
-            try {
-                stream.destroy();
-            }
-            catch {
-                // do nothing
-            }
-        }, 1000);
-    }
-    sshStreamTcp(stream) {
-        if (!this.canStreamTcp()) {
-            this.safeEndStream(stream);
-            return;
-        }
-        logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_TCP_STREAM)(this.id));
-        this.tunnelToTarget(stream, () => {
-            this.emit(utils_1.TUNNEL_EVENT_TCP_CLOSED, this);
-        });
-        this.emit(utils_1.TUNNEL_EVENT_TCP_OPEN, this);
-    }
-    sshStreamHttp1(stream, info, ip) {
-        if (!this.canStreamHttp()) {
-            this.safeEndStream(stream);
-            return;
-        }
-        logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_HTTP1_STREAM)(this.id));
-        if (this.http1server) {
-            this.http1server.handleSshTunnel(stream, info, ip);
-            return;
-        }
-        this.safeEndStream(stream);
-    }
-    sshStreamHttp2(stream, info, ip) {
-        if (!this.canStreamHttp()) {
-            this.safeEndStream(stream);
-            return;
-        }
-        logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_HTTP2_STREAM)(this.id));
-        if (this.http2server) {
-            this.http2server.handleSshTunnel(stream, info, ip);
-            return;
-        }
-        this.safeEndStream(stream);
-    }
-    sshStreamSsh(stream) {
-        if (!this.canStreamSsh()) {
-            this.safeEndStream(stream);
-            return;
-        }
-        logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_SSH_STREAM)(this.id));
-        if (this.sshServer) {
-            this.sshServer.handleSshTunnel(stream);
-            return;
-        }
-        this.safeEndStream(stream);
-    }
-    sshStreamTls(stream) {
-        if (!this.canStreamTls()) {
-            this.safeEndStream(stream);
-            return;
-        }
-        if (this.terminate === utils_1.TLS_TERMINATE_AT_TARGET) {
-            logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_TLS_TARGET_STREAM)(this.id));
-            this.sshStreamTcp(stream);
-            return;
-        }
-        if (this.terminate === utils_1.TLS_TERMINATE_AT_REGION) {
-            logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_TLS_REGION_STREAM)(this.id));
-            this.sshStreamTcp(stream);
-            return;
-        }
-        if (this.tls) {
-            logger_1.default.debug((0, texts_js_1.LOG_TUNNEL_TLS_AGENT_STREAM)(this.id));
-            this.tls.handleSshTunnel(stream);
-            return;
-        }
-        this.safeEndStream(stream);
-    }
-    start() {
-        if (this.started)
-            return;
-        this.started = true;
-        logger_1.default.info((0, texts_js_1.LOG_STARTING_TUNNEL)(this.id));
-        // region latency
-        this.regionLatency = new latency_1.default(this.sshIp, this.sshPort);
-        this.regionLatency.startChecking();
-        // target latency
-        if (!this.serve && this.type !== utils_1.TUNNEL_SSH) {
-            this.targetLatency = new latency_1.default(this.targetHost, this.targetPort);
-            this.targetLatency.on(utils_1.TUNNEL_LATENCY_EVENT_RECONNECTED, () => this.targetReconnected());
-            this.targetLatency.startChecking();
-        }
-        // dns health
-        this.dns = new dns_js_1.default(this.sshIp, this.domain, this.customDomain, this.subdomain, this.region, this.sshId);
-        this.dns.startChecking();
-        if (this.type === utils_1.TUNNEL_TLS && this.terminate === utils_1.TLS_TERMINATE_AT_AGENT) {
-            // tls
-            this.tls = new tls_1.default(this.key, this.cert, this.ca);
-            this.tls.on(utils_1.TLS_SOCKET, (socket) => this.tlsSocket(socket));
-        }
-        else if (this.type === utils_1.TUNNEL_HTTP) {
-            // http
-            this.httpLog = new log_1.default(this.log, this.circuitBreaker);
-            this.httpLog.on(utils_1.EVENT_TUNNEL_HTTP_NEW_REQUEST, (logRequest) => this.httpLogRequest(logRequest));
-            this.httpLog.on(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE, (logRequest) => this.httpLogResponse(logRequest));
-            this.identify = new identification_1.default(this.targetProto, this.targetHost, this.targetPort, this.http2 || !!this.serve);
-            this.identify.on(utils_1.EVENT_TUNNEL_IDENTIFIED, (type) => this.httpIdentified(type));
-            const host = format_1.default.entryHostEncoded(this);
-            this.http2server = new http2_1.default(host);
-            this.http2server.on(utils_1.HTTP2_SESSION_OPEN, (session) => this.httpConnectionOpen(session));
-            this.http2server.on(utils_1.HTTP2_SESSION_CLOSED, (session) => this.httpConnectionClosed(session));
-            this.http2server.on(utils_1.HTTP2_REQUEST, (req, res) => this.httpRequest(req, res));
-            this.http1server = new http1_1.default(host);
-            this.http1server.on(utils_1.HTTP1_SOCKET_OPEN, (socket) => this.httpConnectionOpen(socket));
-            this.http1server.on(utils_1.HTTP1_SOCKET_CLOSED, (socket) => this.httpConnectionClosed(socket));
-            this.http1server.on(utils_1.HTTP1_REQUEST, (req, res) => this.httpRequest(req, res));
-        }
-        else if (this.type === utils_1.TUNNEL_SSH) {
-            // ssh server
-            this.sshServer = new ssh_1.default(this.agent, this.sshClientUser, this.sshClientPassword, this.sshHostKey);
-        }
-        // ssh
-        this.ssh = new client_1.default(this.sshIp, this.sshPort, this.sshUser, this.sshPassword);
-        this.ssh.on(utils_1.SSH_CLIENT_EVENT_CONNECTED, () => this.sshConnected());
-        this.ssh.on(utils_1.SSH_CLIENT_EVENT_DISCONNECTED, () => this.sshDisconnected());
-        this.ssh.on(utils_1.SSH_CLIENT_EVENT_STREAM_TCP, (stream) => this.sshStreamTcp(stream));
-        this.ssh.on(utils_1.SSH_CLIENT_EVENT_STREAM_TLS, (stream) => this.sshStreamTls(stream));
-        this.ssh.on(utils_1.SSH_CLIENT_EVENT_STREAM_HTTP1, (stream, info, ip) => this.sshStreamHttp1(stream, info, ip));
-        this.ssh.on(utils_1.SSH_CLIENT_EVENT_STREAM_HTTP2, (stream, info, ip) => this.sshStreamHttp2(stream, info, ip));
-        this.ssh.on(utils_1.SSH_CLIENT_EVENT_STREAM_SSH, (stream) => this.sshStreamSsh(stream));
-        this.ssh.openKeepAlive();
-    }
-    stop(emitEvent = true) {
-        if (!this.started)
-            return;
-        this.started = false;
-        logger_1.default.info((0, texts_js_1.LOG_STOPPING_TUNNEL)(this.id));
-        if (emitEvent)
-            this.emit(utils_1.TUNNEL_EVENT_STOPPED, this);
-        if (this.regionLatency) {
-            this.regionLatency.removeAllListeners();
-            this.regionLatency.stopChecking();
-            this.regionLatency = null;
-        }
-        if (this.dns) {
-            this.dns.stopChecking();
-            this.dns = null;
-        }
-        if (this.targetLatency) {
-            this.targetLatency.removeAllListeners();
-            this.targetLatency.stopChecking();
-            this.targetLatency = null;
-        }
-        if (this.tls) {
-            this.tls.removeAllListeners();
-            this.tls.stop();
-            this.tls = null;
-        }
-        if (this.httpLog) {
-            this.httpLog.removeAllListeners();
-            this.httpLog.stop();
-            this.httpLog = null;
-        }
-        if (this.sshServer) {
-            this.sshServer.removeAllListeners();
-            this.sshServer.stop();
-            this.sshServer = null;
-        }
-        if (this.identify) {
-            this.identify.removeAllListeners();
-            this.identify.stop();
-            this.identify = null;
-        }
-        if (this.http2server) {
-            this.http2server.removeAllListeners();
-            this.http2server.stop();
-            this.http2server = null;
-        }
-        if (this.http1server) {
-            this.http1server.removeAllListeners();
-            this.http1server.stop();
-            this.http1server = null;
-        }
-        if (this.ssh) {
-            this.ssh.removeAllListeners();
-            this.ssh.closeKeepAlive();
-            this.ssh = null;
-        }
-        this.status = utils_1.TUNNEL_CLOSED;
-    }
-}
-exports.default = Tunnel;

package/distTs/src/types/ciInfo.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CI = void 0;
-var CI;
-(function (CI) {
-    CI["BUDDY"] = "BUDDY";
-    CI["GITHUB_ACTION"] = "GITHUB_ACTION";
-    CI["CIRCLE_CI"] = "CIRCLE_CI";
-    CI["NONE"] = "NONE";
-})(CI || (exports.CI = CI = {}));