bdy 1.8.3-dev → 1.8.4-dev

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

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const texts_js_1 = require("../../texts.js");
+const events_1 = __importDefault(require("events"));
+const utils_1 = require("../../utils");
+class AgentSocketTunnel extends events_1.default {
+    constructor(socket, id) {
+        super();
+        this.id = id;
+        this.ready = false;
+        this.closed = false;
+        this.socket = socket;
+        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,
+        }));
+    }
+    close() {
+        if (this.socket) {
+            this.socket.close();
+        }
+    }
+    onTunnelRequests(data) {
+        this.httpLog = {
+            requests: data.requests.map((r) => {
+                r.requestBody = {
+                    data: Buffer.from(r.requestBody.data, 'base64'),
+                    tooLarge: r.requestBody.tooLarge,
+                    realLength: r.requestBody.realLength,
+                };
+                r.responseBody = {
+                    data: Buffer.from(r.responseBody.data, 'base64'),
+                    tooLarge: r.responseBody.tooLarge,
+                    realLength: r.responseBody.realLength,
+                };
+                return r;
+            }),
+        };
+    }
+    onTunnelData(data) {
+        if (data.regionLatency)
+            this.regionLatency = data.regionLatency;
+        if (data.targetLatency)
+            this.targetLatency = data.targetLatency;
+        if (data.identify)
+            this.identify = data.identify;
+        if (data.dns)
+            this.dns = data.dns;
+        if (data.connections)
+            this.connections = data.connections;
+        this.totalConnections = data.totalConnections;
+        this.serve = data.serve;
+        this.log = data.log;
+        this.status = data.status;
+        this.region = data.region;
+        this.type = data.type;
+        this.target = data.target;
+        this.terminate = data.terminate;
+        this.id = data.id;
+        this.subdomain = data.subdomain;
+        this.sshId = data.sshId;
+        this.domain = data.domain;
+        this.sshForwardPort = data.sshForwardPort;
+    }
+    upsertHttpLog(data) {
+        if (!this.httpLog || !this.httpLog.requests || !this.log)
+            return;
+        /**
+         * @type {object}
+         */
+        const r = this.httpLog.requests.find((r) => r.id === data.id);
+        if (!r) {
+            data.requestBody = {
+                data: Buffer.from(data.requestBody.data, 'base64'),
+                tooLarge: data.requestBody.tooLarge,
+                realLength: data.requestBody.realLength,
+            };
+            data.responseBody = {
+                data: Buffer.from(data.responseBody.data, 'base64'),
+                tooLarge: data.responseBody.tooLarge,
+                realLength: data.responseBody.realLength,
+            };
+            this.httpLog.requests.unshift(data);
+        }
+        else {
+            r.finished = data.finished;
+            r.time = data.time;
+            r.httpVersion = data.httpVersion;
+            r.requestBody = {
+                data: Buffer.from(data.requestBody.data, 'base64'),
+                tooLarge: data.requestBody.tooLarge,
+                realLength: data.requestBody.realLength,
+            };
+            r.responseBody = {
+                data: Buffer.from(data.responseBody.data, 'base64'),
+                tooLarge: data.responseBody.tooLarge,
+                realLength: data.responseBody.realLength,
+            };
+            r.headers = data.headers;
+            r.status = data.status;
+            r.url = data.url;
+            r.method = data.method;
+        }
+        if (this.httpLog.requests.length > utils_1.TUNNEL_HTTP_LOG_MAX_REQUESTS)
+            this.httpLog.requests.pop();
+    }
+    onMessage(msg) {
+        try {
+            const json = JSON.parse(msg.toString('utf8'));
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL) {
+                this.onTunnelData(json);
+                this.ready = true;
+                return;
+            }
+            if (json.message === utils_1.AGENT_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);
+                return;
+            }
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED) {
+                this.emit(utils_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);
+                return;
+            }
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED) {
+                this.emit(utils_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);
+                return;
+            }
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED) {
+                this.emit(utils_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);
+                return;
+            }
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST) {
+                this.upsertHttpLog(json.logRequest);
+                this.emit(utils_1.TUNNEL_EVENT_HTTP_REQUEST, json, json.logRequest);
+                return;
+            }
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE) {
+                this.upsertHttpLog(json.logRequest);
+                this.emit(utils_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);
+                this.close();
+            }
+        }
+        catch {
+            this.close();
+        }
+    }
+    onClose() {
+        this.emit(utils_1.TUNNEL_EVENT_STOPPED);
+        try {
+            this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        catch {
+            // do nothing
+        }
+        this.closed = true;
+        this.socket = null;
+    }
+    retryHttpLogRequest(logRequest) {
+        if (this.socket) {
+            this.socket.send(JSON.stringify({
+                message: utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY,
+                logRequest,
+            }));
+        }
+    }
+    waitForReady() {
+        return new Promise((resolve, reject) => {
+            const ts1 = setInterval(() => {
+                if (this.ready) {
+                    clearInterval(ts1);
+                    clearTimeout(ts2);
+                    resolve();
+                }
+                else if (this.closed) {
+                    clearInterval(ts1);
+                    clearTimeout(ts2);
+                    reject(new Error((0, texts_js_1.ERR_TUNNEL_NOT_FOUND)(this.id)));
+                }
+            }, 100);
+            const ts2 = setTimeout(() => {
+                clearInterval(ts1);
+                clearTimeout(ts2);
+                reject(new Error((0, texts_js_1.ERR_TUNNEL_NOT_FOUND)(this.id)));
+            }, 3000);
+        });
+    }
+}
+exports.default = AgentSocketTunnel;

