bdy 1.7.46-dev

package/.eslintrc.yml

@@ -0,0 +1,23 @@
+env:
+  node: true
+  es2021: true
+extends: eslint:recommended
+parserOptions:
+  ecmaVersion: latest
+  sourceType: commonjs
+ignorePatterns:
+  - dist
+rules:
+  indent:
+    - error
+    - 2
+  linebreak-style:
+    - error
+    - unix
+  quotes:
+    - error
+    - single
+  semi:
+    - error
+    - always
+  eol-last: error

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Buddy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+console.log = () => {}; // fix for termkit
+
+require('../src/index.js');

package/dockerfile

@@ -0,0 +1,15 @@
+FROM ubuntu:22.04
+ARG ENV=dev
+ARG VERSION=1.4.6
+ARG BUILDARCH
+ENV IS_IN_DOCKER=1
+VOLUME ["/buddy"]
+RUN apt-get update && apt-get install -y curl tar
+RUN if [ "$BUILDARCH" = "arm64" ]; then \
+      export ARCH="arm64"; \
+    else \
+      export ARCH="x64"; \
+    fi; \
+    curl https://es.buddy.works/bdy/$ENV/$VERSION/linux-$ARCH.tar.gz -o bdy.tar.gz && \
+    tar -zxf bdy.tar.gz -C /usr/local/bin/
+ENTRYPOINT ["/usr/local/bin/bdy"]

package/link.sh

@@ -0,0 +1,3 @@
+#!/bin/bash -e
+
+npm link

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "bdy",
+  "preferGlobal": false,
+  "version": "1.7.46-dev",
+  "type": "commonjs",
+  "license": "MIT",
+  "dependencies": {
+    "socket.io-client": "4.7.5",
+    "@fastify/accept-negotiator": "1.1.0",
+    "@xhmikosr/decompress": "10.0.1",
+    "basic-auth": "2.0.1",
+    "commander": "12.0.0",
+    "content-disposition": "0.5.4",
+    "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",
+    "range-parser": "1.2.1",
+    "ssh2": "1.15.0",
+    "terminal-kit": "3.1.1",
+    "uuid": "9.0.1",
+    "ws": "8.18.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "25.0.8",
+    "@rollup/plugin-json": "6.1.0",
+    "@rollup/plugin-node-resolve": "15.2.3",
+    "eslint": "8.50.0",
+    "rollup-plugin-natives": "0.7.8"
+  },
+  "bin": {
+    "bdy": "bin/cli.js"
+  }
+}

package/src/agent/linux.js

@@ -0,0 +1,127 @@
+const AgentSystem = require('./system');
+const path = require('path');
+const { exec } = require('child_process');
+const logger = require('../logger');
+const { LOG_AGENT_SYSTEM_DIR,
+  LOG_AGENT_DOWNLOADING_ARCHIVE,
+  LOG_AGENT_EXTRACTING_ARCHIVE,
+  LOG_AGENT_SYSTEM_SERVICE_CONFIG,
+  LOG_AGENT_ENABLING_SYSTEM,
+  LOG_AGENT_ENABLED,
+  LOG_AGENT_STOPPING_SYSTEM,
+  LOG_AGENT_STARTING_SYSTEM
+} = require('../texts');
+
+class AgentLinux extends AgentSystem {
+  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.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.info(LOG_AGENT_SYSTEM_DIR);
+      await this.ensureSystemConfigDir();
+      logger.info(LOG_AGENT_DOWNLOADING_ARCHIVE);
+      await this.downloadBinaryArchive();
+      logger.info(LOG_AGENT_EXTRACTING_ARCHIVE);
+      await this.extractBinaryArchive();
+      logger.info(LOG_AGENT_SYSTEM_SERVICE_CONFIG);
+      await this.saveFile(this.getServicePath(), this.getServiceConfig(id, host, token, port, start, user, debug));
+      logger.info(LOG_AGENT_ENABLING_SYSTEM);
+      await this.systemctl('enable --now bdy');
+      logger.info(LOG_AGENT_ENABLED);
+    } catch (err) {
+      logger.error(err);
+      throw err;
+    }
+  }
+
+  async update() {
+    try {
+      logger.info(LOG_AGENT_STOPPING_SYSTEM);
+      await this.systemctl('stop bdy');
+      logger.info(LOG_AGENT_SYSTEM_DIR);
+      await this.ensureSystemConfigDir();
+      logger.info(LOG_AGENT_DOWNLOADING_ARCHIVE);
+      await this.downloadBinaryArchive();
+      logger.info(LOG_AGENT_EXTRACTING_ARCHIVE);
+      await this.extractBinaryArchive();
+      logger.info(LOG_AGENT_STARTING_SYSTEM);
+      await this.systemctl('start bdy');
+    } catch (err) {
+      logger.error(err);
+      throw err;
+    }
+  }
+
+  async disable() {
+    return this.systemctl('disable --now bdy');
+  }
+
+  systemctl(cmd) {
+    return new Promise((resolve, reject) => {
+      exec(`systemctl ${cmd}`, (err, stdout, stderr) => {
+        if (!err) resolve(stdout, stderr);
+        else reject(err, stderr);
+      });
+    });
+  }
+}
+
+module.exports = AgentLinux;

