bdy 1.7.60-dev → 1.8.3-dev

package/src/api/agent.js

@@ -1,95 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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.emit('joinTunnelAgent', {
-        id: this.id,
-        token: this.token,
-      });
-    });
-    this.socket.on('disconnect', () => {
-      this.connected = false;
-      logger.info(LOG_SOCKET_DISCONNECTED);
-      this.emit(SOCKET_IO_EVENT_DISCONNECTED);
-    });
-    this.socket.on('fetchTunnelAgentSuccess', (data) => {
-      logger.debug('Socket fetch success');
-      this.emit(SOCKET_IO_EVENT_FETCH_SUCCESS, data);
-    });
-    this.socket.on('fetchTunnelAgentFailed', (code) => {
-      logger.debug('Socket fetch failed');
-      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

@@ -1,239 +0,0 @@
-const { resolve } = require('path');
-const {
-  mkdirSync,
-  readFileSync,
-  chmodSync,
-  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'));
-    }
-    try {
-      chmodSync(this.dir, 0o777);
-    } catch {
-      // do nothing
-    }
-  }
-
-  createEmptyFile() {
-    try {
-      writeFileSync(this.file, '{}', 'utf-8');
-    } catch (err) {
-      throw new Error(ERR_CANT_CREATE_DIR_IN_HOME('.bdy/cfg.json'));
-    }
-    try {
-      chmodSync(this.file, 0o666);
-    } catch {
-      // do nothing
-    }
-  }
-
-  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) {
-    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 (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) {
-    this.ensureTunnels();
-    this.json.tunnels[name] = await this.prepareTunnel(type, target, {
-      name,
-      ...options
-    }, false);
-    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'));
-    }
-    try {
-      chmodSync(this.file, 0o666);
-    } catch {
-      // do nothing
-    }
-  }
-}
-
-module.exports = new Cfg();