bdy 1.11.0-dev → 1.12.0-dev

package/distTs/src/agent/socket/client.js

@@ -9,10 +9,22 @@ const logger_1 = __importDefault(require("../../logger"));
 const texts_1 = require("../../texts");
 const utils_1 = require("../../utils");
 const socket_io_client_1 = require("socket.io-client");
+const tunnel_1 = require("../../types/tunnel");
 const MAX_REQUESTS_SYNC_WINDOW = 30000;
 const MAX_REQUESTS_SYNC_IN_WINDOW = 100;
 class AgentSocketClient extends events_1.default {
+    socket;
+    id;
+    token;
+    hostname;
+    platform;
+    version;
+    connected;
+    lastUpdate;
+    tunnelRequests;
     fetch(activate = true, action = null, disabled = null, resetFirstHeard = false, tunnels) {
+        if (!this.socket)
+            return;
         this.socket.emit('fetchTunnelAgent', {
             id: this.id,
             token: this.token,
@@ -27,6 +39,8 @@ class AgentSocketClient extends events_1.default {
         });
     }
     update(activate, tunnels, force = false) {
+        if (!this.socket)
+            return;
         const now = Date.now();
         // nie robimy update jak byl mniej niz 5s temu
         if (!force && this.lastUpdate && now - this.lastUpdate < 5000)
@@ -43,6 +57,8 @@ class AgentSocketClient extends events_1.default {
         });
     }
     emitRequest(tunnelId, logRequest) {
+        if (!this.socket)
+            return;
         this.socket.emit('tunnelRequest', {
             id: this.id,
             token: this.token,
@@ -54,16 +70,16 @@ class AgentSocketClient extends events_1.default {
         if (this.tunnelRequests > MAX_REQUESTS_SYNC_IN_WINDOW)
             return;
         this.tunnelRequests += 1;
-        logRequest.once(utils_1.EVENT_TUNNEL_HTTP_NEW_RESPONSE_END, () => {
+        logRequest.once(tunnel_1.TUNNEL_EVENT_HTTP.NEW_RESPONSE_END, () => {
             this.emitRequest(tunnelId, logRequest);
         });
         this.emitRequest(tunnelId, logRequest);
     }
     onSyncAgent(data, action) {
-        this.emit(utils_1.SOCKET_IO_EVENT_AGENT, data, action);
+        this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.AGENT, data, action);
     }
     onSyncTunnel(data, action) {
-        this.emit(utils_1.SOCKET_IO_EVENT_TUNNEL, data, action);
+        this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.TUNNEL, data, action);
     }
     onSync(data) {
         try {
@@ -117,6 +133,7 @@ class AgentSocketClient extends events_1.default {
             transports: ['websocket'],
             reconnection: false,
             rejectUnauthorized: false,
+            // @ts-ignore
             agent: new https_1.Agent({
                 rejectUnauthorized: false,
             }),
@@ -126,9 +143,11 @@ class AgentSocketClient extends events_1.default {
             },
         });
         this.socket.on('connect', () => {
+            if (!this.socket)
+                return;
             this.connected = true;
             logger_1.default.info(texts_1.LOG_SOCKET_CONNECTED);
-            this.emit(utils_1.SOCKET_IO_EVENT_CONNECTED);
+            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.CONNECTED);
             this.socket.emit('joinTunnelAgent', {
                 id: this.id,
                 token: this.token,
@@ -137,7 +156,7 @@ class AgentSocketClient extends events_1.default {
         this.socket.on('disconnect', () => {
             this.connected = false;
             logger_1.default.info(texts_1.LOG_SOCKET_DISCONNECTED);
-            this.emit(utils_1.SOCKET_IO_EVENT_DISCONNECTED);
+            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.DISCONNECTED);
             this.connect();
         });
         this.socket.on('connect_error', () => {
@@ -146,11 +165,11 @@ class AgentSocketClient extends events_1.default {
         });
         this.socket.on('fetchTunnelAgentSuccess', (data) => {
             logger_1.default.debug('Socket fetch success');
-            this.emit(utils_1.SOCKET_IO_EVENT_FETCH_SUCCESS, data);
+            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.FETCH_SUCCESS, data);
         });
         this.socket.on('fetchTunnelAgentFailed', (code) => {
             logger_1.default.debug('Socket fetch failed');
-            this.emit(utils_1.SOCKET_IO_EVENT_FETCH_FAILED, (0, utils_1.apiErrorCodeToClass)(code, host));
+            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.FETCH_FAILED, (0, utils_1.apiErrorCodeToClass)(code, host));
         });
         this.socket.on('sync', (data) => this.onSync(data));
         this.connect(true);

package/distTs/src/agent/socket/tunnel.js

@@ -6,7 +6,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const texts_1 = require("../../texts");
 const events_1 = __importDefault(require("events"));
 const utils_1 = require("../../utils");
+const tunnel_1 = require("../../types/tunnel");
 class AgentSocketTunnel extends events_1.default {
+    id;
+    closed;
+    ready;
+    socket;
+    httpLog;
+    regionLatency;
+    targetLatency;
+    identify;
+    sshForwardPort;
+    domain;
+    sshId;
+    subdomain;
+    terminate;
+    target;
+    type;
+    region;
+    status;
+    log;
+    serve;
+    totalConnections;
+    connections;
+    dns;
     constructor(socket, id) {
         super();
         this.id = id;
@@ -16,7 +39,7 @@ class AgentSocketTunnel extends events_1.default {
         this.socket.on('close', () => this.onClose());
         this.socket.on('message', (msg) => this.onMessage(msg));
         this.socket.send(JSON.stringify({
-            message: utils_1.AGENT_SOCKET_MESSAGE_READY,
+            message: tunnel_1.TUNNEL_SOCKET_MESSAGE.READY,
         }));
     }
     close() {
@@ -64,7 +87,6 @@ class AgentSocketTunnel extends events_1.default {
         this.subdomain = data.subdomain;
         this.sshId = data.sshId;
         this.domain = data.domain;
-        this.customDomain = data.customDomain;
         this.sshForwardPort = data.sshForwardPort;
     }
     upsertHttpLog(data) {
@@ -112,55 +134,55 @@ class AgentSocketTunnel extends events_1.default {
     onMessage(msg) {
         try {
             const json = JSON.parse(msg.toString('utf8'));
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL) {
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL) {
                 this.onTunnelData(json);
                 this.ready = true;
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS) {
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_REQUESTS) {
                 this.onTunnelRequests(json);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_OPEN) {
-                this.emit(utils_1.TUNNEL_EVENT_OPEN, json);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_OPEN) {
+                this.emit(tunnel_1.TUNNEL_EVENT.OPEN, json);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED) {
-                this.emit(utils_1.TUNNEL_EVENT_CLOSED, json);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_CLOSED) {
+                this.emit(tunnel_1.TUNNEL_EVENT.CLOSED, json);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN) {
-                this.emit(utils_1.TUNNEL_EVENT_TCP_OPEN, json);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_OPEN) {
+                this.emit(tunnel_1.TUNNEL_EVENT.TCP_OPEN, json);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED) {
-                this.emit(utils_1.TUNNEL_EVENT_TCP_CLOSED, json);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_CLOSED) {
+                this.emit(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, json);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN) {
-                this.emit(utils_1.TUNNEL_EVENT_TLS_OPEN, json);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_OPEN) {
+                this.emit(tunnel_1.TUNNEL_EVENT.TLS_OPEN, json);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED) {
-                this.emit(utils_1.TUNNEL_EVENT_TLS_CLOSED, json);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_CLOSED) {
+                this.emit(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, json);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED) {
-                this.emit(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, json, json.identify);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_IDENTIFIED) {
+                this.emit(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, json, json.identify);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST) {
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_REQUEST) {
                 this.upsertHttpLog(json.logRequest);
-                this.emit(utils_1.TUNNEL_EVENT_HTTP_REQUEST, json, json.logRequest);
+                this.emit(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, json, json.logRequest);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE) {
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_RESPONSE) {
                 this.upsertHttpLog(json.logRequest);
-                this.emit(utils_1.TUNNEL_EVENT_HTTP_RESPONSE, json, json.logRequest);
+                this.emit(tunnel_1.TUNNEL_EVENT.HTTP_RESPONSE, json, json.logRequest);
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED) {
-                this.emit(utils_1.TUNNEL_EVENT_STOPPED, json);
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_STOPPED) {
+                this.emit(tunnel_1.TUNNEL_EVENT.STOPPED, json);
                 this.close();
             }
         }
@@ -169,13 +191,15 @@ class AgentSocketTunnel extends events_1.default {
         }
     }
     onClose() {
-        this.emit(utils_1.TUNNEL_EVENT_STOPPED);
-        try {
-            this.socket.removeAllListeners();
-            this.socket.close();
-        }
-        catch {
-            // do nothing
+        this.emit(tunnel_1.TUNNEL_EVENT.STOPPED);
+        if (this.socket) {
+            try {
+                this.socket.removeAllListeners();
+                this.socket.close();
+            }
+            catch {
+                // do nothing
+            }
         }
         this.closed = true;
         this.socket = null;
@@ -183,7 +207,7 @@ class AgentSocketTunnel extends events_1.default {
     retryHttpLogRequest(logRequest) {
         if (this.socket) {
             this.socket.send(JSON.stringify({
-                message: utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY,
+                message: tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_RETRY,
                 logRequest,
             }));
         }

package/distTs/src/agent/socket.js

@@ -1,7 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
+const tunnel_1 = require("../types/tunnel");
 class AgentSocket {
+    tunnel;
+    socket;
+    ready;
+    ts;
+    boundEventStopped;
+    boundEventOpen;
+    boundEventClosed;
+    boundEventTcpOpen;
+    boundEventTcpClosed;
+    boundEventTlsOpen;
+    boundEventTlsClosed;
+    boundEventHttpIdentified;
+    boundEventHttpRequest;
+    boundEventHttpResponse;
     constructor(socket, tunnel) {
         this.tunnel = tunnel;
         this.socket = socket;
@@ -18,21 +32,21 @@ class AgentSocket {
         this.boundEventHttpIdentified = (t, type) => this.tunnelHttpIdentified(t, type);
         this.boundEventHttpRequest = (t, logRequest) => this.tunnelHttpRequest(t, logRequest);
         this.boundEventHttpResponse = (t, logRequest) => this.tunnelHttpResponse(t, logRequest);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_STOPPED, this.boundEventStopped);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_OPEN, this.boundEventOpen);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_CLOSED, this.boundEventClosed);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_TCP_OPEN, this.boundEventTcpOpen);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_TCP_CLOSED, this.boundEventTcpClosed);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_TLS_OPEN, this.boundEventTlsOpen);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_TLS_CLOSED, this.boundEventTlsClosed);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, this.boundEventHttpIdentified);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_REQUEST, this.boundEventHttpRequest);
-        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_RESPONSE, this.boundEventHttpResponse);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.STOPPED, this.boundEventStopped);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.OPEN, this.boundEventOpen);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.CLOSED, this.boundEventClosed);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TCP_OPEN, this.boundEventTcpOpen);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, this.boundEventTcpClosed);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TLS_OPEN, this.boundEventTlsOpen);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, this.boundEventTlsClosed);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, this.boundEventHttpIdentified);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, this.boundEventHttpRequest);
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_RESPONSE, this.boundEventHttpResponse);
     }
     onMessage(message) {
         try {
             const json = JSON.parse(message.toString('utf8'));
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_READY) {
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.READY) {
                 this.ready = true;
                 this.ts = setInterval(() => {
                     this.sendTunnel();
@@ -41,7 +55,7 @@ class AgentSocket {
                 this.sendRequests();
                 return;
             }
-            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY &&
+            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_RETRY &&
                 this.ready) {
                 this.retryHttpRequest(json.logRequest);
             }
@@ -51,6 +65,8 @@ class AgentSocket {
         }
     }
     retryHttpRequest(logRequest) {
+        if (!this.tunnel)
+            return;
         this.tunnel.retryHttpLogRequest(logRequest);
     }
     send(message, data = {}) {
@@ -68,32 +84,31 @@ class AgentSocket {
             target: t.target,
             subdomain: t.subdomain,
             domain: t.domain,
-            customDomain: t.customDomain,
             sshId: t.sshId,
             sshForwardPort: t.sshForwardPort,
             ...data,
         });
     }
     tunnelOpen(t) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_OPEN, t);
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_OPEN, t);
     }
     tunnelClosed(t) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED, t);
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_CLOSED, t);
     }
     tunnelTcpOpen(t) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN, t);
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_OPEN, t);
     }
     tunnelTcpClosed(t) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED, t);
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_CLOSED, t);
     }
     tunnelTlsOpen(t) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN, t);
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_OPEN, t);
     }
     tunnelTlsClosed(t) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED, t);
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_CLOSED, t);
     }
     tunnelHttpIdentified(t, type) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED, t, {
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_IDENTIFIED, t, {
             identify: type,
         });
     }
