bdy 1.7.60-dev → 1.8.3-dev

package/src/format.js

@@ -1,171 +0,0 @@
-const {
-  TLS_TERMINATE_AT_AGENT,
-  TLS_TERMINATE_AT_REGION,
-  TUNNEL_HTTP,
-  TARGET_ONLY_PORT_REGEX,
-  TARGET_HTTP_REGEX,
-  TARGET_TCP_TLS_REGEX,
-  TUNNEL_TCP,
-  TUNNEL_TLS,
-  TUNNEL_IDENTIFIED_HTTP1
-} = require('./utils');
-
-class Format {
-  static date() {
-    const dt = new Date();
-    return dt.toISOString();
-  }
-
-  static token(token) {
-    if (!token || token.length < 6) return 'Not provided';
-    return token.substring(0, 3) + '...' + token.substring(token.length - 3);
-  }
-
-  static region(region) {
-    if (!region) return 'Autodetect';
-    return region.toUpperCase();
-  }
-
-  static timeout(timeout) {
-    if (timeout === 1) return '1 second';
-    return `${timeout} seconds`;
-  }
-
-  static tunnelTimeout(timeout) {
-    if (!timeout) return 'Default';
-    return this.timeout(timeout);
-  }
-
-  static whitelist(whitelist) {
-    if (!whitelist || !whitelist.length) return 'Everyone';
-    if (whitelist.includes('*')) return 'Everyone';
-    return whitelist.join('\n');
-  }
-
-  static tunnelWhitelist(whitelist) {
-    if (!whitelist) return 'Default';
-    return this.whitelist(whitelist);
-  }
-
-  static tunnelHeaders(headers) {
-    if (!headers || !headers.length) return 'Not set';
-    return headers.map((h) => `${h.name}: ${h.value}`).join('\n');
-  }
-
-  static tunnelCircuitBreaker(cb) {
-    if (cb === undefined || cb === null) return 'Not set';
-    return String(cb);
-  }
-
-  static tunnelUserAgent(userAgents) {
-    if (!userAgents || !userAgents.length) return 'Everyone';
-    return userAgents.join('\n');
-  }
-
-  static tunnelDomain(domain) {
-    if (!domain) return 'Default';
-    return domain;
-  }
-
-  static type(type) {
-    return type.toUpperCase();
-  }
-
-  static tunnelRegion(region) {
-    if (!region) return 'Default';
-    return this.region(region);
-  }
-
-  static identify(identifyType) {
-    if (identifyType === TUNNEL_IDENTIFIED_HTTP1) return 'Ver. 1.1';
-    return 'Ver. 2';
-  }
-
-  static terminate(terminate) {
-    if (terminate === TLS_TERMINATE_AT_AGENT) return 'AGENT';
-    if (terminate === TLS_TERMINATE_AT_REGION) return 'REGION';
-    return 'TARGET';
-  }
-
-  static serve(serve) {
-    return serve;
-  }
-
-  static hostHeader(host) {
-    if (!host) return 'Not set';
-    return host;
-  }
-
-  static basicAuth(login, pass) {
-    if (!login || !pass) return 'Not set';
-    return `${login}:${pass}`;
-  }
-
-  static latency(latency) {
-    if (latency < 0) return 'Unreachable';
-    if (latency < 1000) return `${latency.toFixed(0)}ms`;
-    return `${(latency / 1000).toFixed(0)}s`;
-  }
-
-  static yesNo(val) {
-    if (!val) return 'No';
-    return 'Yes';
-  }
-
-  static entryHost(tunnel) {
-    let host = '';
-    host += tunnel.subdomain;
-    host += '.';
-    // todo custom domain
-    host += tunnel.region.toLowerCase();
-    host += '-';
-    host += tunnel.sshId;
-    host += '.';
-    host += tunnel.domain;
-    return host;
-  }
-
-  static entry(tunnel) {
-    let entry = '';
-    if (tunnel.type === TUNNEL_HTTP) entry += 'https://';
-    entry += this.entryHost(tunnel);
-    if (tunnel.type === TUNNEL_TCP) entry += `:${tunnel.sshForwardPort}`;
-    else if (tunnel.type === TUNNEL_TLS) entry += ':443';
-    return entry;
-  }
-
-  static target(type, target) {
-    if (type === TUNNEL_HTTP) {
-      let port = '80';
-      let host = 'localhost';
-      let proto = 'http';
-      let m = target.match(TARGET_ONLY_PORT_REGEX);
-      if (m) {
-        port = m[0];
-      } else {
-        m = target.match(TARGET_HTTP_REGEX);
-        if (m) {
-          if (m[2]) proto = m[2];
-          if (m[4]) host = m[4];
-          if (m[6]) port = m[6];
-          else if (proto === 'https') port = '443';
-        }
-      }
-      let t = `${proto}://${host}`;
-      if (proto === 'http' && port !== '80') t += `:${port}`;
-      else if (proto === 'https' && port !== '443') t += `:${port}`;
-      return t;
-    } else {
-      let host = 'localhost';
-      let port = '80';
-      const m = target.match(TARGET_TCP_TLS_REGEX);
-      if (m) {
-        if (m[3]) port = m[3];
-        if (m[2]) host = m[2];
-      }
-      return `${host}:${port}`;
-    }
-  }
-}
-
-module.exports = Format;