package/src/agent/manager.js

@@ -0,0 +1,404 @@
+const {
+  ApiErrorAgentNotFound,
+  AGENT_STATUS_DISABLED,
+  AGENT_STATUS_ENABLED,
+  AGENT_STATUS_FETCH_FAILED,
+  getVersion,
+  sleep
+} = require('../utils.js');
+const { WebSocketServer } = require('ws');
+const logger = require('../logger.js');
+const http = require('http');
+const Output = require('../output.js');
+const {
+  AGENT_FETCH_RETRY,
+  ERR_AGENT_NOT_REGISTERED,
+  LOG_AGENT_SERVER_STARTED,
+  LOG_AGENT_STARTED,
+  LOG_ERROR_STARTING_AGENT_SERVER,
+  LOG_REQUEST
+} = require('../texts.js');
+const AgentSocket = require('./socket.js');
+const ApiBuddy = require('../api/buddy.js');
+const { isOsx,
+  AGENT_STATUS_INITIALIZING,
+  isLinux,
+  isWindows,
+  TUNNEL_SSH,
+  createSshHostKey
+} = require('../utils');
+const AgentOsx = require('./osx');
+const { ERR_AGENT_NOT_FOUND,
+  ERR_SAVING_AGENT_CONFIG
+} = require('../texts');
+const AgentSystem = require('./system');
+const AgentLinux = require('./linux');
+const AgentWindows = require('./windows');
+
+class AgentManagerClass {
+  constructor() {
+    this.status = 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 (isOsx()) {
+      this.system = new AgentOsx();
+    } else if (isLinux()) {
+      this.system = new AgentLinux();
+    } else if (isWindows()) {
+      this.system = new AgentWindows();
+    } else {
+      this.system = new AgentSystem();
+    }
+  }
+
+  start(id, host, token, port, start) {
+    this.load(id, host, token, parseInt(port, 10), !!start).then();
+  }
+
+  async tryFetch() {
+    try {
+      this.agent = await ApiBuddy.fetchAgent(this.id, this.host, this.token);
+      this.agent.manager = this;
+      this.agent.startRefreshingConfiguration((success) => {
+        if (success) this.status = AGENT_STATUS_ENABLED;
+        else this.status = AGENT_STATUS_FETCH_FAILED;
+      });
+      if (this.shouldStart) await this.agent.start();
+      this.status = AGENT_STATUS_ENABLED;
+    } catch (err) {
+      if (err instanceof ApiErrorAgentNotFound) {
+        await this.disableAgentAndExit(ERR_AGENT_NOT_FOUND);
+      } else {
+        Output.normal(AGENT_FETCH_RETRY);
+        this.status = AGENT_STATUS_FETCH_FAILED;
+        await 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 === 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: getVersion(),
+      started: this.shouldStart,
+      enabled: this.status === 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 (err) {
+      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 ApiBuddy.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.error(txt);
+    try {
+      await this.system.disable();
+    } catch {
+      // do nothing
+    }
+    try {
+      await ApiBuddy.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.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 (err) {
+      this.serverError(res, 'Wrong input data');
+      return;
+    }
+    let tunnel;
+    try {
+      tunnel = await ApiBuddy.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.info(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.info(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 === TUNNEL_SSH) {
+      con.close();
+      return;
+    }
+    new AgentSocket(con, tunnel);
+  }
+
+  createServer() {
+    this.server = http.createServer((req, res) => this.processRequest(req, res));
+    this.ws = new 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(LOG_ERROR_STARTING_AGENT_SERVER);
+      } else {
+        logger.info(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 = 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 = 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(ERR_AGENT_NOT_REGISTERED);
+      return;
+    }
+    const ok = this.resaveAgentConfig(start);
+    if (!ok) {
+      await this.disableAgentAndExit(ERR_SAVING_AGENT_CONFIG);
+      return;
+    }
+    this.createServer();
+    await this.tryFetch();
+    logger.info(LOG_AGENT_STARTED);
+  }
+}
+
+const AgentManager = new AgentManagerClass();
+
+module.exports = AgentManager;