bdy 1.8.3-dev → 1.8.5-dev

package/distTs/bin/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+console.log = () => { }; // fix for termkit
+require("../src/index.js");

package/distTs/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "bdy",
+  "preferGlobal": false,
+  "version": "1.8.5-dev",
+  "type": "commonjs",
+  "license": "MIT",
+  "scripts": {
+    "lint": "eslint \"*/**\"",
+    "lint:types": "tsc --skipLibCheck --noEmit --project tsconfig.json",
+    "watch": "tsc --watch --project tsconfig.json"
+  },
+  "files": [
+    "distTs"
+  ],
+  "bin": {
+    "bdy": "distTs/bin/cli.js"
+  },
+  "dependencies": {
+    "@fastify/accept-negotiator": "1.1.0",
+    "@fastify/cors": "9.0.1",
+    "@puppeteer/browsers": "2.4.0",
+    "@xhmikosr/decompress": "10.0.1",
+    "basic-auth": "2.0.1",
+    "chalk": "4.1.2",
+    "commander": "12.1.0",
+    "content-disposition": "0.5.4",
+    "cross-spawn": "7.0.3",
+    "fastify": "4.28.1",
+    "isbinaryfile": "5.0.2",
+    "jsonwebtoken": "9.0.2",
+    "mime-db": "1.52.0",
+    "mime-types": "2.1.35",
+    "netmask": "2.0.2",
+    "node-fetch": "3.3.2",
+    "node-forge": "1.3.1",
+    "path-is-inside": "1.0.2",
+    "pino": "8.20.0",
+    "puppeteer-core": "23.6.0",
+    "range-parser": "1.2.1",
+    "socket.io-client": "4.7.5",
+    "ssh2": "1.15.0",
+    "terminal-kit": "3.1.1",
+    "undici": "6.19.2",
+    "uuid": "10.0.0",
+    "which": "4.0.0",
+    "ws": "8.18.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.13.0",
+    "@rollup/plugin-commonjs": "28.0.1",
+    "@rollup/plugin-json": "6.1.0",
+    "@rollup/plugin-node-resolve": "15.3.0",
+    "@rollup/plugin-replace": "6.0.1",
+    "@stylistic/eslint-plugin-js": "2.9.0",
+    "@types/cross-spawn": "6.0.6",
+    "@types/eslint__js": "8.42.3",
+    "@types/ssh2": "1.15.1",
+    "@types/terminal-kit": "2.5.6",
+    "@types/uuid": "10.0.0",
+    "@types/which": "3.0.4",
+    "eslint": "9.13.0",
+    "eslint-config-prettier": "9.1.0",
+    "globals": "15.11.0",
+    "prettier": "3.3.3",
+    "rollup-plugin-natives": "0.7.8",
+    "typescript": "5.6.3",
+    "typescript-eslint": "8.11.0",
+    "rollup": "4.24.2"
+  }
+}

package/distTs/src/agent/linux.js

