bdy 1.10.14-stage → 1.11.0-beta

package/distTs/bin/cli.js

@@ -2,4 +2,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 console.log = () => { }; // fix for termkit
-require("../src/index.js");
+require("../src/index");

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.10.14-stage",
+  "version": "1.11.0-beta",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {

package/distTs/src/agent/agent.js

@@ -0,0 +1,302 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const logger_1 = __importDefault(require("../logger"));
+const texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const tunnel_1 = __importDefault(require("../tunnel/tunnel"));
+const output_1 = __importDefault(require("../output"));
+const client_1 = __importDefault(require("./socket/client"));
+class Agent extends events_1.default {
+    constructor(id, host, token, service, target, api, disabled) {
+        super();
+        this.id = id;
+        this.host = host;
+        this.token = token;
+        this.service = service;
+        this.target = target;
+        this.disabled = disabled;
+        this.tunnels = [];
+        this.tunnelsUpdating = false;
+        this.started = false;
+        this.api = api;
+        this.manager = null;
+        this.onRefresh = null;
+        this.socket = new client_1.default(host, id, token);
+        this.socket.on(utils_1.SOCKET_IO_EVENT_FETCH_SUCCESS, (data) => this._onSocketFetch(data));
+        this.socket.on(utils_1.SOCKET_IO_EVENT_FETCH_FAILED, (err) => this._onSocketFetchFailed(err));
+        this.socket.on(utils_1.SOCKET_IO_EVENT_CONNECTED, () => this._onSocketConnected());
+        this.socket.on(utils_1.SOCKET_IO_EVENT_DISCONNECTED, () => this._onSocketDisconnected());
+        this.socket.on(utils_1.SOCKET_IO_EVENT_TUNNEL, (tunnel, action) => this._onSocketTunnel(tunnel, action));
+        this.socket.on(utils_1.SOCKET_IO_EVENT_AGENT, (agent, action) => this._onSocketAgent(agent, action));
+    }
+    destroy() {
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+        this.manager = null;
+        this.onRefresh = null;
+        this.api = null;
+        // musza byc manualnie wczesniej zniszczone to tylko czysci obiekt
+        this.tunnels = null;
+    }
+    _onSocketTunnel(data, action) {
+        if (action === 'DEL') {
+            this.destroyTunnel(data.id);
+            if (!this.service && this.tunnels.length <= 0)
+                output_1.default.exitError(texts_1.ERR_TUNNEL_REMOVED);
+        }
+        else {
+            logger_1.default.debug('Socket fetch tunnel after sync push');
+            this.socket.fetch(this.started, null, null, false, []);
+        }
+    }
+    async _onSocketAgent(data, action) {
+        if (action === 'DEL') {
+            if (this.manager) {
+                return this.manager.disableAgentAndExit(texts_1.ERR_AGENT_REMOVED);
+            }
+            output_1.default.exitError(texts_1.ERR_AGENT_REMOVED);
+        }
+        else {
+            this.target = !!data.target;
+            this.disabled = !!data.disabled;
+            if (data.disabled === this.started) {
+                await this.makeAction(data.disabled ? utils_1.AGENT_ACTION_STOP : utils_1.AGENT_ACTION_START);
+            }
+            else if (data.action) {
+                try {
+                    await this.makeAction(data.action);
+                }
+                catch (err) {
+                    logger_1.default.error('Agent sync error');
+                    logger_1.default.error(err);
+                }
+            }
+        }
+    }
+    _onSocketConnected() {
+        if (this.onRefresh)
+            this.onRefresh(true);
+    }
+    _onSocketDisconnected() {
+        if (this.onRefresh)
+            this.onRefresh(false);
+    }
+    async _onSocketFetch(data) {
+        try {
+            if (data.agent.action)
+                await this.makeAction(data.agent.action);
+            this.refreshTunnels(data.tunnels || []);
+        }
+        catch (err) {
+            logger_1.default.error('Fetch error');
+            logger_1.default.error(err);
+        }
+    }
+    _onSocketFetchFailed(err) {
+        if (err instanceof utils_1.ApiErrorAgentNotFound) {
+            if (this.manager) {
+                return this.manager.disableAgentAndExit(texts_1.ERR_AGENT_REMOVED);
+            }
+            output_1.default.exitError(texts_1.ERR_AGENT_REMOVED);
+        }
+        else {
+            logger_1.default.error(texts_1.LOG_ERROR_WHILE_REFRESHING_AGENT);
+            logger_1.default.error(err);
+        }
+    }
+    startRefreshingConfiguration(onRefresh) {
+        this.onRefresh = onRefresh;
+        if (this.onRefresh)
+            this.onRefresh(this.socket.connected);
+        this.refreshIn15();
+    }
+    async start() {
+        this.started = true;
+        this.tunnels.forEach((t) => {
+            t.start();
+        });
+        this.socket.fetch(this.started, '', null, true, this.getTunnelsUpdate());
+    }
+    async enable() {
+        this.disabled = false;
+        this.started = true;
+        this.tunnels.forEach((t) => {
+            t.start();
+        });
+        this.socket.fetch(this.started, '', false, true, this.getTunnelsUpdate());
+    }
+    async stop(clearAction = true) {
+        this.started = false;
+        this.tunnels.forEach((t) => {
+            t.stop();
+        });
+        this.socket.fetch(this.started, clearAction ? '' : null, null, false, this.getTunnelsUpdate());
+    }
+    async disable() {
+        this.disabled = true;
+        this.started = false;
+        this.tunnels.forEach((t) => {
+            t.stop();
+        });
+        this.socket.fetch(this.started, '', true, false, this.getTunnelsUpdate());
+    }
+    async restart() {
+        await this.stop(false);
+        await (0, utils_1.sleep)(100);
+        await this.start();
+    }
+    async delete() {
+        try {
+            await this.api.unregister(this.id, this.host, this.token);
+        }
+        catch {
+            // do nothing
+        }
+        process.exit(0);
+    }
+    refreshIn15(fetch = true, counter = 1) {
+        setTimeout(async () => {
+            try {
+                if (fetch || counter >= 3) {
+                    counter = 0;
+                    this.socket.fetch(this.started, null, null, false, this.getTunnelsUpdate());
+                }
+                else {
+                    this.update();
+                }
+            }
+            catch {
+                // do nothing
+            }
+            this.refreshIn15(false, counter + 1);
+        }, 15000);
+    }
+    httpRequest(tunnelId, logRequest) {
+        this.socket.request(tunnelId, logRequest);
+    }
+    update(force = false) {
+        this.socket.update(this.started, this.getTunnelsUpdate(), force);
+    }
+    async makeAction(action) {
+        if (action === utils_1.AGENT_ACTION_STOP) {
+            if (this.manager) {
+                return this.manager.agentStop();
+            }
+            return this.stop();
+        }
+        if (action === utils_1.AGENT_ACTION_START) {
+            if (this.manager) {
+                return this.manager.agentStart();
+            }
+            return this.start();
+        }
+        if (action === utils_1.AGENT_ACTION_RESTART) {
+            if (this.manager) {
+                return this.manager.agentRestart();
+            }
+            return this.restart();
+        }
+        if (action === utils_1.AGENT_ACTION_DELETE) {
+            if (this.manager) {
+                return this.manager.disableAgentAndExit(texts_1.ERR_AGENT_REMOVED);
+            }
+            return this.delete();
+        }
+    }
+    refreshTunnels(tunnels) {
+        if (this.tunnelsUpdating)
+            return;
+        this.tunnelsUpdating = true;
+        let hasTunnels = false;
+        let haveTunnels = false;
+        try {
+            const tt = [...this.tunnels];
+            hasTunnels = tt.length > 0;
+            haveTunnels = tunnels.length > 0;
+            if (hasTunnels) {
+                tt.forEach((tunnel) => {
+                    if (!tunnels.find((t) => t.id === tunnel.id)) {
+                        this.destroyTunnel(tunnel.id);
+                    }
+                });
+            }
+            if (haveTunnels) {
+                tunnels.forEach((data) => {
+                    let sshHostKey;
+                    if (this.manager)
+                        sshHostKey = this.manager.sshHostKey;
+                    const tunnel = tt.find((tunnel) => data.id === tunnel.id);
+                    if (!tunnel) {
+                        this.addTunnel(new tunnel_1.default({
+                            ...data,
+                            sshHostKey,
+                            agent: {
+                                id: this.id,
+                                host: this.host,
+                                token: this.token,
+                            },
+                        }));
+                    }
+                    else if (tunnel.hasChanged(data)) {
+                        tunnel.recreate(data);
+                    }
+                });
+            }
+        }
+        catch {
+            // do nothing
+        }
+        this.tunnelsUpdating = false;
+        if (!this.service && hasTunnels && !haveTunnels) {
+            output_1.default.exitError(texts_1.ERR_TUNNEL_REMOVED);
+        }
+    }
+    getTunnelsUpdate() {
+        const update = [];
+        this.tunnels.forEach((t) => {
+            update.push({
+                id: t.id,
+                active: t.status === utils_1.TUNNEL_OPEN,
+                regionLatency: t.regionLatency ? t.regionLatency.latency : -1,
+                targetLatency: t.targetLatency ? t.targetLatency.latency : -1,
+                totalConnections: t.totalConnections,
+                currentConnections: Object.keys(t.connections).length,
+                httpIdentified: t.identify ? t.identify.type : '',
+            });
+        });
+        return update;
+    }
+    addTunnel(tunnel) {
+        this.tunnels.push(tunnel);
+        if (this.started)
+            tunnel.start();
+        tunnel.on(utils_1.TUNNEL_EVENT_OPEN, () => this.update(true));
+        tunnel.on(utils_1.TUNNEL_EVENT_CLOSED, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_TCP_OPEN, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_TCP_CLOSED, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_TLS_OPEN, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_TLS_CLOSED, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_HTTP_OPEN, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_HTTP_CLOSED, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_STOPPED, () => this.update());
+        tunnel.on(utils_1.TUNNEL_EVENT_HTTP_REQUEST, (t, logRequest) => this.httpRequest(t.id, logRequest));
+    }
+    destroyTunnel(id) {
+        let tunnel = this.tunnels.find((t) => t.id === id);
+        if (!tunnel)
+            return null;
+        this.tunnels = this.tunnels.filter((t) => t.id !== tunnel.id);
+        tunnel.stop();
+        tunnel.removeAllListeners();
+        return tunnel;
+    }
+}
+exports.default = Agent;

package/distTs/src/agent/manager.js

@@ -3,21 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_js_1 = require("../utils.js");
+const utils_1 = require("../utils");
 const ws_1 = require("ws");
-const logger_js_1 = __importDefault(require("../logger.js"));
+const logger_1 = __importDefault(require("../logger"));
 const http_1 = __importDefault(require("http"));
-const output_js_1 = __importDefault(require("../output.js"));
-const texts_js_1 = require("../texts.js");
+const output_1 = __importDefault(require("../output"));
+const texts_1 = require("../texts");
 const windows_1 = __importDefault(require("./windows"));
 const linux_1 = __importDefault(require("./linux"));
 const system_1 = __importDefault(require("./system"));
 const osx_1 = __importDefault(require("./osx"));
-const buddy_js_1 = __importDefault(require("../api/buddy.js"));
-const socket_js_1 = __importDefault(require("./socket.js"));
+const buddy_1 = __importDefault(require("../tunnel/api/buddy"));
+const socket_1 = __importDefault(require("./socket"));
 class AgentManagerClass {
     constructor() {
-        this.status = utils_js_1.AGENT_STATUS_DISABLED;
+        this.status = utils_1.AGENT_STATUS_DISABLED;
         this.id = null;
         this.host = null;
         this.token = null;
@@ -27,13 +27,13 @@ class AgentManagerClass {
         this.agent = null;
         this.server = null;
         this.ws = null;
-        if ((0, utils_js_1.isOsx)()) {
+        if ((0, utils_1.isOsx)()) {
             this.system = new osx_1.default();
         }
-        else if ((0, utils_js_1.isLinux)()) {
+        else if ((0, utils_1.isLinux)()) {
             this.system = new linux_1.default();
         }
-        else if ((0, utils_js_1.isWindows)()) {
+        else if ((0, utils_1.isWindows)()) {
             this.system = new windows_1.default();
         }
         else {
@@ -45,26 +45,26 @@ class AgentManagerClass {
     }
     async tryFetch() {
         try {
-            this.agent = await buddy_js_1.default.fetchAgent(this.id, this.host, this.token);
+            this.agent = await buddy_1.default.fetchAgent(this.id, this.host, this.token);
             this.agent.manager = this;
             this.agent.startRefreshingConfiguration((success) => {
                 if (success)
-                    this.status = utils_js_1.AGENT_STATUS_ENABLED;
+                    this.status = utils_1.AGENT_STATUS_ENABLED;
                 else
-                    this.status = utils_js_1.AGENT_STATUS_FETCH_FAILED;
+                    this.status = utils_1.AGENT_STATUS_FETCH_FAILED;
             });
             if (this.shouldStart)
                 await this.agent.start();
-            this.status = utils_js_1.AGENT_STATUS_ENABLED;
+            this.status = utils_1.AGENT_STATUS_ENABLED;
         }
         catch (err) {
-            if (err instanceof utils_js_1.ApiErrorAgentNotFound) {
-                await this.disableAgentAndExit(texts_js_1.ERR_AGENT_NOT_FOUND);
+            if (err instanceof utils_1.ApiErrorAgentNotFound) {
+                await this.disableAgentAndExit(texts_1.ERR_AGENT_NOT_FOUND);
             }
             else {
-                output_js_1.default.normal(texts_js_1.AGENT_FETCH_RETRY);
-                this.status = utils_js_1.AGENT_STATUS_FETCH_FAILED;
-                await (0, utils_js_1.sleep)(3000);
+                output_1.default.normal(texts_1.AGENT_FETCH_RETRY);
+                this.status = utils_1.AGENT_STATUS_FETCH_FAILED;
+                await (0, utils_1.sleep)(3000);
                 return this.tryFetch();
             }
         }
@@ -88,7 +88,7 @@ class AgentManagerClass {
         const tunnels = [];
         if (this.agent) {
             this.agent.tunnels.forEach((tunnel) => {
-                if (tunnel.type === utils_js_1.TUNNEL_SSH)
+                if (tunnel.type === utils_1.TUNNEL_SSH)
                     return;
                 tunnels.push({
                     id: tunnel.id,
@@ -130,7 +130,7 @@ class AgentManagerClass {
             return;
         }
         try {
-            await buddy_js_1.default.enableTarget(this.id, this.host, this.token);
+            await buddy_1.default.enableTarget(this.id, this.host, this.token);
             this.agent.target = true;
         }
         catch (err) {
@@ -145,7 +145,7 @@ class AgentManagerClass {
             return;
         }
         try {
-            await buddy_js_1.default.disableTarget(this.id, this.host, this.token);
+            await buddy_1.default.disableTarget(this.id, this.host, this.token);
             this.agent.target = false;
         }
         catch (err) {
@@ -158,9 +158,9 @@ class AgentManagerClass {
         this.serverOutput(res, {
             id: this.id,
             status: this.status,
-            version: (0, utils_js_1.getVersion)(),
+            version: (0, utils_1.getVersion)(),
             started: this.shouldStart,
-            enabled: this.status === utils_js_1.AGENT_STATUS_ENABLED,
+            enabled: this.status === utils_1.AGENT_STATUS_ENABLED,
         });
     }
     processBody(req) {
@@ -199,7 +199,7 @@ class AgentManagerClass {
             return;
         }
         try {
-            await buddy_js_1.default.removeTunnel(this.id, tunnel.id, this.host, this.token);
+            await buddy_1.default.removeTunnel(this.id, tunnel.id, this.host, this.token);
         }
         catch (err) {
             this.serverError(res, err.message);
@@ -213,11 +213,11 @@ class AgentManagerClass {
         let saved = await this.agentStop();
         if (!saved)
             return false;
-        await (0, utils_js_1.sleep)(100);
+        await (0, utils_1.sleep)(100);
         return await this.agentStart();
     }
     async disableAgentAndExit(txt) {
-        logger_js_1.default.error(txt);
+        logger_1.default.error(txt);
         try {
             await this.system.disable();
         }
@@ -225,7 +225,7 @@ class AgentManagerClass {
             // do nothing
         }
         try {
-            await buddy_js_1.default.unregister(this.id, this.host, this.token);
+            await buddy_1.default.unregister(this.id, this.host, this.token);
         }
         catch {
             // do nothing
@@ -242,7 +242,7 @@ class AgentManagerClass {
         catch {
             // do nothing
         }
-        output_js_1.default.exitError(txt);
+        output_1.default.exitError(txt);
     }
     async agentStop() {
         const saved = this.resaveAgentConfig(false, true);
@@ -370,7 +370,7 @@ class AgentManagerClass {
         }
         let tunnel;
         try {
-            tunnel = await buddy_js_1.default.addTunnel(this.id, this.host, this.token, data, this.sshHostKey);
+            tunnel = await buddy_1.default.addTunnel(this.id, this.host, this.token, data, this.sshHostKey);
         }
         catch (err) {
             this.serverError(res, err.message);
@@ -383,7 +383,7 @@ class AgentManagerClass {
         });
     }
     async processRequest(req, res) {
-        logger_js_1.default.info((0, texts_js_1.LOG_REQUEST)(req.url));
+        logger_1.default.info((0, texts_1.LOG_REQUEST)(req.url));
         if (req.url === '/status')
             return this.processStatus(res);
         if (req.url === '/target')
@@ -411,7 +411,7 @@ class AgentManagerClass {
         this.server404(res);
     }
     processUpgrade(req, socket, head) {
-        logger_js_1.default.info((0, texts_js_1.LOG_REQUEST)(req.url));
+        logger_1.default.info((0, texts_1.LOG_REQUEST)(req.url));
         const url = new URL(req.url, 'http://localhost');
         const id = url.searchParams.get('id');
         if (url.pathname === '/tunnel' && id) {
@@ -428,11 +428,11 @@ class AgentManagerClass {
             return;
         }
         const tunnel = this.agent.tunnels.find((t) => t.id === id);
-        if (!tunnel || tunnel.type === utils_js_1.TUNNEL_SSH) {
+        if (!tunnel || tunnel.type === utils_1.TUNNEL_SSH) {
             con.close();
             return;
         }
-        new socket_js_1.default(con, tunnel);
+        new socket_1.default(con, tunnel);
     }
     createServer() {
         this.server = http_1.default.createServer((req, res) => this.processRequest(req, res));
@@ -441,10 +441,10 @@ class AgentManagerClass {
         this.server.on('upgrade', (req, socket, head) => this.processUpgrade(req, socket, head));
         this.server.listen(this.port, async (err) => {
             if (err) {
-                await this.disableAgentAndExit(texts_js_1.LOG_ERROR_STARTING_AGENT_SERVER);
+                await this.disableAgentAndExit(texts_1.LOG_ERROR_STARTING_AGENT_SERVER);
             }
             else {
-                logger_js_1.default.info(texts_js_1.LOG_AGENT_SERVER_STARTED);
+                logger_1.default.info(texts_1.LOG_AGENT_SERVER_STARTED);
             }
         });
     }
@@ -461,7 +461,7 @@ class AgentManagerClass {
                 this.shouldStart = shouldStart;
             }
             if (!this.sshHostKey)
-                this.sshHostKey = (0, utils_js_1.createSshHostKey)();
+                this.sshHostKey = (0, utils_1.createSshHostKey)();
         }
         else {
             // save from param
@@ -477,23 +477,23 @@ class AgentManagerClass {
         }
     }
     async load(id, host, token, port, start) {
-        this.status = utils_js_1.AGENT_STATUS_INITIALIZING;
+        this.status = utils_1.AGENT_STATUS_INITIALIZING;
         this.id = id;
         this.host = host;
         this.token = token;
         this.port = parseInt(port, 10);
         if (!this.id || !this.token || !this.host || !this.port) {
-            await this.disableAgentAndExit(texts_js_1.ERR_AGENT_NOT_REGISTERED);
+            await this.disableAgentAndExit(texts_1.ERR_AGENT_NOT_REGISTERED);
             return;
         }
         const ok = this.resaveAgentConfig(start);
         if (!ok) {
-            await this.disableAgentAndExit(texts_js_1.ERR_SAVING_AGENT_CONFIG);
+            await this.disableAgentAndExit(texts_1.ERR_SAVING_AGENT_CONFIG);
             return;
         }
         this.createServer();
         await this.tryFetch();
-        logger_js_1.default.info(texts_js_1.LOG_AGENT_STARTED);
+        logger_1.default.info(texts_1.LOG_AGENT_STARTED);
     }
 }
 const AgentManager = new AgentManagerClass();