package/src/index.js

@@ -1,38 +0,0 @@
-const commandConfig = require('./command/config.js');
-const Output = require('./output.js');
-const commandTcp = require('./command/tcp.js');
-const commandTls = require('./command/tls.js');
-const commandHttp = require('./command/http.js');
-const commandStart = require('./command/start.js');
-const commandAgent = require('./command/agent.js');
-const logger = require('./logger.js');
-const commandVersion = require('./command/version.js');
-const commandPre = require('./command/pre.js');
-const stream = require('stream');
-const { isDocker,
-  formatHelp,
-  newCommand
-} = require('./utils');
-const { DESC_PROGRAM } = require('./texts');
-
-stream.setDefaultHighWaterMark(false, 67108864);
-process.title = 'bdy';
-process.on('uncaughtException', (err) => {
-  logger.fatal(err);
-  Output.exitError(err);
-});
-
-const program = newCommand(null, DESC_PROGRAM);
-program.hook('preAction', commandPre);
-program.configureHelp({
-  formatHelp: formatHelp
-});
-program.addCommand(commandConfig);
-program.addCommand(commandTcp);
-program.addCommand(commandTls);
-program.addCommand(commandHttp);
-program.addCommand(commandStart);
-if (!isDocker()) program.addCommand(commandAgent);
-program.addCommand(commandVersion);
-
-program.parse();

package/src/input.js