@@ -0,0 +1,119 @@
+"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 path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const logger_1 = __importDefault(require("../logger"));
+const texts_1 = require("../texts");
+class AgentLinux extends system_1.default {
+    hasAdminRights() {
+        return new Promise((resolve) => {
+            resolve(process.getuid() === 0);
+        });
+    }
+    isSupported() {
+        return new Promise((resolve) => {
+            this.systemctl('--version')
+                .then(() => {
+                resolve(['arm64', 'x64'].includes(process.arch));
+            })
+                .catch(() => {
+                resolve(false);
+            });
+        });
+    }
+    isEnabled() {
+        return new Promise((resolve) => {
+            this.systemctl('is-enabled bdy')
+                .then(() => {
+                resolve(true);
+            })
+                .catch(() => {
+                resolve(false);
+            });
+        });
+    }
+    getBinaryArchive() {
+        return `linux-${process.arch}.tar.gz`;
+    }
+    getSystemConfigDir() {
+        return '/etc/bdy';
+    }
+    getSystemConfigPath() {
+        return path_1.default.join(this.getSystemConfigDir(), 'agent.json');
+    }
+    getServicePath() {
+        return '/etc/systemd/system/bdy.service';
+    }
+    getServiceConfig(id, host, token, port, start, user, debug) {
+        const cli = this.getSystemBinaryPath();
+        return `[Unit]
+Description=Buddy Tunnel Agent
+After=network.target
+
+[Service]
+Environment="DEBUG=${debug ? 1 : 0}"
+User=${user || 'root'}
+WorkingDirectory=/
+ExecStart=${cli} agent run --id="${id}" --host="${host}" --token="${token}" --port=${port} --start=${!!start}
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target`;
+    }
+    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_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_SYSTEM_SERVICE_CONFIG);
+            await this.saveFile(this.getServicePath(), this.getServiceConfig(id, host, token, port, start, user, debug));
+            logger_1.default.info(texts_1.LOG_AGENT_ENABLING_SYSTEM);
+            await this.systemctl('enable --now bdy');
+            logger_1.default.info(texts_1.LOG_AGENT_ENABLED);
+        }
+        catch (err) {
+            logger_1.default.error(err);
+            throw err;
+        }
+    }
+    async update() {
+        try {
+            logger_1.default.info(texts_1.LOG_AGENT_STOPPING_SYSTEM);
+            await this.systemctl('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();
+            logger_1.default.info(texts_1.LOG_AGENT_STARTING_SYSTEM);
+            await this.systemctl('start bdy');
+        }
+        catch (err) {
+            logger_1.default.error(err);
+            throw err;
+        }
+    }
+    async disable() {
+        return this.systemctl('disable --now bdy');
+    }
+    systemctl(cmd) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(`systemctl ${cmd}`, (err, stdout, stderr) => {
+                if (!err)
+                    resolve(stdout, stderr);
+                else
+                    reject(err, stderr);
+            });
+        });
+    }
+}
+exports.default = AgentLinux;

package/distTs/src/agent/manager.js

