bdy 1.11.0-dev → 1.12.0-dev

package/distTs/src/tunnel/http/log.js

@@ -3,12 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelHttpLogRequest = void 0;
 const events_1 = __importDefault(require("events"));
 const uuid_1 = require("uuid");
 const stream_1 = __importDefault(require("./stream"));
 const isbinaryfile_1 = require("isbinaryfile");
 const utils_1 = require("../../utils");
+const tunnel_1 = require("../../types/tunnel");
 class TunnelHttpLogRequest extends events_1.default {
+    method;
+    headers;
+    responseHeaders;
+    url;
+    httpVersion;
+    status;
+    start;
+    finished;
+    id;
+    requestBody;
+    responseBody;
+    time;
     constructor(method, headers, url, httpVersion) {
         super();
         this.method = method;
@@ -21,11 +35,11 @@ class TunnelHttpLogRequest extends events_1.default {
         this.id = (0, uuid_1.v4)();
         this.requestBody = new stream_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
         this.requestBody.once('close', () => {
-            this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_REQUEST_END);
+            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_REQUEST_END);
         });
         this.responseBody = new stream_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
         this.responseBody.once('close', () => {
-            this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE_END);
+            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_RESPONSE_END);
         });
     }
     response(statusCode, headers) {
@@ -83,15 +97,23 @@ class TunnelHttpLogRequest extends events_1.default {
         };
     }
 }
+exports.TunnelHttpLogRequest = TunnelHttpLogRequest;
 class TunnelHttpLog extends events_1.default {
+    log;
+    tsRateLimit;
+    tsCb;
+    circuitBreaker;
+    rateLimit;
+    requests;
     constructor(log, circuitBreakerThreshold) {
         super();
-        this.log = log;
+        this.log = !!log;
         this.requests = [];
         this.rateLimit = {};
         this.circuitBreaker = {
-            active: circuitBreakerThreshold !== null,
-            threshold: circuitBreakerThreshold,
+            active: circuitBreakerThreshold !== null &&
+                circuitBreakerThreshold !== undefined,
+            threshold: circuitBreakerThreshold || 0,
             open: false,
             test: false,
             total: 0,
@@ -164,7 +186,7 @@ class TunnelHttpLog extends events_1.default {
             this.requests.unshift(r);
             if (this.requests.length > utils_1.TUNNEL_HTTP_LOG_MAX_REQUESTS)
                 this.requests.pop();
-            this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_REQUEST, r);
+            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_REQUEST, r);
             return r;
         }
     }
@@ -185,11 +207,11 @@ class TunnelHttpLog extends events_1.default {
             }
         }
     }
-    newResponse(req, statusCode, headers, logRequest) {
+    newResponse(statusCode, headers, logRequest) {
         this.increaseCircuitBreaker(statusCode);
         if (logRequest && this.log) {
             logRequest.response(statusCode, headers);
-            this.emit(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE, logRequest);
+            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_RESPONSE, logRequest);
         }
     }
 }

package/distTs/src/tunnel/http/serve.js