@@ -1,283 +0,0 @@
-const Output = require('./output.js');
-const netmask = require('netmask');
-const fs = require('fs');
-const { statSync } = require('fs');
-const tls = require('tls');
-const crypto = require('crypto');
-const {
-  isStringRegExp,
-  REGION_EU,
-  REGION_US,
-  TARGET_HTTP_REGEX,
-  TARGET_ONLY_PORT_REGEX,
-  TARGET_TCP_TLS_REGEX,
-  TLS_TERMINATE_AT_AGENT,
-  TLS_TERMINATE_AT_REGION,
-  TLS_TERMINATE_AT_TARGET,
-  TUNNEL_HTTP,
-  TUNNEL_TCP,
-  TUNNEL_TLS
-} = require('./utils.js');
-const {
-  ERR_BA_IS_NOT_VALID,
-  ERR_BA_LOGIN_NOT_PROVIDED,
-  ERR_BA_PASSWORD_NOT_PROVIDED,
-  ERR_CA_PATH_IS_NOT_VALID,
-  ERR_CB_THRESHOLD_IS_NOT_VALID,
-  ERR_CERT_PATH_IS_NOT_VALID,
-  ERR_DIRECTORY_DOES_NOT_EXISTS,
-  ERR_DOMAIN_IS_NOT_VALID,
-  ERR_KEY_PATH_IS_NOT_VALID,
-  ERR_NAME_WITHOUT_ASTERISK,
-  ERR_PATH_IS_NOT_DIRECTORY,
-  ERR_PORT_IS_NOT_VALID,
-  ERR_REGION_IS_NOT_VALID,
-  ERR_SUBDOMAIN_IS_NOT_VALID,
-  ERR_SUBDOMAIN_IS_TOO_LONG,
-  ERR_SUBDOMAIN_IS_TOO_SHORT,
-  ERR_TARGET_IS_NOT_VALID,
-  ERR_TERMINATE_IS_NOT_VALID,
-  ERR_TIMEOUT_IS_NOT_VALID,
-  ERR_TYPE_IS_NOT_VALID,
-  ERR_USER_AGENT_IS_NOT_VALID,
-  ERR_WHITELIST_IS_NOT_VALID,
-  ERR_WRONG_CA,
-  ERR_WRONG_KEY_CERT
-} = require('./texts.js');
-
-class Input {
-  static timeout(timeout) {
-    const t = parseInt(timeout, 10);
-    if (isNaN(t) || t <= 0 || t > 999) {
-      Output.exitError(ERR_TIMEOUT_IS_NOT_VALID(timeout));
-    }
-    return t;
-  }
-
-  static serve(serve) {
-    if (!serve) return serve;
-    try {
-      const info = statSync(serve);
-      if (!info.isDirectory()) {
-        Output.exitError(ERR_PATH_IS_NOT_DIRECTORY(serve));
-      }
-    } catch (err) {
-      Output.exitError(ERR_DIRECTORY_DOES_NOT_EXISTS(serve));
-    }
-    return serve;
-  }
-
-  static circuitBreaker(threshold) {
-    if (threshold === undefined) return null;
-    const n = parseFloat(threshold);
-    if (isNaN(n) || n < 0 || n > 1) {
-      Output.exitError(ERR_CB_THRESHOLD_IS_NOT_VALID(n));
-    }
-    return n;
-  }
-
-  static headers(headers) {
-    const r = [];
-    (headers || []).forEach((h) => {
-      if (!h) return;
-      const s = h.split(':');
-      if (s.length !== 2) return;
-      r.push({
-        name: s[0],
-        value: s[1]
-      });
-    });
-    return r;
-  }
-
-  static subdomain(subdomain) {
-    if (!/^[a-z0-9-]+$/i.test(subdomain)) {
-      Output.exitError(ERR_SUBDOMAIN_IS_NOT_VALID(subdomain));
-    }
-    if (subdomain.length < 5) {
-      Output.exitError(ERR_SUBDOMAIN_IS_TOO_SHORT(subdomain));
-    }
-    if (subdomain.length > 63) {
-      Output.exitError(ERR_SUBDOMAIN_IS_TOO_LONG(subdomain));
-    }
-    return subdomain;
-  }
-
-  static domain(domain) {
-    if (!/^(?:[A-z0-9](?:[A-z0-9-]{0,61}[A-z0-9])?\.)+[A-z0-9][A-z0-9-]{0,61}[A-z0-9]$/i.test(domain)) {
-      Output.exitError(ERR_DOMAIN_IS_NOT_VALID(domain));
-    }
-    return domain;
-  }
-
-  static auth(auth) {
-    const s = auth.split(':');
-    if (s.length !== 2) {
-      Output.exitError(ERR_BA_IS_NOT_VALID(auth));
-    }
-    if (!s[0]) {
-      Output.exitError(ERR_BA_LOGIN_NOT_PROVIDED);
-    }
-    if (!s[1]) {
-      Output.exitError(ERR_BA_PASSWORD_NOT_PROVIDED);
-    }
-    return {
-      login: s[0],
-      password: s[1]
-    };
-  }
-
-  static useragents(useragents) {
-    if (!useragents || !useragents.length) return [];
-    useragents.forEach((ua) => {
-      if (isStringRegExp(ua)) {
-        try {
-          new RegExp(ua);
-        } catch (err) {
-          Output.exitError(ERR_USER_AGENT_IS_NOT_VALID(ua));
-        }
-      }
-    });
-    return useragents;
-  }
-
-  static whitelist(whitelist) {
-    if (!whitelist || !whitelist.length) return [];
-    for (let i = 0; i < whitelist.length; i += 1) {
-      const wh = whitelist[i];
-      if (wh === '*') return ['*'];
-      try {
-        new netmask.Netmask(wh);
-      } catch (err) {
-        Output.exitError(ERR_WHITELIST_IS_NOT_VALID(wh));
-      }
-    }
-    return whitelist;
-  }
-
-  static region(region) {
-    if (!region) Output.exitError(ERR_REGION_IS_NOT_VALID(''));
-    region = region.toUpperCase();
-    if (![REGION_EU, REGION_US].includes(region)) {
-      Output.exitError(ERR_REGION_IS_NOT_VALID(region));
-    }
-    return region;
-  }
-
-  static terminate(terminate) {
-    if (!terminate) return TLS_TERMINATE_AT_REGION;
-    terminate = terminate.toUpperCase();
-    if (![TLS_TERMINATE_AT_AGENT, TLS_TERMINATE_AT_REGION, TLS_TERMINATE_AT_TARGET].includes(terminate)) {
-      Output.exitError(ERR_TERMINATE_IS_NOT_VALID(terminate));
-    }
-    return terminate;
-  }
-
-  static target(target, type) {
-    if (!target) return '80';
-    if (target.length > 200) {
-      Output.exitError(ERR_TARGET_IS_NOT_VALID(target));
-    }
-    target = target.toLowerCase();
-    // 80
-    // localhost
-    // localhost:80
-    // http://localhost:80
-    // http://localhost
-    // http://user:pass@localhost
-    // http://user:pass@localhost:80
-    let port;
-    if ([TUNNEL_TCP, TUNNEL_TLS].includes(type)) {
-      const m = target.match(TARGET_TCP_TLS_REGEX);
-      if (!m) {
-        Output.exitError(ERR_TARGET_IS_NOT_VALID(target));
-      }
-      port = m[3];
-    } else {
-      let m = target.match(TARGET_ONLY_PORT_REGEX);
-      if (m) {
-        port = m[0];
-      } else {
-        m = target.match(TARGET_HTTP_REGEX);
-        if (!m) {
-          Output.exitError(ERR_TARGET_IS_NOT_VALID(target));
-        } else {
-          let proto;
-          if (m[2]) proto = m[2];
-          else proto = 'http';
-          if (m[6]) port = m[6];
-          else if (proto === 'https') port = '443';
-          else port = '80';
-        }
-      }
-    }
-    Input.port(port);
-    return target;
-  }
-
-  static port(port) {
-    const p = parseInt(port, 10);
-    if (isNaN(p) || p <= 0 || p > 65535) Output.exitError(ERR_PORT_IS_NOT_VALID(port));
-    return p;
-  }
-
-  static type(type) {
-    if (!type) return TUNNEL_TCP;
-    type = type.toUpperCase();
-    if (![TUNNEL_TCP, TUNNEL_TLS, TUNNEL_HTTP].includes(type)) {
-      Output.exitError(ERR_TYPE_IS_NOT_VALID(type));
-    }
-    return type;
-  }
-
-  static name(name) {
-    if (name.includes('*')) {
-      Output.exitError(ERR_NAME_WITHOUT_ASTERISK);
-    }
-    return name;
-  }
-
-  static ca(caPath) {
-    let cert;
-    try {
-      cert = fs.readFileSync(caPath, 'utf8');
-    } catch (err) {
-      Output.exitError(ERR_CA_PATH_IS_NOT_VALID(caPath));
-    }
-    try {
-      new crypto.X509Certificate(cert);
-    } catch (err) {
-      Output.exitError(ERR_WRONG_CA(caPath));
-    }
-    return cert;
-  }
-
-  static keyCert(keyPath, certPath) {
-    let key;
-    let cert;
-    try {
-      key = fs.readFileSync(keyPath, 'utf8');
-    } catch (err) {
-      Output.exitError(ERR_KEY_PATH_IS_NOT_VALID(keyPath));
-    }
-    try {
-      cert = fs.readFileSync(certPath, 'utf8');
-    } catch (err) {
-      Output.exitError(ERR_CERT_PATH_IS_NOT_VALID(certPath));
-    }
-    try {
-      tls.createSecureContext({
-        cert,
-        key
-      });
-    } catch (err) {
-      Output.exitError(ERR_WRONG_KEY_CERT);
-    }
-    return {
-      cert,
-      key
-    };
-  }
-}
-
-module.exports = Input;