@@ -0,0 +1,395 @@
+"use strict";
+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 ws_1 = require("ws");
+const logger_js_1 = __importDefault(require("../logger.js"));
+const http_1 = __importDefault(require("http"));
+const output_js_1 = __importDefault(require("../output.js"));
+const texts_js_1 = require("../texts.js");
+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"));
+class AgentManagerClass {
+    constructor() {
+        this.status = utils_js_1.AGENT_STATUS_DISABLED;
+        this.id = null;
+        this.host = null;
+        this.token = null;
+        this.port = null;
+        this.shouldStart = null;
+        this.sshHostKey = null;
+        this.agent = null;
+        this.server = null;
+        this.ws = null;
+        if ((0, utils_js_1.isOsx)()) {
+            this.system = new osx_1.default();
+        }
+        else if ((0, utils_js_1.isLinux)()) {
+            this.system = new linux_1.default();
+        }
+        else if ((0, utils_js_1.isWindows)()) {
+            this.system = new windows_1.default();
+        }
+        else {
+            this.system = new system_1.default();
+        }
+    }
+    start(id, host, token, port, start) {
+        this.load(id, host, token, parseInt(port, 10), !!start).then();
+    }
+    async tryFetch() {
+        try {
+            this.agent = await buddy_js_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;
+                else
+                    this.status = utils_js_1.AGENT_STATUS_FETCH_FAILED;
+            });
+            if (this.shouldStart)
+                await this.agent.start();
+            this.status = utils_js_1.AGENT_STATUS_ENABLED;
+        }
+        catch (err) {
+            if (err instanceof utils_js_1.ApiErrorAgentNotFound) {
+                await this.disableAgentAndExit(texts_js_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);
+                return this.tryFetch();
+            }
+        }
+    }
+    serverOutput(res, data) {
+        res.statusCode = 200;
+        res.setHeader('content-type', 'application/json');
+        res.end(JSON.stringify(data));
+    }
+    server404(res) {
+        res.statusCode = 404;
+        res.end('Not found');
+    }
+    serverError(res, message) {
+        res.statusCode = 400;
+        res.end(JSON.stringify({
+            message,
+        }));
+    }
+    async processTunnels(res) {
+        const tunnels = [];
+        if (this.agent) {
+            this.agent.tunnels.forEach((tunnel) => {
+                if (tunnel.type === utils_js_1.TUNNEL_SSH)
+                    return;
+                tunnels.push({
+                    id: tunnel.id,
+                    type: tunnel.type,
+                    target: tunnel.target,
+                    domain: tunnel.domain,
+                    subdomain: tunnel.subdomain,
+                    serve: tunnel.serve,
+                    status: tunnel.status,
+                    region: tunnel.region,
+                    sshId: tunnel.sshId,
+                    sshForwardPort: tunnel.sshForwardPort,
+                    regionLatency: tunnel.regionLatency
+                        ? tunnel.regionLatency.latency
+                        : -1,
+                    targetLatency: tunnel.targetLatency
+                        ? tunnel.targetLatency.latency
+                        : -1,
+                });
+            });
+        }
+        this.serverOutput(res, {
+            tunnels,
+        });
+    }
+    async processStatus(res) {
+        this.serverOutput(res, {
+            id: this.id,
+            status: this.status,
+            version: (0, utils_js_1.getVersion)(),
+            started: this.shouldStart,
+            enabled: this.status === utils_js_1.AGENT_STATUS_ENABLED,
+        });
+    }
+    processBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.setEncoding('utf-8');
+            req.on('data', (d) => {
+                data += d;
+            });
+            req.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+    }
+    async processTunnelStop(req, res) {
+        if (!this.agent) {
+            this.serverError(res, 'Agent not enabled');
+            return;
+        }
+        let data;
+        try {
+            data = await this.processBody(req);
+        }
+        catch {
+            this.serverError(res, 'Wrong input data');
+            return;
+        }
+        const tunnel = this.agent.destroyTunnel(data.id);
+        if (!tunnel) {
+            this.serverError(res, 'Tunnel not found');
+            return;
+        }
+        try {
+            await buddy_js_1.default.removeTunnel(this.id, tunnel.id, this.host, this.token);
+        }
+        catch (err) {
+            this.serverError(res, err.message);
+            return;
+        }
+        this.serverOutput(res, {
+            success: true,
+        });
+    }
+    async agentRestart() {
+        let saved = await this.agentStop();
+        if (!saved)
+            return false;
+        return await this.agentStart();
+    }
+    async disableAgentAndExit(txt) {
+        logger_js_1.default.error(txt);
+        try {
+            await this.system.disable();
+        }
+        catch {
+            // do nothing
+        }
+        try {
+            await buddy_js_1.default.unregister(this.id, this.host, this.token);
+        }
+        catch {
+            // do nothing
+        }
+        try {
+            this.system.clearSystemFiles();
+        }
+        catch {
+            // do nothing
+        }
+        try {
+            this.system.clearAgentFiles();
+        }
+        catch {
+            // do nothing
+        }
+        output_js_1.default.exitError(txt);
+    }
+    async agentStop() {
+        const saved = this.resaveAgentConfig(false, true);
+        if (!saved)
+            return false;
+        await this.agent.stop();
+        return true;
+    }
+    async processAgentRestart(req, res) {
+        if (!this.agent) {
+            this.serverError(res, 'Agent not enabled');
+            return;
+        }
+        const saved = await this.agentRestart();
+        if (!saved) {
+            this.serverError(res, 'Something went wrong');
+            return;
+        }
+        this.serverOutput(res, {
+            success: true,
+        });
+    }
+    async processAgentStop(req, res) {
+        if (!this.agent) {
+            this.serverError(res, 'Agent not enabled');
+            return;
+        }
+        const saved = await this.agentStop();
+        if (!saved) {
+            this.serverError(res, 'Something went wrong');
+            return;
+        }
+        this.serverOutput(res, {
+            success: true,
+        });
+    }
+    async agentStart() {
+        const saved = this.resaveAgentConfig(true, true);
+        if (!saved) {
+            return false;
+        }
+        await this.agent.start();
+        return true;
+    }
+    async processAgentStart(req, res) {
+        if (!this.agent) {
+            this.serverError(res, 'Agent not enabled');
+            return;
+        }
+        const saved = await this.agentStart();
+        if (!saved) {
+            this.serverError(res, 'Something went wrong');
+            return;
+        }
+        this.serverOutput(res, {
+            success: true,
+        });
+    }
+    async processTunnelAdd(req, res) {
+        if (!this.agent) {
+            this.serverError(res, 'Agent not enabled');
+            return;
+        }
+        let data;
+        try {
+            data = await this.processBody(req);
+        }
+        catch {
+            this.serverError(res, 'Wrong input data');
+            return;
+        }
+        let tunnel;
+        try {
+            tunnel = await buddy_js_1.default.addTunnel(this.id, this.host, this.token, data, this.sshHostKey);
+        }
+        catch (err) {
+            this.serverError(res, err.message);
+            return;
+        }
+        this.agent.addTunnel(tunnel);
+        this.serverOutput(res, {
+            id: tunnel.id,
+            type: tunnel.type,
+        });
+    }
+    async processRequest(req, res) {
+        logger_js_1.default.info((0, texts_js_1.LOG_REQUEST)(req.url));
+        if (req.url === '/status')
+            return this.processStatus(res);
+        if (req.url === '/tunnels')
+            return this.processTunnels(res);
+        if (req.url === '/tunnel/add')
+            return this.processTunnelAdd(req, res);
+        if (req.url === '/tunnel/stop')
+            return this.processTunnelStop(req, res);
+        if (req.url === '/agent/start')
+            return this.processAgentStart(req, res);
+        if (req.url === '/agent/stop')
+            return this.processAgentStop(req, res);
+        if (req.url === '/agent/restart')
+            return this.processAgentRestart(req, res);
+        this.server404(res);
+    }
+    processUpgrade(req, socket, head) {
+        logger_js_1.default.info((0, texts_js_1.LOG_REQUEST)(req.url));
+        const url = new URL(req.url, 'http://localhost');
+        const id = url.searchParams.get('id');
+        if (url.pathname === '/tunnel' && id) {
+            this.ws.handleUpgrade(req, socket, head, (con) => {
+                this.ws.emit('connection', con, id);
+            });
+            return;
+        }
+        socket.destroy();
+    }
+    processWebsocketConnection(con, id) {
+        if (!this.agent) {
+            con.close();
+            return;
+        }
+        const tunnel = this.agent.tunnels.find((t) => t.id === id);
+        if (!tunnel || tunnel.type === utils_js_1.TUNNEL_SSH) {
+            con.close();
+            return;
+        }
+        new socket_js_1.default(con, tunnel);
+    }
+    createServer() {
+        this.server = http_1.default.createServer((req, res) => this.processRequest(req, res));
+        this.ws = new ws_1.WebSocketServer({ noServer: true });
+        this.ws.on('connection', (con, id) => this.processWebsocketConnection(con, id));
+        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);
+            }
+            else {
+                logger_js_1.default.info(texts_js_1.LOG_AGENT_SERVER_STARTED);
+            }
+        });
+    }
+    resaveAgentConfig(shouldStart, forceParam = false) {
+        if (!forceParam) {
+            try {
+                // load from config
+                const json = this.system.loadAgentConfig();
+                this.shouldStart = !!json.shouldStart;
+                this.sshHostKey = json.sshHostKey;
+            }
+            catch {
+                // save from param
+                this.shouldStart = shouldStart;
+            }
+            if (!this.sshHostKey)
+                this.sshHostKey = (0, utils_js_1.createSshHostKey)();
+        }
+        else {
+            // save from param
+            this.shouldStart = shouldStart;
+        }
+        try {
+            // resave config
+            this.system.saveAgentConfig(this.shouldStart, this.sshHostKey);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async load(id, host, token, port, start) {
+        this.status = utils_js_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);
+            return;
+        }
+        const ok = this.resaveAgentConfig(start);
+        if (!ok) {
+            await this.disableAgentAndExit(texts_js_1.ERR_SAVING_AGENT_CONFIG);
+            return;
+        }
+        this.createServer();
+        await this.tryFetch();
+        logger_js_1.default.info(texts_js_1.LOG_AGENT_STARTED);
+    }
+}
+const AgentManager = new AgentManagerClass();
+exports.default = AgentManager;