@@ -13,6 +13,7 @@ const content_disposition_1 = __importDefault(require("content-disposition"));
 const mime_types_1 = __importDefault(require("mime-types"));
 const stream_1 = __importDefault(require("stream"));
 class TunnelHttpServe extends events_1.default {
+    serve;
     constructor(serve) {
         super();
         this.serve = path_1.default.resolve(serve);
@@ -91,7 +92,7 @@ class TunnelHttpServe extends events_1.default {
             }
         }
         const { base } = path_1.default.parse(absolutePath);
-        headers['content-length'] = stats.size;
+        headers['content-length'] = String(stats.size);
         headers['content-disposition'] = (0, content_disposition_1.default)(base, {
             type: 'inline',
         });
@@ -104,7 +105,7 @@ class TunnelHttpServe extends events_1.default {
         if (streamOpts.start !== undefined && streamOpts.end !== undefined) {
             headers['content-range'] =
                 `bytes ${streamOpts.start}-${streamOpts.end}/${stats.size}`;
-            headers['content-length'] = streamOpts.end - streamOpts.start + 1;
+            headers['content-length'] = String(streamOpts.end - streamOpts.start + 1);
         }
         if (!req.headers.range && req.headers['if-modified-since']) {
             const ims = Math.floor(Date.parse(req.headers['if-modified-since']) / 1000);

package/distTs/src/tunnel/http/stream.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const stream_1 = require("stream");
 class TunnelHttpStream extends stream_1.Transform {
+    maxSize;
+    data;
+    realLength;
+    tooLarge;
     constructor(maxSize) {
         super();
         this.maxSize = maxSize;
@@ -9,7 +13,7 @@ class TunnelHttpStream extends stream_1.Transform {
         this.realLength = 0;
         this.tooLarge = false;
     }
-    _transform(chunk, encoding, callback) {
+    _transform(chunk, _, callback) {
         if (!this.tooLarge) {
             if (this.data.length + chunk.length > this.maxSize) {
                 this.tooLarge = true;

package/distTs/src/tunnel/http.js

@@ -15,8 +15,28 @@ const https_1 = __importDefault(require("https"));
 const compression_1 = __importDefault(require("./compression"));
 const html_1 = __importDefault(require("./html"));
 const agent_1 = __importDefault(require("./agent"));
-const punycode_js_1 = __importDefault(require("punycode.js"));
+const punycode_1 = __importDefault(require("punycode/"));
+const tunnel_1 = require("../types/tunnel");
 class TunnelHttp extends events_1.default {
+    id;
+    req;
+    res;
+    proto;
+    host;
+    port;
+    hostHeader;
+    serve;
+    timeout;
+    httpIdentify;
+    verify;
+    compression;
+    headers;
+    responseHeaders;
+    httpLog;
+    logRequest;
+    auth;
+    proxyRes;
+    proxyReq;
     constructor({ req, res, proto, host, port, hostHeader, serve, timeout, httpIdentify, verify, httpLog, compression, headers, responseHeaders, auth = null, }) {
         super();
         this.id = (0, uuid_1.v4)();
@@ -55,7 +75,8 @@ class TunnelHttp extends events_1.default {
                 s.push(null);
                 s.pipe(this.logRequest.responseBody);
             }
-            this.httpLog.newResponse(this.req, code, {}, this.logRequest);
+            if (this.httpLog)
+                this.httpLog.newResponse(code, {}, this.logRequest);
             this.res.statusCode = code;
             this.res.end(html);
         }
@@ -86,13 +107,13 @@ class TunnelHttp extends events_1.default {
     }
     getHostHeader() {
         if (this.hostHeader)
-            return punycode_js_1.default.toASCII(this.hostHeader);
-        let h = this.host;
+            return punycode_1.default.toASCII(this.hostHeader);
+        let h = this.host || '';
         if (this.proto === 'http' && this.port !== 80)
             h += `:${this.port}`;
         else if (this.proto === 'https' && this.port !== 443)
             h += `:${this.port}`;
-        return punycode_js_1.default.toASCII(h);
+        return punycode_1.default.toASCII(h);
     }
     getForwardedHost() {
         if (this.req.headers.host)
@@ -113,7 +134,7 @@ class TunnelHttp extends events_1.default {
             ip = this.req.socket.remoteAddress;
         }
         if (http2) {
-            h[':scheme'] = this.proto;
+            h[':scheme'] = this.proto || '';
             h[':authority'] = this.getHostHeader();
             h[':method'] = this.getMethod();
             h[':path'] = this.getPath();
@@ -152,7 +173,7 @@ class TunnelHttp extends events_1.default {
         }
         const tmp = {};
         if (compressionMethod &&
-            compressionMethod !== utils_1.TUNNEL_COMPRESSION_METHOD_IDENTITY) {
+            compressionMethod !== tunnel_1.TUNNEL_COMPRESSION_METHOD.IDENTITY) {
             tmp['content-encoding'] = compressionMethod;
             hop.push('content-length');
             hop.push('content-encoding');
@@ -165,9 +186,11 @@ class TunnelHttp extends events_1.default {
         tmp['access-control-allow-origin'] = '*';
         if (tmp['set-cookie']) {
             const setCookie = [];
-            const h = (this.req.headers.host || this.req.headers[':authority'] || '').split(':')[0];
+            const h = (this.req.headers.host ||
+                this.req.headers[':authority'] ||
+                '').split(':')[0];
             tmp['set-cookie'].forEach((cookie) => {
-                setCookie.push(cookie.replaceAll(/([dD]omain)=[\w_\-\\.]+/ig, `$1=${h}`));
+                setCookie.push(cookie.replaceAll(/([dD]omain)=[\w_\-\\.]+/gi, `$1=${h}`));
             });
             tmp['set-cookie'] = setCookie;
         }
@@ -202,13 +225,15 @@ class TunnelHttp extends events_1.default {
             path,
             headers,
         });
-        this.logRequest = this.httpLog.newRequest(method, headers, path, utils_1.TUNNEL_IDENTIFIED_HTTP1, this.req);
+        if (this.httpLog) {
+            this.logRequest = this.httpLog.newRequest(method, headers, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1, this.req);
+        }
         r.on('upgrade', (proxyRes, socket, head) => this.upgrade(proxyRes, socket, head));
         r.on('response', (proxyRes) => {
             this.proxyRes = proxyRes;
             const statusCode = this.proxyRes.statusCode;
             const resHeaders = this.proxyRes.headers;
-            const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
+            const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
             this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
                 this.proxyRes
@@ -221,7 +246,9 @@ class TunnelHttp extends events_1.default {
                     .pipe(compression_1.default.compress(compressionMethod))
                     .pipe(this.res);
             }
-            this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+            if (this.httpLog) {
+                this.httpLog.newResponse(statusCode, resHeaders, this.logRequest);
+            }
         });
         return r;
     }
@@ -245,13 +272,15 @@ class TunnelHttp extends events_1.default {
             rejectUnauthorized: this.verify,
             headers,
         });
-        this.logRequest = this.httpLog.newRequest(method, headers, path, utils_1.TUNNEL_IDENTIFIED_HTTP1, this.req);
+        if (this.httpLog) {
+            this.logRequest = this.httpLog.newRequest(method, headers, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1, this.req);
+        }
         r.on('upgrade', (proxyRes, socket, head) => this.upgrade(proxyRes, socket, head));
         r.on('response', (proxyRes) => {
             this.proxyRes = proxyRes;
             const statusCode = this.proxyRes.statusCode;
             const resHeaders = this.proxyRes.headers;
-            const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
+            const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
             this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
                 this.proxyRes
@@ -264,23 +293,27 @@ class TunnelHttp extends events_1.default {
                     .pipe(compression_1.default.compress(compressionMethod))
                     .pipe(this.res);
             }
-            this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+            if (this.httpLog) {
+                this.httpLog.newResponse(statusCode, resHeaders, this.logRequest);
+            }
         });
         return r;
     }
     createServe() {
         const reqHeaders = this.req.headers;
-        const r = new serve_1.default(this.serve);
+        const r = new serve_1.default(this.serve || '');
         const method = this.getMethod();
         const path = this.getPath();
-        this.logRequest = this.httpLog.newRequest(method, reqHeaders, path, utils_1.TUNNEL_IDENTIFIED_HTTP1, this.req);
+        if (this.httpLog) {
+            this.logRequest = this.httpLog.newRequest(method, reqHeaders, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1, this.req);
+        }
         r.on('response', (statusCode, resHeaders, stream) => {
             if (!stream) {
                 this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders));
                 this.res.end();
             }
             else {
-                const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
+                const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
                 this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
                 if (this.logRequest) {
                     stream
@@ -294,14 +327,16 @@ class TunnelHttp extends events_1.default {
                         .pipe(this.res);
                 }
             }
-            this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+            if (this.httpLog) {
+                this.httpLog.newResponse(statusCode, resHeaders, this.logRequest);
+            }
         });
         return r;
     }
     async createRequestHttps2() {
         const reqHeaders = this.req.headers;
         const authority = `${this.proto}://${(0, utils_1.getRealTargetHost)(this.host)}:${this.port}`;
-        const client = await agent_1.default.getHttp2Client(authority, this.host, this.verify);
+        const client = await agent_1.default.getHttp2Client(authority, this.host || '', this.verify || false);
         const method = this.getMethod();
         const path = this.getPath();
         const headers = {
@@ -310,10 +345,12 @@ class TunnelHttp extends events_1.default {
             ...this.getRequestHeaders(true),
         };
         const r = client.request(headers);
-        this.logRequest = this.httpLog.newRequest(method, headers, path, utils_1.TUNNEL_IDENTIFIED_HTTP2, this.req);
+        if (this.httpLog) {
+            this.logRequest = this.httpLog.newRequest(method, headers, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2, this.req);
+        }
         r.on('response', (resHeaders) => {
             const status = resHeaders[':status'] || 200;
-            const compressionMethod = compression_1.default.detect(this.compression, reqHeaders, resHeaders);
+            const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
             this.outputHeaders(status, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
                 r.pipe(this.logRequest.responseBody)
@@ -323,12 +360,14 @@ class TunnelHttp extends events_1.default {
             else {
                 r.pipe(compression_1.default.compress(compressionMethod)).pipe(this.res);
             }
-            this.httpLog.newResponse(this.req, status, resHeaders, this.logRequest);
+            if (this.httpLog) {
+                this.httpLog.newResponse(status, resHeaders, this.logRequest);
+            }
         });
         return r;
     }
     async createRequest() {
-        if (this.httpIdentify === utils_1.TUNNEL_IDENTIFIED_HTTP1) {
+        if (this.httpIdentify === tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1) {
             if (this.proto === 'http')
                 return this.createRequestHttp1();
             return this.createRequestHttps1();
@@ -363,7 +402,9 @@ class TunnelHttp extends events_1.default {
     upgrade(proxyRes, socket, head) {
         const resHeaders = proxyRes?.headers || {};
         const reqSocket = this.req.socket;
-        this.httpLog.newResponse(this.req, 101, resHeaders, this.logRequest);
+        if (this.httpLog) {
+            this.httpLog.newResponse(101, resHeaders, this.logRequest);
+        }
         socket.setTimeout(0);
         const headers = this.getClearedHeaders(resHeaders, null, true);
         this.clear();
@@ -384,7 +425,7 @@ class TunnelHttp extends events_1.default {
         socket.removeAllListeners();
         reqSocket.on('close', () => {
             reqSocket.removeAllListeners();
-            this.emit(utils_1.HTTP1_SOCKET_CLOSED, reqSocket);
+            this.emit(tunnel_1.TUNNEL_HTTP_SOCKET.CLOSED, reqSocket);
         });
         socket.on('close', () => {
             socket.removeAllListeners();

package/distTs/src/tunnel/identification.js

@@ -7,17 +7,23 @@ const events_1 = __importDefault(require("events"));
 const tls_1 = __importDefault(require("tls"));
 const net_1 = __importDefault(require("net"));
 const utils_1 = require("../utils");
-const utils_2 = require("../utils");
+const tunnel_1 = require("../types/tunnel");
 const CHECK_INTERVAL = 300000;
 const CHECK_TIMEOUT = 5000;
 class TunnelIdentification extends events_1.default {
+    proto;
+    host;
+    port;
+    forceHttp2;
+    type;
+    ts;
     constructor(proto, host, port, forceHttp2) {
         super();
         this.proto = proto;
         this.host = (0, utils_1.getRealTargetHost)(host);
         this.port = port;
         this.forceHttp2 = forceHttp2;
-        this.type = utils_2.TUNNEL_IDENTIFIED_HTTP1;
+        this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1;
         this.identify();
         this.ts = setInterval(() => this.identify(), CHECK_INTERVAL);
     }
@@ -29,29 +35,30 @@ class TunnelIdentification extends events_1.default {
     }
     identify() {
         if (this.forceHttp2) {
-            this.type = utils_2.TUNNEL_IDENTIFIED_HTTP2;
-            this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP2);
+            this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2;
+            this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2);
             return;
         }
         let socket;
         const close = () => {
             try {
                 socket.removeAllListeners();
-                socket.close();
+                socket.end();
+                socket.destroy();
             }
             catch {
                 // do nothing
             }
         };
         const connected = () => {
-            if (socket.alpnProtocol) {
+            if (socket instanceof tls_1.default.TLSSocket && socket.alpnProtocol) {
                 if (socket.alpnProtocol === 'h2') {
-                    this.type = utils_2.TUNNEL_IDENTIFIED_HTTP2;
-                    this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP2);
+                    this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2;
+                    this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2);
                 }
                 else {
-                    this.type = utils_2.TUNNEL_IDENTIFIED_HTTP1;
-                    this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP1);
+                    this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1;
+                    this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1);
                 }
                 close();
             }
@@ -59,12 +66,12 @@ class TunnelIdentification extends events_1.default {
                 socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');
                 socket.on('data', (d) => {
                     if (/HTTP\/1/.test(d.toString('utf8'))) {
-                        this.type = utils_2.TUNNEL_IDENTIFIED_HTTP1;
-                        this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP1);
+                        this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1;
+                        this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1);
                     }
                     else {
-                        this.type = utils_2.TUNNEL_IDENTIFIED_HTTP2;
-                        this.emit(utils_2.EVENT_TUNNEL_IDENTIFIED, utils_2.TUNNEL_IDENTIFIED_HTTP2);
+                        this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2;
+                        this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2);
                     }
                     close();
                 });

package/distTs/src/tunnel/latency.js

@@ -6,7 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const net_1 = require("net");
 const events_1 = __importDefault(require("events"));
 const utils_1 = require("../utils");
+const tunnel_1 = require("../types/tunnel");
 class TunnelLatency extends events_1.default {
+    latency;
+    isChecking;
+    port;
+    host;
+    ts;
     constructor(host, port) {
         super();
         this.latency = -1;
@@ -26,16 +32,18 @@ class TunnelLatency extends events_1.default {
         let socket = new net_1.Socket();
         let ts = null;
         const clear = () => {
-            clearTimeout(ts);
-            try {
-                socket.removeAllListeners();
-                socket.once('error', () => {
-                });
-                socket.end();
-                socket.destroy();
-            }
-            catch {
-                // do nothing
+            if (ts)
+                clearTimeout(ts);
+            if (socket) {
+                try {
+                    socket.removeAllListeners();
+                    socket.once('error', () => { });
+                    socket.end();
+                    socket.destroy();
+                }
+                catch {
+                    // do nothing
+                }
             }
             socket = null;
             this.isChecking = false;
@@ -52,7 +60,7 @@ class TunnelLatency extends events_1.default {
         socket.on('ready', () => {
             const elapsed = process.hrtime(start);
             if (this.latency < 0)
-                this.emit(utils_1.TUNNEL_LATENCY_EVENT_RECONNECTED);
+                this.emit(tunnel_1.TUNNEL_EVENT_LATENCY.RECONNECTED);
             this.latency = elapsed[0] * 1000 + elapsed[1] / 1000000; // ms
             clear();
         });

package/distTs/src/tunnel/output/interactive/tunnel.js

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../../../utils");
+// @ts-ignore
 const termkit_no_lazy_require_1 = __importDefault(require("terminal-kit/lib/termkit-no-lazy-require"));
 const isbinaryfile_1 = require("isbinaryfile");
 const format_1 = __importDefault(require("../../../format"));
+const tunnel_1 = require("../../../types/tunnel");
 const COLOR_CYAN = 6;
 const COLOR_LIGHT_GRAY = 7;
 const COLOR_RED = 9;
@@ -40,6 +42,11 @@ const formatBytes = (len) => {
     return `${len}GB`;
 };
 class OutputInteractiveTunnel {
+    terminal;
+    tunnel;
+    viewPort;
+    sprites;
+    selectedRequest;
     constructor(terminal, tunnel) {
         this.terminal = terminal;
         this.tunnel = tunnel;
@@ -162,13 +169,13 @@ class OutputInteractiveTunnel {
         if (r.status === 'NEW') {
             msg += ' ^KNEW^';
         }
-        else if (r.status >= 500) {
+        else if (typeof (r.status) === 'number' && r.status >= 500) {
             msg += ` ^R${r.status}^`;
         }
-        else if (r.status >= 400) {
+        else if (typeof (r.status) === 'number' && r.status >= 400) {
             msg += ` ^Y${r.status}^`;
         }
-        else if (r.status >= 300) {
+        else if (typeof (r.status) === 'number' && r.status >= 300) {
             msg += ` ^B${r.status}^`;
         }
         else {
@@ -179,7 +186,7 @@ class OutputInteractiveTunnel {
         return msg;
     }
     getPathAndQuery(url) {
-        let query = {};
+        const query = {};
         let path;
         try {
             const u = new URL(url, 'https://test.com');
@@ -496,7 +503,7 @@ class OutputInteractiveTunnel {
         }, fillString('Entry:', ROW_LENGTH));
     }
     createSpriteTerminate() {
-        if (this.tunnel.type === utils_1.TUNNEL_TLS) {
+        if (this.tunnel.type === tunnel_1.TUNNEL_TYPE.TLS) {
             this.sprites.terminate = termkit_no_lazy_require_1.default.ScreenBuffer.createFromString({
                 attr: {
                     color: COLOR_LIGHT_GRAY,
@@ -592,7 +599,7 @@ class OutputInteractiveTunnel {
     updateSpriteStatus(y) {
         let text;
         let color;
-        if (this.tunnel.status === utils_1.TUNNEL_OPEN) {
+        if (this.tunnel.status === tunnel_1.TUNNEL_STATUS.OPEN) {
             text = 'OPEN  ';
             color = COLOR_GREEN;
         }
@@ -628,7 +635,7 @@ class OutputInteractiveTunnel {
         return this.sprites.type.height;
     }
     updateSpriteIdentify(y) {
-        if (this.tunnel.type === utils_1.TUNNEL_HTTP) {
+        if (this.tunnel.type === tunnel_1.TUNNEL_TYPE.HTTP) {
             this.sprites.identify.put({
                 x: COLUMN_LENGTH,
                 y: 0,
@@ -690,7 +697,7 @@ class OutputInteractiveTunnel {
         return this.sprites.region.height;
     }
     updateSpriteTerminate(y) {
-        if (this.tunnel.type === utils_1.TUNNEL_TLS) {
+        if (this.tunnel.type === tunnel_1.TUNNEL_TYPE.TLS) {
             this.sprites.terminate.put({
                 x: COLUMN_LENGTH,
                 y: 0,
@@ -836,7 +843,7 @@ class OutputInteractiveTunnel {
         this.terminal.on('resize', () => {
             this.draw();
         });
-        this.tunnel.on(utils_1.TUNNEL_EVENT_STOPPED, () => {
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.STOPPED, () => {
             this.terminate();
         });
     }

package/distTs/src/tunnel/output/noninteractive/agent/tunnels.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../../../../utils");
 const texts_1 = require("../../../../texts");
 const format_1 = __importDefault(require("../../../../format"));
+const tunnel_1 = require("../../../../types/tunnel");
 class OutputNoninteractiveAgentTunnels {
+    terminal;
+    tunnels;
     constructor(terminal, tunnels) {
         this.terminal = terminal;
         this.tunnels = tunnels;
@@ -29,7 +31,7 @@ class OutputNoninteractiveAgentTunnels {
                         format_1.default.target(tunnel.type, tunnel.target) +
                             ` / ${format_1.default.latency(tunnel.targetLatency)}`;
                 const entry = format_1.default.entry(tunnel) + ` / ${format_1.default.latency(tunnel.regionLatency)}`;
-                if (tunnel.status === utils_1.TUNNEL_OPEN)
+                if (tunnel.status === tunnel_1.TUNNEL_STATUS.OPEN)
                     status = 'Open';
                 else
                     status = 'Closed';

package/distTs/src/tunnel/output/noninteractive/config/tunnel.js

@@ -3,9 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../../../../utils");
 const format_1 = __importDefault(require("../../../../format"));
+const tunnel_1 = require("../../../../types/tunnel");
 class OutputNoninteractiveConfigTunnel {
+    terminal;
+    tunnel;
     constructor(terminal, tunnel) {
         this.terminal = terminal;
         this.tunnel = tunnel;
@@ -15,7 +17,7 @@ class OutputNoninteractiveConfigTunnel {
             ['Name', this.tunnel.name],
             ['Type', format_1.default.type(this.tunnel.type)],
         ];
-        if (this.tunnel.type === utils_1.TUNNEL_HTTP && this.tunnel.serve) {
+        if (this.tunnel.type === tunnel_1.TUNNEL_TYPE.HTTP && this.tunnel.serve) {
             data.push(['Serve', format_1.default.serve(this.tunnel.serve)]);
         }
         else {
@@ -27,7 +29,7 @@ class OutputNoninteractiveConfigTunnel {
         data.push(['Region', format_1.default.tunnelRegion(this.tunnel.region)]);
         data.push(['Timeout', format_1.default.tunnelTimeout(this.tunnel.timeout)]);
         data.push(['Whitelist', format_1.default.tunnelWhitelist(this.tunnel.whitelist)]);
-        if (this.tunnel.type === utils_1.TUNNEL_HTTP) {
+        if (this.tunnel.type === tunnel_1.TUNNEL_TYPE.HTTP) {
             data.push(['Host Header', format_1.default.hostHeader(this.tunnel.host)]);
             data.push([
                 'Basic Auth',
@@ -52,7 +54,7 @@ class OutputNoninteractiveConfigTunnel {
             data.push(['Force HTTP/2', format_1.default.yesNo(this.tunnel.http2)]);
             data.push(['Compression', format_1.default.yesNo(this.tunnel.compression)]);
         }
-        else if (this.tunnel.type === utils_1.TUNNEL_TLS) {
+        else if (this.tunnel.type === tunnel_1.TUNNEL_TYPE.TLS) {
             data.push(['Terminate TLS At', this.tunnel.terminate]);
             data.push(['TLS Key', format_1.default.yesNo(!!this.tunnel.key)]);
             data.push(['TLS Cert', format_1.default.yesNo(!!this.tunnel.cert)]);