bdy 1.11.0-dev → 1.12.0-dev

package/distTs/src/tunnel/tunnel.js

@@ -20,8 +20,62 @@ const log_1 = __importDefault(require("./http/log"));
 const format_1 = __importDefault(require("../format"));
 const texts_1 = require("../texts");
 const dns_1 = __importDefault(require("./dns"));
+const tunnel_1 = require("../types/tunnel");
 class Tunnel extends events_1.default {
-    constructor({ agent, id, type, target, region, timeout, domain, customDomain, name, subdomain, whitelist, tlsSettings, httpSettings, sshSettings, sshHostKey, }) {
+    agent;
+    id;
+    sshHostKey;
+    type;
+    region;
+    target;
+    whitelist;
+    domain;
+    subdomain;
+    name;
+    timeout;
+    useragents;
+    headers;
+    responseHeaders;
+    terminate;
+    key;
+    cert;
+    ca;
+    host;
+    login;
+    password;
+    serve;
+    circuitBreaker;
+    log;
+    verify;
+    compression;
+    http2;
+    sshIp;
+    sshId;
+    sshPort;
+    sshUser;
+    sshPassword;
+    sshForwardPort;
+    sshClientUser;
+    sshClientPassword;
+    targetProto;
+    targetHost;
+    targetPort;
+    targetAuth;
+    totalConnections;
+    status;
+    connections;
+    dns;
+    regionLatency;
+    targetLatency;
+    tls;
+    httpLog;
+    identify;
+    http2server;
+    http1server;
+    sshServer;
+    ssh;
+    started;
+    constructor({ agent, id, type, target, region, timeout, domain, name, subdomain, whitelist, tlsSettings, httpSettings, sshSettings, sshHostKey, }) {
         super();
         if (!sshHostKey)
             sshHostKey = (0, utils_1.createSshHostKey)();
@@ -34,7 +88,6 @@ class Tunnel extends events_1.default {
             region,
             timeout,
             domain,
-            customDomain,
             subdomain,
             name,
             whitelist,
@@ -43,13 +96,12 @@ class Tunnel extends events_1.default {
             sshSettings,
         });
     }
-    create({ type, target, region, timeout, domain, customDomain, subdomain, name, whitelist, tlsSettings, httpSettings, sshSettings, }) {
+    create({ type, target, region, timeout, domain, 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;
@@ -91,7 +143,7 @@ class Tunnel extends events_1.default {
         this.targetHost = 'localhost';
         this.targetPort = 80;
         this.targetAuth = null;
-        if (this.type === utils_1.TUNNEL_HTTP) {
+        if (this.type === tunnel_1.TUNNEL_TYPE.HTTP) {
             let m = this.target.match(utils_1.TARGET_ONLY_PORT_REGEX);
             if (m) {
                 this.targetPort = parseInt(m[0], 10);
@@ -112,7 +164,7 @@ class Tunnel extends events_1.default {
                 }
             }
         }
-        else if (this.type === utils_1.TUNNEL_SSH) {
+        else if (this.type === tunnel_1.TUNNEL_TYPE.SSH) {
             this.targetHost = 'localhost';
             this.targetProto = 'ssh://';
             this.targetPort = 22;
@@ -127,7 +179,7 @@ class Tunnel extends events_1.default {
         }
         this.connections = {};
         this.totalConnections = 0;
-        this.status = utils_1.TUNNEL_CLOSED;
+        this.status = tunnel_1.TUNNEL_STATUS.CLOSED;
         this.dns = null;
         this.regionLatency = null;
         this.targetLatency = null;
@@ -140,7 +192,7 @@ class Tunnel extends events_1.default {
         this.ssh = null;
         this.started = false;
     }
-    recreate({ type, target, region, timeout, domain, customDomain, subdomain, name, whitelist, tlsSettings, httpSettings, sshSettings, }) {
+    recreate({ type, target, region, timeout, domain, subdomain, name, whitelist, tlsSettings, httpSettings, sshSettings, }) {
         const started = this.started;
         this.stop(false);
         this.create({
@@ -149,7 +201,6 @@ class Tunnel extends events_1.default {
             region,
             timeout,
             domain,
-            customDomain,
             subdomain,
             name,
             whitelist,
@@ -219,94 +270,116 @@ class Tunnel extends events_1.default {
             return true;
         if (this.sshClientUser !== tunnel.sshClientUser)
             return true;
-        if (this.whitelist.length !== tunnel.whitelist.length)
+        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.whitelist && tunnel.whitelist) {
+            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)
+        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;
+        if (this.useragents && tunnel.useragents) {
+            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;
+        if (this.headers?.length !== tunnel.headers?.length)
+            return true;
+        if (this.headers && tunnel.headers) {
+            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;
+        if (this.responseHeaders && tunnel.responseHeaders) {
+            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_1.LOG_TUNNEL_CONNECTED)(this.id, this.sshForwardPort));
-            await this.ssh.forwardIn(this.sshForwardPort);
-            this.status = utils_1.TUNNEL_OPEN;
+            if (this.ssh && this.sshForwardPort)
+                await this.ssh.forwardIn(this.sshForwardPort);
+            this.status = tunnel_1.TUNNEL_STATUS.OPEN;
         }
         catch (err) {
             // reconnect
             logger_1.default.debug((0, texts_1.LOG_TUNNEL_FAILED)(this.id));
             logger_1.default.debug(err);
-            this.ssh.close();
+            if (this.ssh)
+                this.ssh.close();
             return;
         }
-        this.emit(utils_1.TUNNEL_EVENT_OPEN, this);
+        this.emit(tunnel_1.TUNNEL_EVENT.OPEN, this);
     }
     sshDisconnected() {
-        if (this.status !== utils_1.TUNNEL_CLOSED) {
+        if (this.status !== tunnel_1.TUNNEL_STATUS.CLOSED) {
             logger_1.default.debug((0, texts_1.LOG_TUNNEL_DISCONNECTED)(this.id));
-            this.status = utils_1.TUNNEL_CLOSED;
-            this.emit(utils_1.TUNNEL_EVENT_CLOSED, this);
+            this.status = tunnel_1.TUNNEL_STATUS.CLOSED;
+            this.emit(tunnel_1.TUNNEL_EVENT.CLOSED, this);
         }
     }
     tunnelToTarget(stream, onClose) {
+        if (!this.totalConnections)
+            this.totalConnections = 0;
         this.totalConnections += 1;
-        const tcp = new tcp_1.default(this.targetHost, this.targetPort, stream);
+        const tcp = new tcp_1.default(this.targetHost || '', this.targetPort || 0, stream);
+        if (!this.connections)
+            this.connections = {};
         this.connections[tcp.id] = tcp;
-        tcp.on(utils_1.TCP_EVENT_CLOSED, () => {
-            this.connections[tcp.id].removeAllListeners();
-            delete this.connections[tcp.id];
+        tcp.on(tunnel_1.TUNNEL_EVENT_TCP.CLOSED, () => {
+            if (this.connections && this.connections[tcp.id]) {
+                this.connections[tcp.id].removeAllListeners();
+                delete this.connections[tcp.id];
+            }
             onClose();
         });
         tcp.pipe();
     }
     httpIdentified(type) {
         logger_1.default.info((0, texts_1.LOG_TUNNEL_IDENTIFIED)(this.id, type));
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, this, type);
+        this.emit(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, this, type);
     }
     httpConnectionOpen(s) {
+        if (!this.totalConnections)
+            this.totalConnections = 0;
+        if (!this.connections)
+            this.connections = {};
         this.totalConnections += 1;
         this.connections[s.id] = s;
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_OPEN, this);
+        this.emit(tunnel_1.TUNNEL_EVENT.HTTP_OPEN, this);
     }
     httpConnectionClosed(s) {
-        delete this.connections[s.id];
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_CLOSED, this);
+        if (this.connections && this.connections[s.id]) {
+            delete this.connections[s.id];
+        }
+        this.emit(tunnel_1.TUNNEL_EVENT.HTTP_CLOSED, this);
     }
     httpBasicAuth(req, res) {
         if (this.login || this.password) {
@@ -322,9 +395,13 @@ class Tunnel extends events_1.default {
         return true;
     }
     httpEndFast(req, res, statusCode, msg, headers = {}) {
-        const log = this.httpLog.newRequest(req.method, req.headers, req.url, req.httpVersion, req);
+        let log;
+        if (this.httpLog) {
+            log = this.httpLog.newRequest(req.method, req.headers, req.url, req.httpVersion, req);
+        }
         if (!log) {
-            this.httpLog.newResponse(req, statusCode, headers);
+            if (this.httpLog)
+                this.httpLog.newResponse(statusCode, headers);
             res.statusCode = statusCode;
             Object.keys(headers).forEach((k) => {
                 res.setHeader(k, headers[k]);
@@ -334,7 +411,8 @@ class Tunnel extends events_1.default {
         else {
             req.pipe(log.requestBody);
             log.requestBody.pipeToNothing(() => {
-                this.httpLog.newResponse(req, statusCode, headers, log);
+                if (this.httpLog)
+                    this.httpLog.newResponse(statusCode, headers, log);
                 res.statusCode = statusCode;
                 Object.keys(headers).forEach((k) => {
                     res.setHeader(k, headers[k]);
@@ -344,7 +422,7 @@ class Tunnel extends events_1.default {
         }
     }
     httpRateLimit(req, res) {
-        const isRateLimited = this.httpLog.isRateLimited(req);
+        const isRateLimited = !!this.httpLog && this.httpLog.isRateLimited(req);
         if (isRateLimited) {
             logger_1.default.debug(texts_1.LOG_TUNNEL_HTTP_RATE_LIMIT);
             this.httpEndFast(req, res, 429, 'Too Many Requests', {
@@ -355,7 +433,7 @@ class Tunnel extends events_1.default {
         return true;
     }
     httpCircuitBreaker(req, res) {
-        const isOpen = this.httpLog.isCircuitBreakerOpen();
+        const isOpen = !!this.httpLog && this.httpLog.isCircuitBreakerOpen();
         if (isOpen) {
             logger_1.default.debug(texts_1.LOG_TUNNEL_HTTP_CIRCUIT_BREAKER_OPEN);
             this.httpEndFast(req, res, 504, 'Service Unavailable', {});
@@ -393,17 +471,21 @@ class Tunnel extends events_1.default {
             this.identify.identify();
     }
     httpLogRequest(logRequest) {
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_REQUEST, this, logRequest);
+        this.emit(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, this, logRequest);
     }
     httpLogResponse(logRequest) {
-        this.emit(utils_1.TUNNEL_EVENT_HTTP_RESPONSE, this, logRequest);
+        this.emit(tunnel_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);
+        if (logRequest.httpVersion === '2.0') {
+            if (this.http2server)
+                return this.http2server.retryRequest(logRequest);
+        }
+        if (this.http1server) {
+            return this.http1server.retryRequest(logRequest);
+        }
     }
     httpRequest(req, res) {
         const isAuth = this.httpBasicAuth(req, res) &&
@@ -426,32 +508,33 @@ class Tunnel extends events_1.default {
             headers: this.headers,
             serve: this.serve,
             responseHeaders: this.responseHeaders,
-            httpIdentify: this.identify.type,
+            httpIdentify: this.identify?.type,
             httpLog: this.httpLog,
         });
-        http.once(utils_1.HTTP1_SOCKET_CLOSED, (socket) => this.httpConnectionClosed(socket));
+        http.once(tunnel_1.TUNNEL_HTTP_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(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, this);
         });
-        this.emit(utils_1.TUNNEL_EVENT_TLS_OPEN, this);
+        this.emit(tunnel_1.TUNNEL_EVENT.TLS_OPEN, this);
     }
     canStreamTcp() {
-        if (this.type === utils_1.TUNNEL_TCP)
+        if (this.type === tunnel_1.TUNNEL_TYPE.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));
+        return (this.type === tunnel_1.TUNNEL_TYPE.TLS &&
+            this.terminate &&
+            [tunnel_1.TUNNEL_TERMINATE_AT.REGION, tunnel_1.TUNNEL_TERMINATE_AT.TARGET].includes(this.terminate));
     }
     canStreamTls() {
-        return this.type === utils_1.TUNNEL_TLS;
+        return this.type === tunnel_1.TUNNEL_TYPE.TLS;
     }
     canStreamSsh() {
-        return this.type === utils_1.TUNNEL_SSH;
+        return this.type === tunnel_1.TUNNEL_TYPE.SSH;
     }
     canStreamHttp() {
-        return this.type === utils_1.TUNNEL_HTTP;
+        return this.type === tunnel_1.TUNNEL_TYPE.HTTP;
     }
     safeEndStream(stream) {
         try {
@@ -478,9 +561,9 @@ class Tunnel extends events_1.default {
         }
         logger_1.default.debug((0, texts_1.LOG_TUNNEL_TCP_STREAM)(this.id));
         this.tunnelToTarget(stream, () => {
-            this.emit(utils_1.TUNNEL_EVENT_TCP_CLOSED, this);
+            this.emit(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, this);
         });
-        this.emit(utils_1.TUNNEL_EVENT_TCP_OPEN, this);
+        this.emit(tunnel_1.TUNNEL_EVENT.TCP_OPEN, this);
     }
     sshStreamHttp1(stream, info, ip) {
         if (!this.canStreamHttp()) {
@@ -523,12 +606,12 @@ class Tunnel extends events_1.default {
             this.safeEndStream(stream);
             return;
         }
-        if (this.terminate === utils_1.TLS_TERMINATE_AT_TARGET) {
+        if (this.terminate === tunnel_1.TUNNEL_TERMINATE_AT.TARGET) {
             logger_1.default.debug((0, texts_1.LOG_TUNNEL_TLS_TARGET_STREAM)(this.id));
             this.sshStreamTcp(stream);
             return;
         }
-        if (this.terminate === utils_1.TLS_TERMINATE_AT_REGION) {
+        if (this.terminate === tunnel_1.TUNNEL_TERMINATE_AT.REGION) {
             logger_1.default.debug((0, texts_1.LOG_TUNNEL_TLS_REGION_STREAM)(this.id));
             this.sshStreamTcp(stream);
             return;
@@ -541,7 +624,7 @@ class Tunnel extends events_1.default {
         this.safeEndStream(stream);
     }
     start() {
-        if (this.started)
+        if (this.started || !this.sshIp || !this.sshPort || !this.domain || !this.subdomain || !this.region || !this.sshId || !this.sshUser || !this.sshPassword)
             return;
         this.started = true;
         logger_1.default.info((0, texts_1.LOG_STARTING_TUNNEL)(this.id));
@@ -549,49 +632,50 @@ class Tunnel extends events_1.default {
         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());
+        if (!this.serve && this.type !== tunnel_1.TUNNEL_TYPE.SSH) {
+            this.targetLatency = new latency_1.default(this.targetHost || '', this.targetPort || 0);
+            this.targetLatency.on(tunnel_1.TUNNEL_EVENT_LATENCY.RECONNECTED, () => this.targetReconnected());
             this.targetLatency.startChecking();
         }
         // dns health
-        this.dns = new dns_1.default(this.sshIp, this.domain, this.customDomain, this.subdomain, this.region, this.sshId);
+        this.dns = new dns_1.default(this.sshIp, this.domain, this.subdomain, this.region, this.sshId);
         this.dns.startChecking();
-        if (this.type === utils_1.TUNNEL_TLS && this.terminate === utils_1.TLS_TERMINATE_AT_AGENT) {
+        if (this.type === tunnel_1.TUNNEL_TYPE.TLS &&
+            this.terminate === tunnel_1.TUNNEL_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));
+            this.tls.on(tunnel_1.TUNNEL_EVENT.TLS_SOCKET, (socket) => this.tlsSocket(socket));
         }
-        else if (this.type === utils_1.TUNNEL_HTTP) {
+        else if (this.type === tunnel_1.TUNNEL_TYPE.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));
+            this.httpLog.on(tunnel_1.TUNNEL_EVENT_HTTP.NEW_REQUEST, (logRequest) => this.httpLogRequest(logRequest));
+            this.httpLog.on(tunnel_1.TUNNEL_EVENT_HTTP.NEW_RESPONSE, (logRequest) => this.httpLogResponse(logRequest));
+            this.identify = new identification_1.default(this.targetProto || '', this.targetHost || '', this.targetPort || 0, this.http2 || !!this.serve);
+            this.identify.on(tunnel_1.TUNNEL_EVENT.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.http2server.on(tunnel_1.TUNNEL_EVENT.HTTP_SESSION_OPEN, (session) => this.httpConnectionOpen(session));
+            this.http2server.on(tunnel_1.TUNNEL_EVENT.HTTP_SESSION_CLOSED, (session) => this.httpConnectionClosed(session));
+            this.http2server.on(tunnel_1.TUNNEL_EVENT.HTTP_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));
+            this.http1server.on(tunnel_1.TUNNEL_HTTP_SOCKET.OPEN, (socket) => this.httpConnectionOpen(socket));
+            this.http1server.on(tunnel_1.TUNNEL_HTTP_SOCKET.CLOSED, (socket) => this.httpConnectionClosed(socket));
+            this.http1server.on(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, (req, res) => this.httpRequest(req, res));
         }
-        else if (this.type === utils_1.TUNNEL_SSH) {
+        else if (this.type === tunnel_1.TUNNEL_TYPE.SSH) {
             // ssh server
-            this.sshServer = new ssh_1.default(this.agent, this.sshClientUser, this.sshClientPassword, this.sshHostKey);
+            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.on(tunnel_1.TUNNEL_SSH_EVENT.CONNECTED, () => this.sshConnected());
+        this.ssh.on(tunnel_1.TUNNEL_SSH_EVENT.DISCONNECTED, () => this.sshDisconnected());
+        this.ssh.on(tunnel_1.TUNNEL_SSH_EVENT.STREAM_TCP, (stream) => this.sshStreamTcp(stream));
+        this.ssh.on(tunnel_1.TUNNEL_SSH_EVENT.STREAM_TLS, (stream) => this.sshStreamTls(stream));
+        this.ssh.on(tunnel_1.TUNNEL_SSH_EVENT.STREAM_HTTP1, (stream, info, ip) => this.sshStreamHttp1(stream, info, ip));
+        this.ssh.on(tunnel_1.TUNNEL_SSH_EVENT.STREAM_HTTP2, (stream, info, ip) => this.sshStreamHttp2(stream, info, ip));
+        this.ssh.on(tunnel_1.TUNNEL_SSH_EVENT.STREAM_SSH, (stream) => this.sshStreamSsh(stream));
         this.ssh.openKeepAlive();
     }
     stop(emitEvent = true) {
@@ -600,7 +684,7 @@ class Tunnel extends events_1.default {
         this.started = false;
         logger_1.default.info((0, texts_1.LOG_STOPPING_TUNNEL)(this.id));
         if (emitEvent)
-            this.emit(utils_1.TUNNEL_EVENT_STOPPED, this);
+            this.emit(tunnel_1.TUNNEL_EVENT.STOPPED, this);
         if (this.regionLatency) {
             this.regionLatency.removeAllListeners();
             this.regionLatency.stopChecking();
@@ -650,7 +734,7 @@ class Tunnel extends events_1.default {
             this.ssh.closeKeepAlive();
             this.ssh = null;
         }
-        this.status = utils_1.TUNNEL_CLOSED;
+        this.status = tunnel_1.TUNNEL_STATUS.CLOSED;
     }
 }
 exports.default = Tunnel;