@@ -120,47 +135,47 @@ class AgentSocket {
         };
     }
     tunnelHttpRequest(t, logRequest) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST, t, {
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_REQUEST, t, {
             logRequest: this.logRequestToSocket(logRequest),
         });
     }
     tunnelHttpResponse(t, logRequest) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE, t, {
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_RESPONSE, t, {
             logRequest: this.logRequestToSocket(logRequest),
         });
     }
     tunnelStopped(t) {
-        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED, t);
+        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_STOPPED, t);
         this.close();
     }
     sendRequests() {
         let requests = [];
-        if (this.tunnel.httpLog) {
+        if (this.tunnel?.httpLog) {
             requests = this.tunnel.httpLog.requests.map((lr) => this.logRequestToSocket(lr));
         }
-        this.send(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS, {
+        this.send(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_REQUESTS, {
             requests,
         });
     }
     sendTunnel() {
         const connections = {};
-        Object.keys(this.tunnel.connections).forEach((id) => {
+        Object.keys(this.tunnel?.connections || {}).forEach((id) => {
             connections[id] = true;
         });
         const regionLatency = {
             latency: -1,
         };
-        if (this.tunnel.regionLatency) {
+        if (this.tunnel?.regionLatency) {
             regionLatency.latency = this.tunnel.regionLatency.latency;
         }
         const targetLatency = {
             latency: -1,
         };
-        if (this.tunnel.targetLatency) {
+        if (this.tunnel?.targetLatency) {
             targetLatency.latency = this.tunnel.targetLatency.latency;
         }
         let identify = null;
-        if (this.tunnel.identify) {
+        if (this.tunnel?.identify) {
             identify = {
                 type: this.tunnel.identify.type,
             };
@@ -169,53 +184,58 @@ class AgentSocket {
             checking: false,
             valid: false,
         };
-        if (this.tunnel.dns) {
+        if (this.tunnel?.dns) {
             dns.checking = this.tunnel.dns.checking;
             dns.valid = this.tunnel.dns.valid;
         }
-        this.send(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL, {
+        this.send(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL, {
             regionLatency,
             targetLatency,
             connections,
             identify,
             dns,
-            totalConnections: this.tunnel.totalConnections,
-            serve: this.tunnel.serve,
-            log: this.tunnel.log,
-            status: this.tunnel.status,
-            region: this.tunnel.region,
-            type: this.tunnel.type,
-            target: this.tunnel.target,
-            terminate: this.tunnel.terminate,
-            id: this.tunnel.id,
-            subdomain: this.tunnel.subdomain,
-            domain: this.tunnel.domain,
-            customDomain: this.tunnel.customDomain,
-            sshId: this.tunnel.sshId,
-            sshForwardPort: this.tunnel.sshForwardPort,
+            totalConnections: this.tunnel?.totalConnections,
+            serve: this.tunnel?.serve,
+            log: this.tunnel?.log,
+            status: this.tunnel?.status,
+            region: this.tunnel?.region,
+            type: this.tunnel?.type,
+            target: this.tunnel?.target,
+            terminate: this.tunnel?.terminate,
+            id: this.tunnel?.id,
+            subdomain: this.tunnel?.subdomain,
+            domain: this.tunnel?.domain,
+            sshId: this.tunnel?.sshId,
+            sshForwardPort: this.tunnel?.sshForwardPort,
         });
     }
     close() {
-        clearInterval(this.ts);
-        try {
-            this.socket.removeAllListeners();
-            this.socket.close();
-        }
-        catch {
-            // do nothing
+        if (this.ts) {
+            clearInterval(this.ts);
         }
         this.ts = null;
+        if (this.socket) {
+            try {
+                this.socket.removeAllListeners();
+                this.socket.close();
+            }
+            catch {
+                // do nothing
+            }
+        }
         this.socket = null;
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_OPEN, this.boundEventOpen);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_CLOSED, this.boundEventClosed);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_TCP_OPEN, this.boundEventTcpOpen);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_TCP_CLOSED, this.boundEventTcpClosed);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, this.boundEventHttpIdentified);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_HTTP_REQUEST, this.boundEventHttpRequest);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_HTTP_RESPONSE, this.boundEventHttpResponse);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_TLS_OPEN, this.boundEventTlsOpen);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_TLS_CLOSED, this.boundEventTlsClosed);
-        this.tunnel.removeListener(utils_1.TUNNEL_EVENT_STOPPED, this.boundEventStopped);
+        if (this.tunnel) {
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.OPEN, this.boundEventOpen);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.CLOSED, this.boundEventClosed);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TCP_OPEN, this.boundEventTcpOpen);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, this.boundEventTcpClosed);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, this.boundEventHttpIdentified);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, this.boundEventHttpRequest);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.HTTP_RESPONSE, this.boundEventHttpResponse);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TLS_OPEN, this.boundEventTlsOpen);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, this.boundEventTlsClosed);
+            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.STOPPED, this.boundEventStopped);
+        }
         this.tunnel = null;
     }
 }