package/distTs/src/agent/socket.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class AgentSocket {
+    constructor(socket, tunnel) {
+        this.tunnel = tunnel;
+        this.socket = socket;
+        this.ready = false;
+        this.socket.on('close', () => this.close());
+        this.socket.on('message', (msg) => this.onMessage(msg));
+        this.boundEventStopped = (t) => this.tunnelStopped(t);
+        this.boundEventOpen = (t) => this.tunnelOpen(t);
+        this.boundEventClosed = (t) => this.tunnelClosed(t);
+        this.boundEventTcpOpen = (t) => this.tunnelTcpOpen(t);
+        this.boundEventTcpClosed = (t) => this.tunnelTcpClosed(t);
+        this.boundEventTlsOpen = (t) => this.tunnelTlsOpen(t);
+        this.boundEventTlsClosed = (t) => this.tunnelTlsClosed(t);
+        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);
+    }
+    onMessage(message) {
+        try {
+            const json = JSON.parse(message.toString('utf8'));
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_READY) {
+                this.ready = true;
+                this.ts = setInterval(() => {
+                    this.sendTunnel();
+                }, 100);
+                this.sendTunnel();
+                this.sendRequests();
+                return;
+            }
+            if (json.message === utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY &&
+                this.ready) {
+                this.retryHttpRequest(json.logRequest);
+            }
+        }
+        catch {
+            // do nothing
+        }
+    }
+    retryHttpRequest(logRequest) {
+        this.tunnel.retryHttpLogRequest(logRequest);
+    }
+    send(message, data = {}) {
+        if (this.socket && this.ready) {
+            this.socket.send(JSON.stringify({
+                message,
+                ...data,
+            }));
+        }
+    }
+    sendEvent(message, t, data = {}) {
+        this.send(message, {
+            type: t.type,
+            serve: t.serve,
+            target: t.target,
+            subdomain: t.subdomain,
+            domain: t.domain,
+            sshId: t.sshId,
+            sshForwardPort: t.sshForwardPort,
+            ...data,
+        });
+    }
+    tunnelOpen(t) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_OPEN, t);
+    }
+    tunnelClosed(t) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED, t);
+    }
+    tunnelTcpOpen(t) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN, t);
+    }
+    tunnelTcpClosed(t) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED, t);
+    }
+    tunnelTlsOpen(t) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN, t);
+    }
+    tunnelTlsClosed(t) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED, t);
+    }
+    tunnelHttpIdentified(t, type) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED, t, {
+            identify: type,
+        });
+    }
+    logRequestToSocket(logRequest) {
+        return {
+            id: logRequest.id,
+            finished: logRequest.finished,
+            time: logRequest.time,
+            httpVersion: logRequest.httpVersion,
+            requestBody: {
+                data: logRequest.requestBody.data.toString('base64'),
+                tooLarge: logRequest.requestBody.tooLarge,
+                realLength: logRequest.requestBody.realLength,
+            },
+            responseBody: {
+                data: logRequest.responseBody.data.toString('base64'),
+                tooLarge: logRequest.responseBody.tooLarge,
+                realLength: logRequest.responseBody.realLength,
+            },
+            headers: logRequest.headers,
+            status: logRequest.status,
+            url: logRequest.url,
+            method: logRequest.method,
+        };
+    }
+    tunnelHttpRequest(t, logRequest) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST, t, {
+            logRequest: this.logRequestToSocket(logRequest),
+        });
+    }
+    tunnelHttpResponse(t, logRequest) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE, t, {
+            logRequest: this.logRequestToSocket(logRequest),
+        });
+    }
+    tunnelStopped(t) {
+        this.sendEvent(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED, t);
+        this.close();
+    }
+    sendRequests() {
+        let requests = [];
+        if (this.tunnel.httpLog) {
+            requests = this.tunnel.httpLog.requests.map((lr) => this.logRequestToSocket(lr));
+        }
+        this.send(utils_1.AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS, {
+            requests,
+        });
+    }
+    sendTunnel() {
+        const connections = {};
+        Object.keys(this.tunnel.connections).forEach((id) => {
+            connections[id] = true;
+        });
+        const regionLatency = {
+            latency: -1,
+        };
+        if (this.tunnel.regionLatency) {
+            regionLatency.latency = this.tunnel.regionLatency.latency;
+        }
+        const targetLatency = {
+            latency: -1,
+        };
+        if (this.tunnel.targetLatency) {
+            targetLatency.latency = this.tunnel.targetLatency.latency;
+        }
+        let identify = null;
+        if (this.tunnel.identify) {
+            identify = {
+                type: this.tunnel.identify.type,
+            };
+        }
+        const dns = {
+            checking: false,
+            valid: false,
+        };
+        if (this.tunnel.dns) {
+            dns.checking = this.tunnel.dns.checking;
+            dns.valid = this.tunnel.dns.valid;
+        }
+        this.send(utils_1.AGENT_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,
+            sshId: this.tunnel.sshId,
+            sshForwardPort: this.tunnel.sshForwardPort,
+        });
+    }
+    close() {
+        clearInterval(this.ts);
+        try {
+            this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        catch {
+            // do nothing
+        }
+        this.ts = null;
+        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);
+        this.tunnel = null;
+    }
+}
+exports.default = AgentSocket;