package/src/logger.js

@@ -1,92 +0,0 @@
-const pino = require('pino');
-const { resolve } = require('path');
-const fs = require('fs');
-const {
-  getHomeDirectory,
-} = require('./utils.js');
-
-class Logger {
-  rootPath = null;
-  logPath = null;
-  log1Path = null;
-  logStream = null;
-  p = null;
-  ts = null;
-  constructor() {
-    this.rootPath = getHomeDirectory();
-  }
-  checkLogSize() {
-    try {
-      const s = fs.statSync(this.logPath);
-      if (s.size > 5242880) {
-        fs.copyFileSync(this.logPath, this.log1Path);
-        fs.truncateSync(this.logPath);
-      }
-    } catch {
-      // do nothing
-    }
-  }
-  getPino() {
-    if (!this.p) {
-      this.logPath = resolve(this.rootPath, 'cli.log');
-      this.log1Path = resolve(this.rootPath, 'cli.1.log');
-      this.logStream = fs.openSync(this.logPath, 'w');
-      try {
-        fs.chmodSync(this.logPath, 0o666);
-      } catch {
-        // do nothing
-      }
-      this.p = pino({
-        level: process.env.DEBUG === '1' ? 'debug' : 'info',
-        timestamp: () => `, "time": "${new Date().toISOString()}"`,
-        formatters: {
-          bindings: () => ({}),
-          level: (label) => ({
-            level: label.toUpperCase()
-          })
-        }
-      }, pino.destination(this.logStream));
-      this.checkLogSize();
-      this.ts = setInterval(() => {
-        this.checkLogSize();
-      }, 30000);
-    }
-    return this.p;
-  }
-  error(...args) {
-    this.getPino().error(...args);
-  }
-  info(...args) {
-    this.getPino().info(...args);
-  }
-  debug(...args){
-    this.getPino().debug(...args);
-  }
-  fatal(...args){
-    this.getPino().fatal(...args);
-  }
-
-  stack() {
-    this.getPino().info(new Error().stack);
-  }
-
-  changeRootPath(path) {
-    if (this.ts) {
-      clearInterval(this.ts);
-      this.ts = null;
-    }
-    if (this.logStream) {
-      try {
-        this.logStream.close();
-      } catch {
-        // do nothing
-      }
-      this.logStream = null;
-    }
-    this.p = null;
-    this.rootPath = path;
-
-  }
-}
-
-module.exports = new Logger();