bdy 1.7.46-dev

package/src/api/agent.js

@@ -0,0 +1,95 @@
+const logger = require('../logger.js');
+const {
+  ERR_FAILED_TO_CONNECT_TO_AGENT,
+  ERR_NOT_FOUND,
+  ERR_SWW,
+  LOG_ERROR
+} = require('../texts.js');
+const { WebSocket } = require('ws');
+
+const TIMEOUT = 120000;
+
+const openSocket = (port, path) => {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://localhost:${port}${path}`);
+    ws.on('error', () => {
+      reject(new Error(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(ERR_NOT_FOUND);
+  }
+  if (response.status === 400) {
+    const data = await response.json();
+    throw new Error(data.message);
+  }
+  if (response.status !== 200) {
+    throw new Error(ERR_SWW);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    logger.error(LOG_ERROR);
+    logger.error(err);
+    throw new Error(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)}`);
+  }
+}
+
+module.exports = ApiAgent;

package/src/api/buddy.js

@@ -0,0 +1,131 @@
+const { Agent: HttpsAgent } = require('https');
+const Tunnel = require('../tunnel.js');
+const logger = require('../logger.js');
+const Agent = require('../agent.js');
+const {
+  apiErrorCodeToClass,
+  getHostname,
+  getPlatform,
+  getVersion,
+  ApiErrorFailedToConnect,
+} = require('../utils');
+const {
+  LOG_AGENT_REGISTERED,
+  LOG_GETTING_AGENT,
+  LOG_REGION_DETECTED,
+  LOG_REGISTERING_AGENT,
+  LOG_REGISTERING_TUNNEL,
+  LOG_REMOVING_TUNNEL,
+  LOG_TUNNEL_REGISTERED,
+  LOG_UNREGISTERING_AGENT
+} = 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 HttpsAgent({
+        rejectUnauthorized: false,
+      }),
+    });
+    if (respAsJson) data = await response.json();
+    else data = await response.text();
+  } catch (err) {
+    throw new ApiErrorFailedToConnect(host);
+  }
+  if (respAsJson) {
+    if (data.code !== 200) {
+      throw apiErrorCodeToClass(data.result.code, host);
+    }
+    return data.result;
+  } else {
+    return data;
+  }
+};
+
+class ApiBuddyClass {
+  async register(service, host, token, onDefaultRegion) {
+    const version = getVersion();
+    const hostname = getHostname();
+    const platform = getPlatform();
+    logger.info(LOG_REGISTERING_AGENT);
+    const r = await makeRequest(host, '/tunnel/agent/add', {
+      token,
+      version,
+      hostname,
+      platform,
+      service
+    });
+    logger.info(LOG_AGENT_REGISTERED(r.id));
+    logger.info(LOG_REGION_DETECTED(r.region));
+    if (onDefaultRegion) onDefaultRegion(r.region);
+    return new Agent(r.id, host, r.token, service, this);
+  }
+
+  async unregister(id, host, token) {
+    logger.info(LOG_UNREGISTERING_AGENT);
+    await makeRequest(host, '/tunnel/agent/remove', {
+      token,
+      id
+    });
+    return true;
+  }
+
+  async fetchAgent(id, host, token) {
+    logger.info(LOG_GETTING_AGENT);
+    const r = await makeRequest(host, '/tunnel/agent/fetch', {
+      token,
+      id
+    });
+    return new Agent(r.id, host, token, r.service, this);
+  }
+
+  async addTunnel(agentId, host, token, prepared, sshHostKey) {
+    logger.info(LOG_REGISTERING_TUNNEL);
+    const config = await makeRequest(host, '/tunnel/add', {
+      ...prepared,
+      token,
+      agentId
+    });
+    logger.info(LOG_TUNNEL_REGISTERED(config.id));
+    return new Tunnel({
+      ...config,
+      sshHostKey
+    });
+  }
+
+  async removeTunnel(agentId, tunnelId, host, token) {
+    logger.info(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();
+
+module.exports = ApiBuddy;

package/src/api/socket.js

@@ -0,0 +1,142 @@
+const { io } = require('socket.io-client');
+const { Agent: HttpsAgent } = require('https');
+const EventEmitter = require('events');
+const logger = require('../logger.js');
+const {
+  LOG_SOCKET_CONNECTED,
+  LOG_SOCKET_DISCONNECTED
+} = require('../texts');
+const {
+  apiErrorCodeToClass,
+  getHostname,
+  getPlatform,
+  getVersion,
+  SOCKET_IO_EVENT_FETCH_FAILED,
+  SOCKET_IO_EVENT_FETCH_SUCCESS,
+  SOCKET_IO_EVENT_CONNECTED,
+  SOCKET_IO_EVENT_DISCONNECTED,
+  SOCKET_IO_EVENT_AGENT,
+  SOCKET_IO_EVENT_TUNNEL,
+  EVENT_TUNNEL_HTTP_NEW_RESPONSE_END
+} = require('../utils');
+
+const MAX_REQUESTS_SYNC_WINDOW = 30000;
+const MAX_REQUESTS_SYNC_IN_WINDOW = 100;
+
+class ApiSocketClass extends EventEmitter {
+  fetch(activate = true, action = null, resetFirstHeard = false, tunnels) {
+    this.socket.emit('fetchTunnelAgent', {
+      id: this.id,
+      token: this.token,
+      hostname: this.hostname,
+      platform: this.platform,
+      version: this.version,
+      activate,
+      action,
+      resetFirstHeard,
+      tunnels
+    });
+  }
+
+  update(activate, tunnels, force = false) {
+    const now = Date.now();
+    // nie robimy update jak byl mniej niz 5s temu
+    if (!force && this.lastUpdate && now - this.lastUpdate < 5000) return;
+    this.lastUpdate = now;
+    this.socket.emit('updateTunnelAgent', {
+      id: this.id,
+      token: this.token,
+      hostname: this.hostname,
+      platform: this.platform,
+      version: this.version,
+      activate,
+      tunnels
+    });
+  }
+
+  emitRequest(tunnelId, logRequest) {
+    this.socket.emit('tunnelRequest', {
+      id: this.id,
+      token: this.token,
+      tunnelId,
+      request: logRequest.toSocket()
+    });
+  }
+
+  request(tunnelId, logRequest) {
+    if (this.tunnelRequests > MAX_REQUESTS_SYNC_IN_WINDOW) return;
+    this.tunnelRequests += 1;
+    logRequest.once(EVENT_TUNNEL_HTTP_NEW_RESPONSE_END, () => {
+      this.emitRequest(tunnelId, logRequest);
+    });
+    this.emitRequest(tunnelId, logRequest);
+  }
+
+  onSyncAgent(data, action) {
+    this.emit(SOCKET_IO_EVENT_AGENT, data, action);
+  }
+
+  onSyncTunnel(data, action) {
+    this.emit(SOCKET_IO_EVENT_TUNNEL, data, action);
+  }
+
+  onSync(data) {
+    try {
+      const json = JSON.parse(data);
+      if (json.payloadType === 'TunnelAgentFront') this.onSyncAgent(json.payload, json.action);
+      else if (json.payloadType === 'TunnelFront') this.onSyncTunnel(json.payload, json.action);
+    } catch {
+      // do nothing
+    }
+  }
+
+  constructor(host, id, token) {
+    super();
+    this.id = id;
+    this.token = token;
+    this.connected = false;
+    this.hostname = getHostname();
+    this.platform = getPlatform();
+    this.version = getVersion();
+    this.lastUpdate = null;
+    this.tunnelRequests = 0;
+    setInterval(() => {
+      this.tunnelRequests = 0;
+    }, MAX_REQUESTS_SYNC_WINDOW);
+    this.socket = io(host, {
+      forceNew: true,
+      autoConnect: true,
+      autoUnref: true,
+      forceBase64: true,
+      transports: ['websocket'],
+      reconnection: true,
+      rejectUnauthorized: false,
+      agent: new HttpsAgent({
+        rejectUnauthorized: false,
+      }),
+      maxHttpBufferSize: 3e6,
+      extraHeaders: {
+        cookie: 'a=b'
+      }
+    });
+    this.socket.on('connect', () => {
+      this.connected = true;
+      logger.info(LOG_SOCKET_CONNECTED);
+      this.emit(SOCKET_IO_EVENT_CONNECTED);
+    });
+    this.socket.on('disconnect', () => {
+      this.connected = false;
+      logger.info(LOG_SOCKET_DISCONNECTED);
+      this.emit(SOCKET_IO_EVENT_DISCONNECTED);
+    });
+    this.socket.on('fetchTunnelAgentSuccess', (data) => {
+      this.emit(SOCKET_IO_EVENT_FETCH_SUCCESS, data);
+    });
+    this.socket.on('fetchTunnelAgentFailed', (code) => {
+      this.emit(SOCKET_IO_EVENT_FETCH_FAILED, apiErrorCodeToClass(code, host));
+    });
+    this.socket.on('sync', (data) => this.onSync(data));
+  }
+}
+
+module.exports = ApiSocketClass;

package/src/cfg.js

@@ -0,0 +1,228 @@
+const { resolve } = require('path');
+const {
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} = require('fs');
+const { decode }  = require('jsonwebtoken');
+const {
+  DEFAULT_TIMEOUT,
+  getHomeDirectory,
+  TUNNEL_HTTP,
+  TUNNEL_TLS
+} = require('./utils.js');
+const Input = require('./input.js');
+const {
+  ERR_CANT_CREATE_DIR_IN_HOME,
+  ERR_CONFIG_CORRUPTED,
+  ERR_TOKEN_NOT_PROVIDED,
+  ERR_WRONG_TOKEN
+} = require('./texts.js');
+
+class Cfg {
+  constructor() {
+    this.dir = getHomeDirectory();
+    this.file = resolve(this.dir, 'cfg.json');
+    this.json = {};
+    this.load();
+  }
+
+  createDir() {
+    try {
+      mkdirSync(this.dir, {
+        recursive: true
+      });
+    } catch (err) {
+      throw new Error(ERR_CANT_CREATE_DIR_IN_HOME('.bdy'));
+    }
+  }
+
+  createEmptyFile() {
+    try {
+      writeFileSync(this.file, '{}', 'utf-8');
+    } catch (err) {
+      throw new Error(ERR_CANT_CREATE_DIR_IN_HOME('.bdy/cfg.json'));
+    }
+  }
+
+  ensureDir() {
+    try {
+      statSync(this.dir);
+    } catch(err) {
+      this.createDir();
+    }
+  }
+
+  ensureFile() {
+    this.ensureDir();
+    try {
+      statSync(this.file);
+    } catch (err) {
+      this.createEmptyFile();
+    }
+  }
+
+  ensureTunnels() {
+    if (!this.json.tunnels) this.json.tunnels = {};
+  }
+
+  async prepareTunnel(tunnelType, target, options, useDefaults, myIp) {
+    const type = Input.type(tunnelType);
+    const tunnel = {
+      type,
+      target: Input.target(target, type)
+    };
+    if (options.region !== undefined) tunnel.region = Input.region(options.region);
+    else if (useDefaults) tunnel.region = this.getRegion();
+    if (options.whitelist !== undefined) tunnel.whitelist = Input.whitelist(options.whitelist);
+    else if (useDefaults) {
+      tunnel.whitelist = this.getWhitelist();
+      if (!tunnel.whitelist.length) {
+        tunnel.whitelist.push(myIp);
+      }
+    }
+    if (options.timeout !== undefined) tunnel.timeout = Input.timeout(options.timeout);
+    else if (useDefaults) tunnel.timeout = this.getTimeout();
+    if (options.domain !== undefined) tunnel.domain = Input.domain(options.domain);
+    if (options.subdomain !== undefined) tunnel.subdomain = Input.subdomain(options.subdomain);
+    if (type === TUNNEL_HTTP) {
+      if (options.host !== undefined) tunnel.host = options.host;
+      if (options.auth !== undefined) {
+        const { password, login } = Input.auth(options.auth);
+        tunnel.login = login;
+        tunnel.password = password;
+      }
+      if (options.ca !== undefined) tunnel.ca = Input.ca(options.ca);
+      if (options.serve !== undefined) tunnel.serve = Input.serve(options.serve);
+      if (options.useragent !== undefined) tunnel.useragents = Input.useragents(options.useragent);
+      if (options.header !== undefined) tunnel.headers = Input.headers(options.header);
+      if (options.responseHeader !== undefined) tunnel.responseHeaders = Input.headers(options.responseHeader);
+      if (options.circuitBreaker !== undefined) tunnel.circuitBreaker = Input.circuitBreaker(options.circuitBreaker);
+      tunnel.log = !!options.log;
+      tunnel.verify = !!options.verify;
+      tunnel.http2 = !!options.http2;
+      tunnel.compression = !!options.compression;
+    } else if (type === TUNNEL_TLS) {
+      tunnel.terminate = Input.terminate(options.terminate);
+      if (options.key !== undefined || options.cert !== undefined){
+        const { key, cert } = Input.keyCert(options.key, options.cert);
+        tunnel.key = key;
+        tunnel.cert = cert;
+      }
+      if (options.ca !== undefined) tunnel.ca = Input.ca(options.ca);
+    }
+    if (options.name !== undefined) tunnel.name = Input.name(options.name);
+    return tunnel;
+  }
+
+  async addTunnel(name, type, target, options, myIp) {
+    this.ensureTunnels();
+    this.json.tunnels[name] = await this.prepareTunnel(type, target, {
+      name,
+      ...options
+    }, false, myIp);
+    this.save();
+  }
+
+  removeTunnel(name) {
+    this.ensureTunnels();
+    delete this.json.tunnels[name];
+    this.save();
+  }
+
+  getTunnels() {
+    this.ensureTunnels();
+    return this.json.tunnels;
+  }
+
+  hasTunnel(name) {
+    this.ensureTunnels();
+    return !!this.json.tunnels[name];
+  }
+
+  getTunnel(name) {
+    this.ensureTunnels();
+    return this.json.tunnels[name];
+  }
+
+  setToken(token) {
+    if (!token) delete this.json.token;
+    else this.json.token = token;
+    this.save();
+  }
+
+  setWhitelist(whitelist) {
+    if (!whitelist || !whitelist.length) delete this.json.whitelist;
+    else this.json.whitelist = whitelist;
+    this.save();
+  }
+
+  setTimeout(timeout) {
+    if (!timeout) delete this.json.timeout;
+    else this.json.timeout = timeout;
+    this.save();
+  }
+
+  getToken() {
+    return this.json.token || '';
+  }
+
+  getTokenHost() {
+    const token = this.getToken();
+    if (!token) {
+      throw new Error(ERR_TOKEN_NOT_PROVIDED);
+    }
+    const d = decode(token);
+    if (d === null) {
+      throw new Error(ERR_WRONG_TOKEN);
+    }
+    if (!d.host) {
+      throw new Error(ERR_WRONG_TOKEN);
+    }
+    return d.host;
+  }
+
+  getRegion() {
+    return (this.json.region || '').toUpperCase();
+  }
+
+  getTimeout() {
+    return this.json.timeout || DEFAULT_TIMEOUT;
+  }
+
+  getWhitelist() {
+    return this.json.whitelist || [];
+  }
+
+  setRegion(region) {
+    this.json.region = region;
+    this.save();
+  }
+
+  setRegionIfNotSet(region) {
+    if (!this.json.region && region) this.json.region = region.toUpperCase();
+    this.save();
+  }
+
+  load() {
+    this.ensureFile();
+    try {
+      const txt = readFileSync(this.file, 'utf-8');
+      this.json = JSON.parse(txt);
+    } catch (err) {
+      throw new Error(ERR_CONFIG_CORRUPTED);
+    }
+  }
+
+  save() {
+    this.ensureDir();
+    try {
+      writeFileSync(this.file, JSON.stringify(this.json, null, 4), 'utf-8');
+    } catch (err) {
+      throw new Error(ERR_CANT_CREATE_DIR_IN_HOME('.bdy/cfg.json'));
+    }
+  }
+}
+
+module.exports = new Cfg();

package/src/command/agent/disable.js

@@ -0,0 +1,37 @@
+const { Command } = require('commander');
+const Output = require('../../output.js');
+const {
+  DESC_COMMAND_AGENT_DISABLE,
+  TXT_AGENT_DISABLED
+} = require('../../texts.js');
+const AgentManager = require('../../agent/manager.js');
+const ApiBuddy = require('../../api/buddy.js');
+const { ERR_AGENT_ADMIN_RIGHTS } = require('../../texts');
+
+const commandAgentDisable = new Command('disable');
+commandAgentDisable.description(DESC_COMMAND_AGENT_DISABLE);
+commandAgentDisable.action(async () => {
+  const hasAdminRights = await AgentManager.system.hasAdminRights();
+  if (!hasAdminRights) {
+    Output.exitError(ERR_AGENT_ADMIN_RIGHTS);
+  }
+  try {
+    await AgentManager.system.disable();
+  } catch {
+    // do nothing
+  }
+  try {
+    const json = AgentManager.system.loadSystemConfig();
+    await ApiBuddy.unregister(json.id, json.host, json.token);
+  } catch {
+    // do nothing
+  }
+  try {
+    AgentManager.system.clearSystemFiles();
+  } catch {
+    // do nothing
+  }
+  Output.exitSuccess(TXT_AGENT_DISABLED);
+});
+
+module.exports = commandAgentDisable;