bdy 1.8.3-dev → 1.8.4-dev

package/distTs/src/agent/windows.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const system_1 = __importDefault(require("./system"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const logger_1 = __importDefault(require("../logger"));
+const texts_1 = require("../texts");
+class AgentWindows extends system_1.default {
+    hasAdminRights() {
+        return new Promise((resolve) => {
+            (0, child_process_1.exec)('net session', (err) => {
+                resolve(!err);
+            });
+        });
+    }
+    isSupported() {
+        return Promise.resolve(process.arch === 'x64');
+    }
+    isEnabled() {
+        return new Promise((resolve) => {
+            this.sc('query bdy')
+                .then(() => {
+                resolve(true);
+            })
+                .catch(() => {
+                resolve(false);
+            });
+        });
+    }
+    getBinaryArchive() {
+        return 'win-x64.zip';
+    }
+    getSystemConfigDir() {
+        return 'C:\\ProgramData\\bdy';
+    }
+    getSystemConfigPath() {
+        return path_1.default.join(this.getSystemConfigDir(), 'agent.json');
+    }
+    getNssmArchivePath() {
+        return path_1.default.join(this.getSystemConfigDir(), 'nssm.zip');
+    }
+    downloadNssm() {
+        return this.downloadFile('https://es.buddy.works/bdy/nssm.zip', this.getNssmArchivePath());
+    }
+    extractNssm() {
+        return this.extractArchive(this.getNssmArchivePath(), this.getSystemConfigDir());
+    }
+    clearNssmExtract() {
+        (0, fs_1.rmSync)(path_1.default.join(this.getSystemConfigDir(), '__MACOSX'), {
+            force: true,
+            recursive: true,
+        });
+    }
+    getNssmBinaryPath() {
+        return path_1.default.join(this.getSystemConfigDir(), 'nssm', 'win64', 'nssm.exe');
+    }
+    getSystemBinaryPath() {
+        return path_1.default.join(this.getSystemConfigDir(), 'bdy.exe');
+    }
+    clearSystemFiles() {
+        (0, fs_1.rmSync)(this.getSystemBinaryPath(), { force: true });
+        (0, fs_1.rmSync)(this.getSystemConfigPath(), { force: true });
+        (0, fs_1.rmSync)(path_1.default.join(this.getSystemConfigDir(), 'nssm'), {
+            force: true,
+            recursive: true,
+        });
+    }
+    async update() {
+        try {
+            logger_1.default.info(texts_1.LOG_AGENT_STOPPING_SYSTEM);
+            await this.nssm('stop bdy');
+            logger_1.default.info(texts_1.LOG_AGENT_SYSTEM_DIR);
+            await this.ensureSystemConfigDir();
+            logger_1.default.info(texts_1.LOG_AGENT_DOWNLOADING_ARCHIVE);
+            await this.downloadBinaryArchive();
+            logger_1.default.info(texts_1.LOG_AGENT_EXTRACTING_ARCHIVE);
+            await this.extractBinaryArchive();
+            try {
+                logger_1.default.info(texts_1.LOG_AGENT_STARTING_SYSTEM);
+                await this.nssm('start bdy');
+            }
+            catch {
+                // do nothing, it will throw operation pending
+            }
+        }
+        catch (err) {
+            logger_1.default.error(err);
+            throw err;
+        }
+    }
+    async enable(id, host, token, port, start, user, pass, debug) {
+        try {
+            logger_1.default.info(texts_1.LOG_AGENT_SYSTEM_DIR);
+            await this.ensureSystemConfigDir();
+            logger_1.default.info(texts_1.LOG_AGENT_NSSM_DOWNLOADING);
+            await this.downloadNssm();
+            logger_1.default.info(texts_1.LOG_AGENT_NSSM_EXTRACTING);
+            await this.extractNssm();
+            logger_1.default.info(texts_1.LOG_AGENT_NSSM_CLEARING);
+            this.clearNssmExtract();
+            logger_1.default.info(texts_1.LOG_AGENT_DOWNLOADING_ARCHIVE);
+            await this.downloadBinaryArchive();
+            logger_1.default.info(texts_1.LOG_AGENT_EXTRACTING_ARCHIVE);
+            await this.extractBinaryArchive();
+            logger_1.default.info(texts_1.LOG_AGENT_ENABLING_SYSTEM);
+            await this.nssm(`install bdy ${this.getSystemBinaryPath()}`);
+            await this.nssm(`set bdy AppParameters agent run --id="${id}" --host="${host}" --token="${token}" --port=${port} --start=${!!start}`);
+            await this.nssm('set bdy DisplayName Buddy Tunnel Agent');
+            await this.nssm('set bdy AppThrottle 5000');
+            await this.nssm('set bdy AppRestartDelay 0');
+            await this.nssm('set bdy AppExit Default Restart');
+            await this.nssm('set bdy Start SERVICE_AUTO_START');
+            await this.nssm(`set bdy AppEnvironmentExtra DEBUG=${debug ? 1 : 0}`);
+            if (user && pass) {
+                await this.nssm(`set bdy ObjectName ${user} ${pass}`);
+            }
+            this.nssm('start bdy').then().catch();
+            logger_1.default.info(texts_1.LOG_AGENT_ENABLED);
+        }
+        catch (err) {
+            logger_1.default.info(err);
+            throw err;
+        }
+    }
+    async disable() {
+        try {
+            await this.nssm('stop bdy');
+        }
+        catch {
+            // do nothing
+        }
+        await this.nssm('remove bdy confirm');
+    }
+    nssm(cmd) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(`${this.getNssmBinaryPath()} ${cmd}`, (err, stdout, stderr) => {
+                if (!err)
+                    resolve(stdout, stderr);
+                else
+                    reject(err, stderr);
+            });
+        });
+    }
+    sc(cmd) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(`sc ${cmd}`, (err, stdout, stderr) => {
+                if (!err)
+                    resolve(stdout, stderr);
+                else
+                    reject(err, stderr);
+            });
+        });
+    }
+}
+exports.default = AgentWindows;

