bdy 1.8.3-dev → 1.8.4-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/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;

package/distTs/src/agent/osx.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const texts_1 = require("../texts");
+const logger_1 = __importDefault(require("../logger"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const system_1 = __importDefault(require("./system"));
+class AgentOsx extends system_1.default {
+    hasAdminRights() {
+        return new Promise((resolve) => {
+            resolve(process.getuid() === 0);
+        });
+    }
+    isSupported() {
+        // cant check for process.arch because of rosetta (process.arch returns x64 for m1)
+        return Promise.resolve(true);
+    }
+    isEnabled() {
+        return new Promise((resolve) => {
+            this.launchCtl('print system/bdy | grep domain')
+                .then((str) => {
+                resolve(!!str && !!str.match(/domain\s=\ssystem/i));
+            })
+                .catch(() => {
+                resolve(false);
+            });
+        });
+    }
+    getBinaryArchive() {
+        return 'darwin-arm64.tar.gz';
+    }
+    getSystemConfigDir() {
+        return '/Library/Application Support/bdy';
+    }
+    getSystemConfigPath() {
+        return path_1.default.join(this.getSystemConfigDir(), 'agent.json');
+    }
+    getServicePath() {
+        return '/Library/LaunchDaemons/bdy.plist';
+    }
+    getServiceConfig(id, host, token, port, start, user, debug) {
+        const cli = this.getSystemBinaryPath();
+        let cfg = `<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version='1.0'>
+  <dict>
+    <key>Label</key>
+    <string>bdy</string>
+    <key>ProgramArguments</key>
+    <array>
+      <string>${cli}</string>
+      <string>agent</string>
+      <string>run</string>
+      <string>--id</string>
+      <string>${id}</string>
+      <string>--host</string>
+      <string>${host}</string>
+      <string>--token</string>
+      <string>${token}</string>
+      <string>--port</string>
+      <string>${port}</string>
+      <string>--start</string>
+      <string>${!!start}</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>DEBUG</key>
+        <string>${debug ? 1 : 0}</string>
+    </dict>
+    <key>KeepAlive</key>
+    <true/>
+    <key>RunAtLoad</key>
+    <true/>`;
+        if (user) {
+            cfg += `
+    <key>UserName</key>
+    <string>${user}</string>`;
+        }
+        cfg += `
+  </dict>
+</plist>`;
+        return cfg;
+    }
+    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.launchCtl(`bootstrap system ${this.getServicePath()}`);
+            logger_1.default.info(texts_1.LOG_AGENT_ENABLED);
+        }
+        catch (err) {
+            logger_1.default.info(err);
+            throw err;
+        }
+    }
+    async update() {
+        try {
+            logger_1.default.info(texts_1.LOG_AGENT_STOPPING_SYSTEM);
+            await this.launchCtl('bootout system/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.launchCtl(`bootstrap system ${this.getServicePath()}`);
+            logger_1.default.info(texts_1.LOG_AGENT_ENABLED);
+        }
+        catch (err) {
+            logger_1.default.error(err);
+            throw err;
+        }
+    }
+    disable() {
+        return this.launchCtl('bootout system/bdy');
+    }
+    launchCtl(cmd) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(`launchctl ${cmd}`, (err, stdout, stderr) => {
+                if (!err)
+                    resolve(stdout, stderr);
+                else
+                    reject(err, stderr);
+            });
+        });
+    }
+}
+exports.default = AgentOsx;