package/distTs/src/agent/system.js

@@ -15,7 +15,8 @@ class AgentSystem {
         return Promise.resolve(false);
     }
     // extend
-    enable() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    enable(id, host, token, port, start, user, pass, debug) {
         return Promise.reject();
     }
     // extend
@@ -54,6 +55,7 @@ class AgentSystem {
     }
     extractArchive(source, dest) {
         return new Promise((resolve, reject) => {
+            // @ts-ignore
             import('@xhmikosr/decompress')
                 .then(({ default: decompress }) => {
                 decompress(source, dest)

package/distTs/src/agent/windows.js

@@ -137,21 +137,21 @@ class AgentWindows extends system_1.default {
     }
     nssm(cmd) {
         return new Promise((resolve, reject) => {
-            (0, child_process_1.exec)(`${this.getNssmBinaryPath()} ${cmd}`, (err, stdout, stderr) => {
+            (0, child_process_1.exec)(`${this.getNssmBinaryPath()} ${cmd}`, (err) => {
                 if (!err)
-                    resolve(stdout, stderr);
+                    resolve();
                 else
-                    reject(err, stderr);
+                    reject(err);
             });
         });
     }
     sc(cmd) {
         return new Promise((resolve, reject) => {
-            (0, child_process_1.exec)(`sc ${cmd}`, (err, stdout, stderr) => {
+            (0, child_process_1.exec)(`sc ${cmd}`, (err) => {
                 if (!err)
-                    resolve(stdout, stderr);
+                    resolve();
                 else
-                    reject(err, stderr);
+                    reject(err);
             });
         });
     }

package/distTs/src/command/agent/install.js

@@ -61,10 +61,10 @@ commandAgentInstall.action(async (options) => {
     if (isEnabled) {
         output_1.default.exitSuccess(texts_1.TXT_AGENT_ALREADY_ENABLED);
     }
-    let id;
-    let token;
+    let id = '';
+    let token = '';
     let agent;
-    let port = input_1.default.port(options.port);
+    const port = input_1.default.port(options.port);
     const target = !!options.target;
     if (options.id && options.token) {
         // if id & token passed set as it is
@@ -81,7 +81,7 @@ commandAgentInstall.action(async (options) => {
         // set global token if passed
         cfg_1.default.setToken(options.token);
     }
-    let host = cfg_1.default.getTokenHost();
+    const host = cfg_1.default.getTokenHost();
     if (!agent) {
         agent = await buddy_1.default.register(true, target, host, cfg_1.default.getToken(), (region) => {
             cfg_1.default.setRegionIfNotSet(region);

package/distTs/src/command/agent/run.js

@@ -14,6 +14,6 @@ commandAgentRun.option('--port <port>');
 commandAgentRun.option('--start <start>');
 commandAgentRun.action(async (options) => {
     logger_1.default.changeRootPath(manager_1.default.system.getAgentConfigDir());
-    manager_1.default.start(options.id, options.host, options.token, options.port, String(options.start) === 'true');
+    manager_1.default.start(options.id, options.host, options.token, parseInt(options.port, 10), String(options.start) === 'true');
 });
-module.exports = commandAgentRun;
+exports.default = commandAgentRun;

package/distTs/src/command/agent/status.js

@@ -7,24 +7,23 @@ const output_1 = __importDefault(require("../../output"));
 const texts_1 = require("../../texts");
 const utils_1 = require("../../utils");
 const manager_1 = __importDefault(require("../../agent/manager"));
-const texts_2 = require("../../texts");
-const utils_2 = require("../../utils");
-const commandAgentStatus = (0, utils_2.newCommand)('status', texts_1.DESC_COMMAND_AGENT_STATUS);
+const tunnel_1 = require("../../types/tunnel");
+const commandAgentStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_AGENT_STATUS);
 commandAgentStatus.action(async () => {
     const isEnabled = await manager_1.default.system.isEnabled();
     if (!isEnabled) {
         output_1.default.exitError(texts_1.ERR_AGENT_NOT_ENABLED);
     }
     if (!commandAgentStatus.agentStatus) {
-        output_1.default.exitError(texts_2.ERR_AGENT_NOT_RUNNING);
+        output_1.default.exitError(texts_1.ERR_AGENT_NOT_RUNNING);
     }
-    if (commandAgentStatus.agentStatus.status === utils_1.AGENT_STATUS_INITIALIZING) {
+    if (commandAgentStatus.agentStatus.status === tunnel_1.TUNNEL_AGENT_STATUS.INITIALIZING) {
         output_1.default.exitError(texts_1.TXT_AGENT_IS_ENABLED_AND_INITIALIZING);
     }
-    if (commandAgentStatus.agentStatus.status === utils_1.AGENT_STATUS_FETCH_FAILED) {
+    if (commandAgentStatus.agentStatus.status === tunnel_1.TUNNEL_AGENT_STATUS.FETCH_FAILED) {
         output_1.default.exitError(texts_1.TXT_AGENT_IS_ENABLED_AND_HAVE_TROUBLES);
     }
-    if (commandAgentStatus.agentStatus.status !== utils_1.AGENT_STATUS_ENABLED) {
+    if (commandAgentStatus.agentStatus.status !== tunnel_1.TUNNEL_AGENT_STATUS.ENABLED) {
         output_1.default.exitError(texts_1.TXT_AGENT_IS_DISABLED);
     }
     if (commandAgentStatus.agentStatus.started) {

package/distTs/src/command/agent/tunnel/http.js

@@ -8,20 +8,19 @@ const output_1 = __importDefault(require("../../../output"));
 const cfg_1 = __importDefault(require("../../../tunnel/cfg"));
 const texts_1 = require("../../../texts");
 const tunnel_1 = __importDefault(require("../../../agent/socket/tunnel"));
-const texts_2 = require("../../../texts");
 const manager_1 = __importDefault(require("../../../agent/manager"));
-const utils_2 = require("../../../utils");
 const agent_1 = __importDefault(require("../../../tunnel/api/agent"));
-const commandAgentTunnelHttp = (0, utils_2.getBasicCommandHttp)();
+const tunnel_2 = require("../../../types/tunnel");
+const commandAgentTunnelHttp = (0, utils_1.getBasicCommandHttp)();
 commandAgentTunnelHttp.description(texts_1.DESC_COMMAND_HTTP);
-commandAgentTunnelHttp.option('-f, --follow', texts_2.OPTION_FOLLOW);
+commandAgentTunnelHttp.option('-f, --follow', texts_1.OPTION_FOLLOW);
 commandAgentTunnelHttp.argument('[protocol://host:port]', texts_1.OPTION_TARGET);
 commandAgentTunnelHttp.action(async (target, options) => {
     const isEnabled = await manager_1.default.system.isEnabled();
     if (!isEnabled) {
         output_1.default.exitError(texts_1.ERR_AGENT_NOT_ENABLED);
     }
-    const prepared = await cfg_1.default.prepareTunnel(utils_1.TUNNEL_HTTP, target, options, true);
+    const prepared = await cfg_1.default.prepareTunnel(tunnel_2.TUNNEL_TYPE.HTTP, target, options, true);
     try {
         await output_1.default.spinner(texts_1.TXT_OPENING_TUNNEL);
         const json = manager_1.default.system.loadSystemConfig();