package/distTs/src/agent.js

@@ -0,0 +1,237 @@
+"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_js_1 = __importDefault(require("./logger.js"));
+const texts_js_1 = require("./texts.js");
+const utils_js_1 = require("./utils.js");
+const tunnel_js_1 = __importDefault(require("./tunnel.js"));
+const output_js_1 = __importDefault(require("./output.js"));
+const socket_1 = __importDefault(require("./api/socket"));
+class Agent extends events_1.default {
+    constructor(id, host, token, service, api) {
+        super();
+        this.id = id;
+        this.host = host;
+        this.token = token;
+        this.service = service;
+        this.tunnels = [];
+        this.started = false;
+        this.api = api;
+        this.manager = null;
+        this.onRefresh = null;
+        this.socket = new socket_1.default(host, id, token);
+        this.socket.on(utils_js_1.SOCKET_IO_EVENT_FETCH_SUCCESS, (data) => this._onSocketFetch(data));
+        this.socket.on(utils_js_1.SOCKET_IO_EVENT_FETCH_FAILED, (err) => this._onSocketFetchFailed(err));
+        this.socket.on(utils_js_1.SOCKET_IO_EVENT_CONNECTED, () => this._onSocketConnected());
+        this.socket.on(utils_js_1.SOCKET_IO_EVENT_DISCONNECTED, () => this._onSocketDisconnected());
+        this.socket.on(utils_js_1.SOCKET_IO_EVENT_TUNNEL, (tunnel, action) => this._onSocketTunnel(tunnel, action));
+        this.socket.on(utils_js_1.SOCKET_IO_EVENT_AGENT, (agent, action) => this._onSocketAgent(agent, action));
+    }
+    _onSocketTunnel(data, action) {
+        if (action === 'DEL') {
+            this.destroyTunnel(data.id);
+            if (!this.service && this.tunnels.length <= 0)
+                output_js_1.default.exitError(texts_js_1.ERR_TUNNEL_REMOVED);
+        }
+        else {
+            logger_js_1.default.debug('Socket fetch tunnel after sync push');
+            this.socket.fetch(this.started, null, false, []);
+        }
+    }
+    async _onSocketAgent(data, action) {
+        if (action === 'DEL') {
+            if (this.manager)
+                return this.manager.disableAgentAndExit(texts_js_1.ERR_AGENT_REMOVED);
+            output_js_1.default.exitError(texts_js_1.ERR_AGENT_REMOVED);
+        }
+        else if (data.action) {
+            try {
+                await this.makeAction(data.action);
+            }
+            catch (err) {
+                logger_js_1.default.error('Agent sync error');
+                logger_js_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_js_1.default.error('Fetch error');
+            logger_js_1.default.error(err);
+        }
+    }
+    _onSocketFetchFailed(err) {
+        if (err instanceof utils_js_1.ApiErrorAgentNotFound) {
+            if (this.manager)
+                return this.manager.disableAgentAndExit(texts_js_1.ERR_AGENT_REMOVED);
+            output_js_1.default.exitError(texts_js_1.ERR_AGENT_REMOVED);
+        }
+        else {
+            logger_js_1.default.error(texts_js_1.LOG_ERROR_WHILE_REFRESHING_AGENT);
+            logger_js_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, '', true, this.getTunnelsUpdate());
+    }
+    async stop(clearAction = true) {
+        this.started = false;
+        this.tunnels.forEach((t) => {
+            t.stop();
+        });
+        this.socket.fetch(this.started, clearAction ? '' : null, false, this.getTunnelsUpdate());
+    }
+    async restart() {
+        await this.stop(false);
+        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) {
+        setTimeout(async () => {
+            if (fetch)
+                this.socket.fetch(this.started, null, false, this.getTunnelsUpdate());
+            else
+                this.update();
+            this.refreshIn15(false);
+        }, 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_js_1.AGENT_ACTION_STOP) {
+            if (this.manager)
+                return this.manager.agentStop();
+            else
+                return this.stop();
+        }
+        if (action === utils_js_1.AGENT_ACTION_START) {
+            if (this.manager)
+                return this.manager.agentStart();
+            else
+                return this.start();
+        }
+        if (action === utils_js_1.AGENT_ACTION_RESTART) {
+            if (this.manager)
+                return this.manager.agentRestart();
+            else
+                return this.restart();
+        }
+        if (action === utils_js_1.AGENT_ACTION_DELETE) {
+            if (this.manager)
+                return this.manager.disableAgentAndExit(texts_js_1.ERR_AGENT_REMOVED);
+            else
+                return this.delete();
+        }
+    }
+    refreshTunnels(tunnels) {
+        const tt = this.tunnels;
+        const hasTunnels = tt.length > 0;
+        const 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_js_1.default({
+                        ...data,
+                        sshHostKey,
+                    }));
+                }
+                else if (tunnel.hasChanged(data)) {
+                    tunnel.recreate(data);
+                }
+            });
+        }
+        if (!this.service && hasTunnels && !haveTunnels) {
+            output_js_1.default.exitError(texts_js_1.ERR_TUNNEL_REMOVED);
+        }
+    }
+    getTunnelsUpdate() {
+        const update = [];
+        this.tunnels.forEach((t) => {
+            update.push({
+                id: t.id,
+                active: t.status === utils_js_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_js_1.TUNNEL_EVENT_OPEN, () => this.update(true));
+        tunnel.on(utils_js_1.TUNNEL_EVENT_CLOSED, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_TCP_OPEN, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_TCP_CLOSED, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_TLS_OPEN, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_TLS_CLOSED, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_HTTP_IDENTIFIED, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_HTTP_OPEN, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_HTTP_CLOSED, () => this.update());
+        tunnel.on(utils_js_1.TUNNEL_EVENT_STOPPED, () => this.update());
+        tunnel.on(utils_js_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/api/agent.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_js_1 = __importDefault(require("../logger.js"));
+const texts_js_1 = require("../texts.js");
+const ws_1 = require("ws");
+const TIMEOUT = 120000;
+const openSocket = (port, path) => {
+    return new Promise((resolve, reject) => {
+        const ws = new ws_1.WebSocket(`ws://localhost:${port}${path}`);
+        ws.on('error', () => {
+            reject(new Error(texts_js_1.ERR_FAILED_TO_CONNECT_TO_AGENT));
+        });
+        ws.on('open', () => {
+            resolve(ws);
+        });
+    });
+};
+const makeRequest = async (port, path, body) => {
+    const c = new AbortController();
+    setTimeout(() => {
+        c.abort();
+    }, TIMEOUT);
+    const response = await fetch(`http://localhost:${port}${path}`, {
+        body: body ? JSON.stringify(body) : null,
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+        signal: c.signal,
+    });
+    if (response.status === 404) {
+        throw new Error(texts_js_1.ERR_NOT_FOUND);
+    }
+    if (response.status === 400) {
+        const data = await response.json();
+        throw new Error(data.message);
+    }
+    if (response.status !== 200) {
+        throw new Error(texts_js_1.ERR_SWW);
+    }
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch (err) {
+        logger_js_1.default.error(texts_js_1.LOG_ERROR);
+        logger_js_1.default.error(err);
+        throw new Error(texts_js_1.ERR_FAILED_TO_CONNECT_TO_AGENT);
+    }
+    return data;
+};
+class ApiAgent {
+    constructor(port) {
+        this.port = port;
+    }
+    async fetchStatus() {
+        return makeRequest(this.port, '/status');
+    }
+    async addTunnel(data) {
+        return makeRequest(this.port, '/tunnel/add', data);
+    }
+    async fetchTunnels() {
+        return makeRequest(this.port, '/tunnels');
+    }
+    async stopTunnel(id) {
+        return makeRequest(this.port, '/tunnel/stop', {
+            id,
+        });
+    }
+    async startAgent() {
+        return makeRequest(this.port, '/agent/start');
+    }
+    async restartAgent() {
+        return makeRequest(this.port, '/agent/restart');
+    }
+    async stopAgent() {
+        return makeRequest(this.port, '/agent/stop');
+    }
+    async socketTunnel(id) {
+        return openSocket(this.port, `/tunnel?id=${encodeURIComponent(id)}`);
+    }
+}
+exports.default = ApiAgent;

package/distTs/src/api/buddy.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const https_1 = require("https");
+const tunnel_js_1 = __importDefault(require("../tunnel.js"));
+const logger_js_1 = __importDefault(require("../logger.js"));
+const agent_js_1 = __importDefault(require("../agent.js"));
+const utils_1 = require("../utils");
+const texts_js_1 = require("../texts.js");
+const TIMEOUT = 120000;
+const nodeFetch = (url, opts) => {
+    return new Promise((resolve, reject) => {
+        import('node-fetch')
+            .then(({ default: fetch }) => {
+            fetch(url, opts).then(resolve).catch(reject);
+        })
+            .catch(reject);
+    });
+};
+const makeRequest = async (host, path, body, method = 'POST', respAsJson = true, timeout = TIMEOUT) => {
+    let data;
+    try {
+        const c = new AbortController();
+        setTimeout(() => {
+            c.abort();
+        }, timeout);
+        const response = await nodeFetch(`${host}${path}`, {
+            body: body ? JSON.stringify(body) : null,
+            headers: body ? { 'Content-Type': 'application/json' } : null,
+            method,
+            signal: c.signal,
+            agent: new https_1.Agent({
+                rejectUnauthorized: false,
+            }),
+        });
+        if (respAsJson)
+            data = await response.json();
+        else
+            data = await response.text();
+    }
+    catch {
+        throw new utils_1.ApiErrorFailedToConnect(host);
+    }
+    if (respAsJson) {
+        if (data.code !== 200) {
+            throw (0, utils_1.apiErrorCodeToClass)(data.result.code, host);
+        }
+        return data.result;
+    }
+    else {
+        return data;
+    }
+};
+class ApiBuddyClass {
+    async register(service, host, token, onDefaultRegion) {
+        const version = (0, utils_1.getVersion)();
+        const hostname = (0, utils_1.getHostname)();
+        const platform = (0, utils_1.getPlatform)();
+        logger_js_1.default.info(texts_js_1.LOG_REGISTERING_AGENT);
+        const r = await makeRequest(host, '/tunnel/agent/add', {
+            token,
+            version,
+            hostname,
+            platform,
+            service,
+        });
+        logger_js_1.default.info((0, texts_js_1.LOG_AGENT_REGISTERED)(r.id));
+        logger_js_1.default.info((0, texts_js_1.LOG_REGION_DETECTED)(r.region));
+        if (onDefaultRegion)
+            onDefaultRegion(r.region);
+        return new agent_js_1.default(r.id, host, r.token, service, this);
+    }
+    async unregister(id, host, token) {
+        logger_js_1.default.info(texts_js_1.LOG_UNREGISTERING_AGENT);
+        await makeRequest(host, '/tunnel/agent/remove', {
+            token,
+            id,
+        });
+        return true;
+    }
+    async fetchAgent(id, host, token) {
+        logger_js_1.default.info(texts_js_1.LOG_GETTING_AGENT);
+        const r = await makeRequest(host, '/tunnel/agent/fetch', {
+            token,
+            id,
+        });
+        return new agent_js_1.default(r.id, host, token, r.service, this);
+    }
+    async addTunnel(agentId, host, token, prepared, sshHostKey) {
+        logger_js_1.default.info(texts_js_1.LOG_REGISTERING_TUNNEL);
+        const config = await makeRequest(host, '/tunnel/add', {
+            ...prepared,
+            token,
+            agentId,
+        });
+        logger_js_1.default.info((0, texts_js_1.LOG_TUNNEL_REGISTERED)(config.id));
+        return new tunnel_js_1.default({
+            ...config,
+            sshHostKey,
+        });
+    }
+    async removeTunnel(agentId, tunnelId, host, token) {
+        logger_js_1.default.info(texts_js_1.LOG_REMOVING_TUNNEL);
+        await makeRequest(host, '/tunnel/remove', {
+            agentId,
+            tunnelId,
+            token,
+        });
+    }
+    async fetchMyIp() {
+        return makeRequest('https://es.buddy.works', '/ip', null, 'GET', false);
+    }
+}
+const ApiBuddy = new ApiBuddyClass();
+exports.default = ApiBuddy;