package/distTs/src/agent/system.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const https_1 = __importDefault(require("https"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../utils");
+const texts_1 = require("../texts");
+const logger_1 = __importDefault(require("../logger"));
+class AgentSystem {
+    // extend
+    isEnabled() {
+        return Promise.resolve(false);
+    }
+    // extend
+    enable() {
+        return Promise.reject();
+    }
+    // extend
+    update() {
+        return Promise.reject();
+    }
+    // extend
+    disable() {
+        return Promise.reject();
+    }
+    // extend
+    getSystemConfigPath() {
+        return '';
+    }
+    // extend
+    getSystemConfigDir() {
+        return '';
+    }
+    getAgentConfigDir() {
+        return (0, utils_1.getHomeDirectory)();
+    }
+    getAgentConfigPath() {
+        return path_1.default.join(this.getAgentConfigDir(), 'agent.json');
+    }
+    // extend
+    hasAdminRights() {
+        return Promise.resolve(false);
+    }
+    // extend
+    isSupported() {
+        return Promise.resolve(false);
+    }
+    // extend
+    getBinaryArchive() {
+        return '';
+    }
+    extractArchive(source, dest) {
+        return new Promise((resolve, reject) => {
+            import('@xhmikosr/decompress')
+                .then(({ default: decompress }) => {
+                decompress(source, dest)
+                    .then(() => {
+                    (0, fs_1.rmSync)(source, { force: true });
+                    resolve();
+                })
+                    .catch((err) => {
+                    (0, fs_1.rmSync)(source, { force: true });
+                    reject(err);
+                });
+            })
+                .catch(reject);
+        });
+    }
+    extractBinaryArchive() {
+        return this.extractArchive(this.getBinaryArchivePath(), this.getSystemConfigDir());
+    }
+    loadSystemConfig() {
+        const str = (0, fs_1.readFileSync)(this.getSystemConfigPath(), 'utf-8');
+        return JSON.parse(str);
+    }
+    loadAgentConfig() {
+        const str = (0, fs_1.readFileSync)(this.getAgentConfigPath(), 'utf-8');
+        return JSON.parse(str);
+    }
+    clearSystemFiles() {
+        (0, fs_1.rmSync)(this.getSystemBinaryPath(), { force: true });
+        (0, fs_1.rmSync)(this.getSystemConfigPath(), { force: true });
+    }
+    clearAgentFiles() {
+        (0, fs_1.rmSync)(this.getAgentConfigPath(), { force: true });
+    }
+    ensureSystemConfigDir() {
+        (0, fs_1.mkdirSync)(this.getSystemConfigDir(), { recursive: true });
+    }
+    saveFile(p, c) {
+        return new Promise((resolve, reject) => {
+            (0, fs_1.writeFile)(p, c, 'utf-8', (err) => {
+                if (!err)
+                    resolve();
+                else
+                    reject(err);
+            });
+        });
+    }
+    getSystemBinaryPath() {
+        return path_1.default.join(this.getSystemConfigDir(), 'bdy');
+    }
+    getBinaryArchivePath() {
+        return path_1.default.join(this.getSystemConfigDir(), this.getBinaryArchive());
+    }
+    downloadFile(url, dest) {
+        return new Promise((resolve, reject) => {
+            const file = (0, fs_1.createWriteStream)(dest);
+            const request = https_1.default.get(url, (response) => {
+                if (response.statusCode !== 200) {
+                    file.close();
+                    (0, fs_1.rmSync)(dest);
+                    reject(new Error('File not found'));
+                    return;
+                }
+                response.pipe(file);
+                file.once('finish', () => {
+                    file.close((err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+            });
+            request.once('error', (err) => {
+                file.close();
+                (0, fs_1.rmSync)(dest);
+                reject(err);
+            });
+        });
+    }
+    downloadBinaryArchive() {
+        const archivePath = this.getBinaryArchivePath();
+        const env = (0, utils_1.getVersionEnv)();
+        const version = (0, utils_1.getVersionWithoutEnv)();
+        const archive = this.getBinaryArchive();
+        return this.downloadFile(`https://es.buddy.works/bdy/${env}/${version}/${archive}`, archivePath);
+    }
+    saveSystemConfig(id, host, token, port) {
+        try {
+            logger_1.default.info(texts_1.LOG_SAVING_AGENT_SYSTEM_CONFIG);
+            this.ensureSystemConfigDir();
+            (0, fs_1.writeFileSync)(this.getSystemConfigPath(), JSON.stringify({
+                id,
+                host,
+                token,
+                port,
+            }), 'utf-8');
+            return true;
+        }
+        catch (err) {
+            logger_1.default.error(texts_1.LOG_ERROR_SAVING_AGENT_SYSTEM_CONFIG);
+            logger_1.default.error(err);
+            return false;
+        }
+    }
+    saveAgentConfig(shouldStart, sshHostKey) {
+        try {
+            logger_1.default.info(texts_1.LOG_SAVING_AGENT_LOCAL_CONFIG);
+            (0, fs_1.writeFileSync)(this.getAgentConfigPath(), JSON.stringify({
+                shouldStart,
+                sshHostKey,
+            }), 'utf-8');
+            return true;
+        }
+        catch (err) {
+            logger_1.default.error(texts_1.LOG_ERROR_SAVING_AGENT_LOCAL_CONFIG);
+            logger_1.default.error(err);
+            return false;
+        }
+    }
+}
+exports.default = AgentSystem;

package/distTs/src/agent/wait.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../utils.js");
+const waitUntilAgentEnabled = async (api, timeout, onTimeout, onSuccess) => {
+    let s;
+    try {
+        s = await api.fetchStatus();
+    }
+    catch {
+        s = {};
+    }
+    if (s.enabled) {
+        onSuccess();
+    }
+    else if (timeout < 1000) {
+        onTimeout();
+    }
+    else {
+        await (0, utils_js_1.sleep)(1000);
+        return waitUntilAgentEnabled(api, timeout - 1000, onTimeout, onSuccess);
+    }
+};
+exports.default = waitUntilAgentEnabled;