bdy 1.7.46-dev

package/src/ssh/client.js

@@ -0,0 +1,196 @@
+const { Client } = require('ssh2');
+const EventEmitter = require('events');
+const logger = require('../logger.js');
+const {
+  ERR_WRONG_HANDSHAKE,
+  ERR_WRONG_STREAM,
+  LOG_DETECTED_STREAM,
+  LOG_SSH_CONNECTION,
+  LOG_WRONG_STREAM
+} = require('../texts.js');
+const { SSH_CLIENT_EVENT_CONNECTED,
+  SSH_CLIENT_EVENT_DISCONNECTED,
+  SSH_CLIENT_EVENT_STREAM_TCP,
+  SSH_CLIENT_EVENT_STREAM_TLS,
+  SSH_CLIENT_EVENT_STREAM_HTTP1,
+  SSH_CLIENT_EVENT_STREAM_HTTP2,
+  SOCKET_TYPE_TCP,
+  SOCKET_TYPE_TLS,
+  SOCKET_TYPE_HTTP1,
+  SOCKET_TYPE_HTTP2,
+  SOCKET_TYPE_SSH,
+  SSH_CLIENT_EVENT_STREAM_SSH
+} = require('../utils');
+
+class SshClient extends EventEmitter {
+  constructor(ip, port, username, password) {
+    super();
+    this.ip = ip;
+    this.port = port;
+    this.username = username;
+    this.password = password;
+    this.keepalive = false;
+  }
+
+  async open() {
+    return new Promise((resolve, reject) => {
+      this.close();
+      this.client = new Client();
+      this.client.setNoDelay();
+      this.client.on('ready', () => {
+        this.client.removeAllListeners();
+        this.client.on('error', () => {
+        });
+        resolve();
+      });
+      this.client.once('error', (err) => {
+        this.client.removeAllListeners();
+        reject(err);
+      });
+      try {
+        this.client.connect({
+          algorithms:{
+            cipher: ['aes256-gcm@openssh.com'],
+            compress: ['none'],
+            hmac: ['hmac-sha2-256-etm@openssh.com'],
+            kex: ['ecdh-sha2-nistp256']
+          },
+          keepaliveInterval: 60000,
+          host: this.ip,
+          port: this.port,
+          username: this.username,
+          password: this.password
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  waitForStreamReadable(s){
+    return new Promise((resolve) => {
+      s.once('readable', resolve);
+    });
+  }
+
+  async readStreamBytes(s, toRead){
+    await this.waitForStreamReadable(s);
+    const data = s.read(toRead) ?? s.read();
+    if (data === null) {
+      return this.readStreamBytes(s, toRead);
+    }
+    const newToRead = toRead - data.length;
+    if (newToRead <= 0) return data;
+    const newData = await this.readStreamBytes(s, newToRead);
+    return Buffer.concat([data, newData]);
+  }
+
+  async processStream(stream, info) {
+    if (stream.readableFlowing) stream.pause();
+    stream.on('error', () => {
+      stream.removeAllListeners();
+      try {
+        stream.close();
+      } catch (err) {
+        // do nothing
+      }
+    });
+    stream.on('close', () => {
+      stream.removeAllListeners();
+    });
+    const triggerStream = (type, ip) => {
+      stream.removeAllListeners();
+      this.emit(type, stream, info, ip);
+    };
+    let type;
+    let ip;
+    try {
+      const b = await this.readStreamBytes(stream, 50);
+      const s = b.toString('utf8').replace(/\s+/, ' ').split(' ');
+      if (s.length !== 2) throw new Error(ERR_WRONG_HANDSHAKE);
+      type = parseInt(s[0]);
+      ip = s[1];
+    } catch (err) {
+      stream.emit('error', err);
+      return;
+    }
+    if (type === SOCKET_TYPE_TLS) {
+      logger.debug(LOG_DETECTED_STREAM('TLS'));
+      triggerStream(SSH_CLIENT_EVENT_STREAM_TLS, ip);
+      return;
+    }
+    if (type === SOCKET_TYPE_HTTP1) {
+      logger.debug(LOG_DETECTED_STREAM('HTTP1'));
+      triggerStream(SSH_CLIENT_EVENT_STREAM_HTTP1, ip);
+      return;
+    }
+    if (type === SOCKET_TYPE_HTTP2) {
+      logger.debug(LOG_DETECTED_STREAM('HTTP2'));
+      triggerStream(SSH_CLIENT_EVENT_STREAM_HTTP2, ip);
+      return;
+    }
+    if (type === SOCKET_TYPE_TCP) {
+      logger.debug(LOG_DETECTED_STREAM('TCP'));
+      triggerStream(SSH_CLIENT_EVENT_STREAM_TCP, ip);
+      return;
+    }
+    if (type === SOCKET_TYPE_SSH) {
+      logger.debug(LOG_DETECTED_STREAM('SSH'));
+      triggerStream(SSH_CLIENT_EVENT_STREAM_SSH, ip);
+      return;
+    }
+    logger.debug(LOG_WRONG_STREAM);
+    stream.emit('error', new Error(ERR_WRONG_STREAM));
+  }
+
+  forwardIn(port) {
+    return new Promise((resolve, reject) => {
+      this.client.on('tcp connection', async (info, accept) => {
+        logger.debug(LOG_SSH_CONNECTION);
+        return this.processStream(accept(), info);
+      });
+      this.client.forwardIn('0.0.0.0', port, (err) => {
+        if (err) reject(err);
+        else resolve(err);
+      });
+    });
+  }
+
+  closeKeepAlive() {
+    this.keepalive = false;
+    this.close();
+  }
+
+  openKeepAlive() {
+    this.keepalive = true;
+    this.open()
+      .then(() => {
+        this.emit(SSH_CLIENT_EVENT_CONNECTED);
+        this.client.on('close', () => {
+          if (this.keepalive) this.openKeepAlive();
+        });
+      })
+      .catch(() => {
+        this.emit(SSH_CLIENT_EVENT_DISCONNECTED);
+        setTimeout(() => {
+          if (this.keepalive) this.openKeepAlive();
+        }, 3000);
+      });
+  }
+
+  close() {
+    if (this.client) {
+      try {
+        this.client.removeAllListeners();
+        this.client.on('error', () => {
+        });
+        this.client.end();
+      } catch (err) {
+        // nic nie rob
+      }
+      this.client = null;
+    }
+  }
+}
+
+module.exports = SshClient;

package/src/texts.js

@@ -0,0 +1,447 @@
+const ERR_AGENT_NOT_REGISTERED = 'Agent not registered. Exiting...';
+const ERR_SAVING_AGENT_CONFIG = 'Error while saving agent config. Exiting...';
+const ERR_TARGET_IS_NOT_VALID = (target) => `Target '${target}' is not a valid value`;
+const ERR_TYPE_IS_NOT_VALID = (type) => `Type '${type}' is not a valid value`;
+const ERR_TIMEOUT_IS_NOT_VALID = (timeout) => `Timeout '${timeout}' is not a valid value`;
+const ERR_TERMINATE_IS_NOT_VALID = (terminate) => `Terminate '${terminate}' is not a valid value`;
+const ERR_SUBDOMAIN_IS_NOT_VALID = (subdomain) => `Subdomain '${subdomain}' is not a valid value`;
+const ERR_SUBDOMAIN_IS_TOO_SHORT = (subdomain) => `Subdomain '${subdomain}' is too short`;
+const ERR_SUBDOMAIN_IS_TOO_LONG = (subdomain) => `Subdomain '${subdomain}' is too long`;
+const ERR_DIRECTORY_DOES_NOT_EXISTS = (dir) => `Directory '${dir}' does not exists`;
+const ERR_PATH_IS_NOT_DIRECTORY = (path) => `Path '${path}' is not a directory`;
+const ERR_REGION_IS_NOT_VALID = (region) => `Region '${region}' is not a valid value`;
+const ERR_PORT_IS_NOT_VALID = (port) => `Port '${port}' is not a valid value`;
+const ERR_NAME_WITHOUT_ASTERISK = 'Name cannot contain \'*\'';
+const ERR_WRONG_KEY_CERT = 'Wrong TLS key or certificate';
+const ERR_WRONG_CA = (path) => `TLS CA certificate '${path}' is not valid`;
+const ERR_CA_PATH_IS_NOT_VALID = (path) => `Path to TLS CA certificate '${path}' is not valid`;
+const ERR_KEY_PATH_IS_NOT_VALID = (path) => `Path to TLS key '${path}' is not valid`;
+const ERR_CERT_PATH_IS_NOT_VALID = (path) => `Path to TLS certificate '${path}' is not valid`;
+const ERR_DOMAIN_IS_NOT_VALID = (domain) => `Domain '${domain}' is not a valid value`;
+const ERR_CB_THRESHOLD_IS_NOT_VALID = (val) => `Circuit breaker threshold '${val}' is not a valid value`;
+const ERR_BA_PASSWORD_NOT_PROVIDED = 'Basic Auth password is not provided';
+const ERR_BA_LOGIN_NOT_PROVIDED = 'Basic Auth login is not provided';
+const ERR_BA_IS_NOT_VALID = (auth) => `Basic Auth '${auth}' is not a valid value`;
+const ERR_USER_AGENT_IS_NOT_VALID = (ua) => `User-Agent '${ua}' is not a valid regexp`;
+const ERR_WHITELIST_IS_NOT_VALID = (wh) => `Whitelist '${wh}' is not a valid CIDR address`;
+const ERR_TUNNEL_NOT_FOUND = (name) => `Tunnel '${name}' not found`;
+const ERR_AGENT_NOT_ENABLED = 'Agent is not enabled';
+const ERR_AGENT_NOT_RUNNING = 'Agent is not running';
+const ERR_AGENT_NOT_FOUND = 'Agent is not found';
+const ERR_AGENT_DOCKER_NOT_FOUND = 'Can\'t manage agent. First install Docker and enable it for current user';
+const ERR_SWW_AGENT_ENABLING = 'Something went wrong while enabling agent';
+const ERR_SWW_AGENT_DISABLING = 'Something went wrong while disabling agent';
+const ERR_SWW_AGENT_UPDATING = 'Something went wrong while updating agent';
+const ERR_AGENT_ENABLE = 'Can\'t start agent. Enable it first';
+const ERR_AGENT_ADMIN_RIGHTS = 'Command must be run with administrator rights';
+const ERR_AGENT_NOT_SUPPORTED = 'Starting agent is not supported';
+const ERR_TUNNEL_ALREADY_EXISTS = 'Tunnel with that name already exists. Change name or use -f flag to overwrite it';
+const ERR_FAILED_TO_CONNECT = (host) => `Failed to connect to '${host}'`;
+const ERR_AGENT_REMOVED = 'Agent has been removed';
+const ERR_SUBDOMAIN_TAKEN = 'Subdomain already reserved';
+const ERR_TUNNEL_LIMIT_REACHED = 'Limit of tunnels reached';
+const ERR_AGENT_LIMIT_REACHED = 'Limit of agents reached';
+const ERR_TUNNELS_DISABLED = 'Tunnels disabled';
+const ERR_TUNNEL_REMOVED = 'Tunnel has been removed';
+const ERR_FAILED_TO_CONNECT_TO_AGENT = 'Failed to connect to agent';
+const ERR_NOT_FOUND = 'Not found';
+const ERR_SWW = 'Something went wrong';
+const ERR_FETCH_VERSION = 'Failed to fetch version';
+const ERR_WRONG_HANDSHAKE = 'Wrong handshake data';
+const ERR_WRONG_STREAM = 'Wrong stream type';
+const ERR_CONNECTION_TIMEOUT = 'Connection timeout';
+const ERR_CONNECTION_ERROR = 'Connection error';
+const ERR_CANT_CREATE_DIR_IN_HOME = (dir) => `Can't create '${dir}' in home directory`;
+const ERR_TOKEN_NOT_PROVIDED = 'Token not provided';
+const ERR_WRONG_TOKEN = 'Wrong token';
+const ERR_CONFIG_CORRUPTED = 'Config file is corrupted';
+
+const TXT_AGENT_STOPPED = 'Agent stopped';
+const TXT_AGENT_STARTED = 'Agent started';
+const TXT_AGENT_RESTARTED = 'Agent restarted';
+const TXT_AGENT_IS_ENABLED_AND_STARTED = 'Agent is enabled & started';
+const TXT_AGENT_IS_ENABLED_AND_STOPPED = 'Agent is enabled & stopped';
+const TXT_AGENT_IS_ENABLED_AND_INITIALIZING = 'Agent is enabled & initializing';
+const TXT_AGENT_IS_ENABLED_AND_HAVE_TROUBLES = 'Agent is enabled & have connection issues';
+const TXT_AGENT_IS_DISABLED = 'Agent is disabled';
+const TXT_AGENT_ENABLED = 'Agent enabled';
+const TXT_AGENT_UPDATED = 'Agent updated';
+const TXT_AGENT_ALREADY_ENABLED = 'Agent already enabled';
+const TXT_AGENT_DISABLED = 'Agent disabled';
+const TXT_AGENT_ALREADY_DISABLED = 'Agent already disabled';
+const TXT_TUNNEL_STARTED = (type) => `${type} tunnel started`;
+const TXT_TUNNEL_STOPPED = 'Tunnel stopped';
+const TXT_WHITELIST_SAVED = 'Whitelist saved';
+const TXT_TOKEN_SAVED = 'Token saved';
+const TXT_TIMEOUT_SAVED = 'Timeout saved';
+const TXT_REGION_SAVED = 'Region saved';
+const TXT_TUNNEL_REMOVED = 'Tunnel removed';
+const TXT_TUNNEL_ADDED = 'Tunnel added';
+
+const NO_TUNNELS_STARTED = 'No tunnels started';
+const AGENT_FETCH_RETRY = 'Agent fetch failed. Retrying in 3s...';
+
+const DESC_COMMAND_CONFIG_ADD_HTTP = 'add HTTP tunnel to config';
+const DESC_COMMAND_CONFIG_ADD_TCP = 'add TCP tunnel to config';
+const DESC_COMMAND_CONFIG_ADD_TLS = 'add TLS tunnel to config';
+const DESC_COMMAND_CONFIG_GET_REGION = 'get default region';
+const DESC_COMMAND_CONFIG_GET_TIMEOUT = 'get default timeout';
+const DESC_COMMAND_CONFIG_GET_TOKEN = 'get authorization token';
+const DESC_COMMAND_CONFIG_GET_TUNNEL = 'get tunnel configuration';
+const DESC_COMMAND_CONFIG_GET_TUNNELS = 'get tunnels';
+const DESC_COMMAND_CONFIG_GET_WHITELIST = 'get default whitelist';
+const DESC_COMMAND_CONFIG_REMOVE_TUNNEL = 'remove tunnel';
+const DESC_COMMAND_CONFIG_SET_REGION = 'set default region';
+const DESC_COMMAND_CONFIG_SET_TIMEOUT = 'set default timeout';
+const DESC_COMMAND_CONFIG_SET_TOKEN = 'set default authorization token';
+const DESC_COMMAND_CONFIG_SET_WHITELIST = 'set default whitelist';
+const DESC_COMMAND_CONFIG_ADD = 'add configuration';
+const DESC_COMMAND_CONFIG_GET = 'get configuration';
+const DESC_COMMAND_CONFIG_REMOVE = 'remove configuration';
+const DESC_COMMAND_CONFIG_SET = 'set configuration';
+const DESC_COMMAND_AGENT_TUNNEL_HTTP = 'start HTTP tunnel in agent';
+const DESC_COMMAND_AGENT_TUNNEL_LIST = 'list tunnels in agent';
+const DESC_COMMAND_AGENT_TUNNEL_START = 'start tunnel in agent from config';
+const DESC_COMMAND_AGENT_TUNNEL_STATUS = 'status of tunnel in agent';
+const DESC_COMMAND_AGENT_TUNNEL_STOP = 'stop tunnel in agent';
+const DESC_COMMAND_AGENT_TUNNEL_TCP = 'start TCP tunnel in agent';
+const DESC_COMMAND_AGENT_TUNNEL_TLS = 'start TLS tunnel in agent';
+const DESC_COMMAND_AGENT_DISABLE = 'disable agent';
+const DESC_COMMAND_AGENT_ENABLE = 'enable agent';
+const DESC_COMMAND_AGENT_START = 'start agent';
+const DESC_COMMAND_AGENT_RESTART = 'restart agent';
+const DESC_COMMAND_AGENT_STATUS = 'agent status';
+const DESC_COMMAND_AGENT_STOP = 'stop agent';
+const DESC_COMMAND_AGENT_TUNNEL = 'manage agent tunnels';
+const DESC_COMMAND_AGENT_UPDATE = 'update agent version';
+const DESC_COMMAND_AGENT_VERSION = 'agent version';
+const DESC_COMMAND_CONFIG = 'manage configuration';
+const DESC_COMMAND_HTTP = 'start HTTP tunnel';
+const DESC_COMMAND_AGENT = 'manage agent';
+const DESC_COMMAND_START = 'start tunnel from config';
+const DESC_COMMAND_TCP = 'start TCP tunnel';
+const DESC_COMMAND_TLS = 'start TLS tunnel';
+
+const TXT_NEW_CLI_DOCKER_VERSION = (version) => `There is a new CLI Docker image version (${version})\n\n`;
+const TXT_NEW_CLI_VERSION = (version) => `There is a new CLI version (${version})\n\n`;
+const TXT_NEW_AGENT_VERSION = (version) => `Agent needs update. To update it to version ${version} run:\n\`bdy agent update\`\n\n`;
+const TXT_NEW_CLI_AGENT_VERSION = (version) => `There is a new CLI version (${version}). After upgrading CLI update agent:\n\`bdy agent update\`\n\n`;
+const TXT_DISABLING_AGENT = 'Disabling agent...';
+const TXT_ENABLING_AGENT = 'Enabling agent...';
+const TXT_UPDATING_AGENT = 'Updating agent...';
+const TXT_OPENING_TUNNEL = 'Opening tunnel...';
+
+const OPTION_REGION = 'override default region ("eu", "us")';
+const OPTION_DEFAULT_REGION = 'default region ("eu", "us")';
+const OPTION_WHITELIST = 'whitelist provided IP CIDRs. Use "*" to allow all';
+const OPTION_HEADER = 'header key:value to add to the request';
+const OPTION_RESPONSE_HEADER = 'header key:value to add to the response';
+const OPTION_HEADER_USER_AGENT = 'whitelist browser user-agent by contained text or regular expressions (e.g. /my-user-agent/). By Default all are allowed';
+const OPTION_SERVE = 'serve files from a directory';
+const OPTION_SUBDOMAIN = 'provide custom subdomain';
+const OPTION_FOLLOW = 'follow tunnel details';
+const OPTION_DOMAIN = 'provide custom domain';
+const OPTION_TIMEOUT = 'enforce connection timeout in seconds';
+const OPTION_TOKEN = 'token to authorize agent';
+const OPTION_FORCE = 'overwrite tunnel if it already exist';
+const OPTION_HTTP_HOST = 'provide custom http host header';
+const OPTION_HTTP_AUTH = 'enforce http basic authorization';
+const OPTION_HTTP_LOG = 'log http requests';
+const OPTION_HTTP_VERIFY = 'enforce TLS verify';
+const OPTION_HTTP_2 = 'enforce HTTP/2';
+const OPTION_HTTP_COMPRESSION = 'turn on HTTP response compression';
+const OPTION_HTTP_CIRCUIT_BREAKER = 'turn on circuit breaker. Provide decimal value between 0 to 1';
+const OPTION_TLS_KEY = 'path to a TLS key';
+const OPTION_TLS_CERT = 'path to a TLS PEM certificate';
+const OPTION_TLS_CA = 'path to a TLS PEM CA certificate for TLS auth';
+const OPTION_TLS_TERMINATE = 'terminate TLS at "target", "agent", "region". By default TLS is terminated at "region"';
+const OPTION_TARGET = 'target address to redirect traffic to. Host is optional and by default local machine. Port is by default 80';
+const OPTION_NAME = 'name of the tunnel';
+const OPTION_ID = 'id of the tunnel';
+const OPTION_AGENT_ID = 'start existing agent';
+const OPTION_AGENT_START = 'start agent right away';
+const OPTION_AGENT_TOKEN = 'token to authorize existing agent agent or token to add a new agent';
+const OPTION_USER = 'name of the user in OS. By default agent is run as root (macOS/Linux) or LocalSystem account (Windows). Under Windows user must be passed as DOMAIN\\USER (to find out full name use `whoami` command)';
+const OPTION_PASS = 'password of the user. Only set for Windows';
+const OPTION_AGENT_PORT = 'agent api port';
+const OPTION_AGENT_DEBUG = 'turns on debug mode';
+
+const LOG_REGISTERING_AGENT = 'Registering agent...';
+const LOG_SAVING_AGENT_CONFIG = 'Saving agent config...';
+const LOG_SAVING_AGENT_SYSTEM_CONFIG = 'Saving agent system config...';
+const LOG_SAVING_AGENT_LOCAL_CONFIG = 'Saving agent local config...';
+const LOG_ERROR_SAVING_AGENT_CONFIG = 'Error while saving agent config';
+const LOG_ERROR_SAVING_AGENT_SYSTEM_CONFIG = 'Error while saving agent system config';
+const LOG_ERROR_SAVING_AGENT_LOCAL_CONFIG = 'Error while saving agent local config';
+const LOG_AGENT_SYSTEM_DIR = 'Creating agent system directory...';
+const LOG_AGENT_DOWNLOADING_ARCHIVE = 'Downloading agent archive...';
+const LOG_AGENT_EXTRACTING_ARCHIVE = 'Extracting agent archive...';
+const LOG_AGENT_SYSTEM_SERVICE_CONFIG = 'Saving agent system service config...';
+const LOG_AGENT_ENABLING_SYSTEM = 'Enabling agent in system...';
+const LOG_AGENT_STOPPING_SYSTEM = 'Stopping agent in system...';
+const LOG_AGENT_STARTING_SYSTEM = 'Starting agent in system...';
+const LOG_AGENT_ENABLED = 'Agent enabled in system';
+const LOG_AGENT_NSSM_DOWNLOADING = 'Agent nssm downloading...';
+const LOG_AGENT_NSSM_EXTRACTING = 'Agent nssm extracting...';
+const LOG_AGENT_NSSM_CLEARING = 'Agent nssm clearing...';
+const LOG_SOCKET_CONNECTED = 'Socket connected';
+const LOG_SOCKET_DISCONNECTED = 'Socket disconnected';
+const LOG_AGENT_REGISTERED = (id) => `Agent registered with id '${id}'`;
+const LOG_REGION_DETECTED = (region) => `Detected region '${region}'`;
+const LOG_UNREGISTERING_AGENT = 'Unregistering agent...';
+const LOG_GETTING_AGENT = 'Getting agent...';
+const LOG_REGISTERING_TUNNEL = 'Registering tunnel...';
+const LOG_ERROR_WHILE_REFRESHING_AGENT = 'Error while refreshing agent';
+const LOG_TUNNEL_REGISTERED = (id) => `Tunnel registered with id '${id}'`;
+const LOG_REMOVING_TUNNEL = 'Removing tunnel...';
+const LOG_STARTING_TUNNEL = (id) => `Starting tunnel '${id}'`;
+const LOG_STOPPING_TUNNEL = (id) => `Stopping tunnel '${id}'`;
+const LOG_ERROR = 'error';
+const LOG_HTTP1_CONNECTION = (ip) => `HTTP1 server will handle tunnel connection from ${ip}`;
+const LOG_HTTP1_REQUEST = (method, url) => `HTTP1 server new request ${method} ${url}`;
+const LOG_HTTP2_CONNECTION = (ip) => `HTTP2 server will handle tunnel connection from ${ip}`;
+const LOG_HTTP2_REQUEST = (method, url) => `HTTP2 server new request ${method} ${url}`;
+const LOG_DETECTED_STREAM = (type) => `Detected stream '${type}'`;
+const LOG_WRONG_STREAM = 'Wrong stream type';
+const LOG_SSH_CONNECTION = 'New SSH tcp connection';
+const LOG_REQUEST = (url) => `request: ${url}`;
+const LOG_ERROR_STARTING_AGENT_SERVER = 'Error while starting agent api server';
+const LOG_AGENT_SERVER_STARTED = 'Agent server started';
+const LOG_AGENT_STARTED = 'Agent started';
+const LOG_TUNNEL_CONNECTED = (id, port) => `Tunnel '${id}' connected. Forwarding port '${port}'`;
+const LOG_TUNNEL_FAILED = (id) => `Tunnel '${id}' forwarding failed`;
+const LOG_TUNNEL_DISCONNECTED = (id) => `Tunnel '${id}' disconnected`;
+const LOG_TUNNEL_IDENTIFIED = (id, type) => `Tunnel ${id} identified as ${type}`;
+const LOG_TUNNEL_HTTP_WRON_AUTH = 'HTTP request wrong basic auth';
+const LOG_TUNNEL_HTTP_RATE_LIMIT = 'HTTP request rate limited';
+const LOG_TUNNEL_HTTP_CIRCUIT_BREAKER_OPEN = 'HTTP request circuit breaker open';
+const LOG_TUNNEL_HTTP_WRONG_USER_AGENTS = 'HTTP request wrong user-agents';
+const LOG_TUNNEL_TCP_STREAM = (id) => `New TCP connection on tunnel '${id}'. Stream to target`;
+const LOG_TUNNEL_HTTP1_STREAM = (id) => `New HTTP1 connection on tunnel '${id}'. Handle HTTP1`;
+const LOG_TUNNEL_HTTP2_STREAM = (id) => `New HTTP2 connection on tunnel '${id}'. Handle HTTP2`;
+const LOG_TUNNEL_TLS_TARGET_STREAM = (id) => `New TLS connection on tunnel '${id}'. Terminated at target. Stream to target`;
+const LOG_TUNNEL_TLS_REGION_STREAM = (id) => `New TLS connection on tunnel '${id}'. Terminated at region. Stream to target`;
+const LOG_TUNNEL_TLS_AGENT_STREAM = (id) => `New TLS connection on tunnel '${id}'. Terminated at agent. Handle TLS`;
+const LOG_TUNNEL_SSH_STREAM = (id) => `New SSH connection on tunnel '${id}'. Stream to localhost`;
+
+module.exports = {
+  LOG_ERROR_WHILE_REFRESHING_AGENT,
+  LOG_STOPPING_TUNNEL,
+  LOG_STARTING_TUNNEL,
+  LOG_TUNNEL_TLS_AGENT_STREAM,
+  LOG_TUNNEL_SSH_STREAM,
+  LOG_TUNNEL_TLS_REGION_STREAM,
+  LOG_TUNNEL_TLS_TARGET_STREAM,
+  LOG_TUNNEL_HTTP2_STREAM,
+  LOG_TUNNEL_HTTP1_STREAM,
+  LOG_TUNNEL_TCP_STREAM,
+  LOG_TUNNEL_HTTP_WRONG_USER_AGENTS,
+  LOG_TUNNEL_HTTP_CIRCUIT_BREAKER_OPEN,
+  LOG_TUNNEL_HTTP_RATE_LIMIT,
+  LOG_TUNNEL_HTTP_WRON_AUTH,
+  LOG_TUNNEL_IDENTIFIED,
+  LOG_TUNNEL_DISCONNECTED,
+  LOG_TUNNEL_FAILED,
+  LOG_TUNNEL_CONNECTED,
+  LOG_AGENT_STARTED,
+  LOG_AGENT_SERVER_STARTED,
+  LOG_ERROR_STARTING_AGENT_SERVER,
+  LOG_REQUEST,
+  LOG_SSH_CONNECTION,
+  LOG_WRONG_STREAM,
+  LOG_DETECTED_STREAM,
+  LOG_HTTP2_REQUEST,
+  LOG_HTTP2_CONNECTION,
+  LOG_HTTP1_REQUEST,
+  LOG_HTTP1_CONNECTION,
+  LOG_ERROR,
+  LOG_REMOVING_TUNNEL,
+  LOG_TUNNEL_REGISTERED,
+  LOG_REGISTERING_TUNNEL,
+  LOG_GETTING_AGENT,
+  LOG_UNREGISTERING_AGENT,
+  LOG_REGION_DETECTED,
+  LOG_AGENT_REGISTERED,
+  LOG_REGISTERING_AGENT,
+  OPTION_AGENT_PORT,
+  OPTION_AGENT_DEBUG,
+  OPTION_AGENT_TOKEN,
+  OPTION_AGENT_ID,
+  OPTION_AGENT_START,
+  OPTION_ID,
+  OPTION_NAME,
+  OPTION_TARGET,
+  OPTION_TLS_TERMINATE,
+  OPTION_TLS_CA,
+  OPTION_TLS_CERT,
+  OPTION_TLS_KEY,
+  OPTION_HTTP_CIRCUIT_BREAKER,
+  OPTION_HTTP_COMPRESSION,
+  OPTION_HTTP_2,
+  OPTION_HTTP_VERIFY,
+  OPTION_HTTP_LOG,
+  OPTION_HTTP_AUTH,
+  OPTION_HTTP_HOST,
+  OPTION_FORCE,
+  OPTION_TOKEN,
+  OPTION_TIMEOUT,
+  OPTION_DOMAIN,
+  OPTION_FOLLOW,
+  OPTION_SUBDOMAIN,
+  OPTION_SERVE,
+  OPTION_HEADER_USER_AGENT,
+  OPTION_RESPONSE_HEADER,
+  OPTION_HEADER,
+  OPTION_WHITELIST,
+  OPTION_DEFAULT_REGION,
+  OPTION_USER,
+  OPTION_PASS,
+  OPTION_REGION,
+  DESC_COMMAND_TLS,
+  DESC_COMMAND_TCP,
+  DESC_COMMAND_START,
+  DESC_COMMAND_AGENT,
+  DESC_COMMAND_HTTP,
+  DESC_COMMAND_CONFIG,
+  DESC_COMMAND_AGENT_VERSION,
+  DESC_COMMAND_AGENT_UPDATE,
+  DESC_COMMAND_AGENT_TUNNEL,
+  DESC_COMMAND_AGENT_STOP,
+  DESC_COMMAND_AGENT_STATUS,
+  DESC_COMMAND_AGENT_START,
+  DESC_COMMAND_AGENT_RESTART,
+  DESC_COMMAND_AGENT_ENABLE,
+  DESC_COMMAND_AGENT_DISABLE,
+  DESC_COMMAND_AGENT_TUNNEL_TLS,
+  DESC_COMMAND_AGENT_TUNNEL_TCP,
+  DESC_COMMAND_AGENT_TUNNEL_STOP,
+  DESC_COMMAND_AGENT_TUNNEL_STATUS,
+  DESC_COMMAND_AGENT_TUNNEL_START,
+  DESC_COMMAND_AGENT_TUNNEL_LIST,
+  DESC_COMMAND_AGENT_TUNNEL_HTTP,
+  DESC_COMMAND_CONFIG_SET,
+  DESC_COMMAND_CONFIG_REMOVE,
+  DESC_COMMAND_CONFIG_GET,
+  DESC_COMMAND_CONFIG_ADD,
+  DESC_COMMAND_CONFIG_SET_WHITELIST,
+  DESC_COMMAND_CONFIG_SET_TOKEN,
+  DESC_COMMAND_CONFIG_SET_TIMEOUT,
+  DESC_COMMAND_CONFIG_SET_REGION,
+  DESC_COMMAND_CONFIG_REMOVE_TUNNEL,
+  DESC_COMMAND_CONFIG_GET_WHITELIST,
+  DESC_COMMAND_CONFIG_GET_TUNNELS,
+  DESC_COMMAND_CONFIG_GET_TUNNEL,
+  DESC_COMMAND_CONFIG_GET_TOKEN,
+  DESC_COMMAND_CONFIG_GET_TIMEOUT,
+  DESC_COMMAND_CONFIG_GET_REGION,
+  DESC_COMMAND_CONFIG_ADD_TLS,
+  DESC_COMMAND_CONFIG_ADD_TCP,
+  DESC_COMMAND_CONFIG_ADD_HTTP,
+  ERR_CONFIG_CORRUPTED,
+  ERR_TOKEN_NOT_PROVIDED,
+  ERR_WRONG_TOKEN,
+  ERR_AGENT_NOT_FOUND,
+  ERR_CANT_CREATE_DIR_IN_HOME,
+  ERR_AGENT_NOT_SUPPORTED,
+  ERR_CONNECTION_ERROR,
+  ERR_CONNECTION_TIMEOUT,
+  ERR_WRONG_STREAM,
+  ERR_WRONG_HANDSHAKE,
+  ERR_SWW,
+  ERR_NOT_FOUND,
+  ERR_FAILED_TO_CONNECT_TO_AGENT,
+  ERR_FAILED_TO_CONNECT,
+  ERR_AGENT_REMOVED,
+  ERR_SUBDOMAIN_TAKEN,
+  ERR_TUNNELS_DISABLED,
+  ERR_TUNNEL_REMOVED,
+  AGENT_FETCH_RETRY,
+  NO_TUNNELS_STARTED,
+  TXT_REGION_SAVED,
+  TXT_TUNNEL_REMOVED,
+  TXT_TUNNEL_ADDED,
+  TXT_TIMEOUT_SAVED,
+  TXT_TOKEN_SAVED,
+  TXT_WHITELIST_SAVED,
+  TXT_TUNNEL_STOPPED,
+  TXT_TUNNEL_STARTED,
+  TXT_AGENT_ENABLED,
+  TXT_AGENT_UPDATED,
+  TXT_AGENT_ALREADY_ENABLED,
+  TXT_AGENT_DISABLED,
+  TXT_AGENT_ALREADY_DISABLED,
+  TXT_AGENT_STARTED,
+  TXT_AGENT_RESTARTED,
+  TXT_AGENT_IS_DISABLED,
+  TXT_AGENT_IS_ENABLED_AND_INITIALIZING,
+  TXT_AGENT_IS_ENABLED_AND_HAVE_TROUBLES,
+  TXT_AGENT_IS_ENABLED_AND_STARTED,
+  TXT_AGENT_IS_ENABLED_AND_STOPPED,
+  TXT_AGENT_STOPPED,
+  ERR_TUNNEL_ALREADY_EXISTS,
+  ERR_AGENT_NOT_REGISTERED,
+  ERR_SAVING_AGENT_CONFIG,
+  ERR_WRONG_KEY_CERT,
+  ERR_AGENT_ENABLE,
+  ERR_SWW_AGENT_ENABLING,
+  ERR_SWW_AGENT_DISABLING,
+  ERR_SWW_AGENT_UPDATING,
+  ERR_AGENT_NOT_ENABLED,
+  ERR_AGENT_NOT_RUNNING,
+  ERR_SUBDOMAIN_IS_NOT_VALID,
+  ERR_SUBDOMAIN_IS_TOO_SHORT,
+  ERR_SUBDOMAIN_IS_TOO_LONG,
+  ERR_TUNNEL_NOT_FOUND,
+  ERR_REGION_IS_NOT_VALID,
+  ERR_TARGET_IS_NOT_VALID,
+  ERR_TYPE_IS_NOT_VALID,
+  ERR_TERMINATE_IS_NOT_VALID,
+  ERR_TIMEOUT_IS_NOT_VALID,
+  ERR_DIRECTORY_DOES_NOT_EXISTS,
+  ERR_PATH_IS_NOT_DIRECTORY,
+  ERR_PORT_IS_NOT_VALID,
+  ERR_NAME_WITHOUT_ASTERISK,
+  ERR_BA_PASSWORD_NOT_PROVIDED,
+  ERR_BA_LOGIN_NOT_PROVIDED,
+  ERR_AGENT_DOCKER_NOT_FOUND,
+  ERR_FETCH_VERSION,
+  ERR_TUNNEL_LIMIT_REACHED,
+  ERR_AGENT_LIMIT_REACHED,
+  TXT_DISABLING_AGENT,
+  TXT_ENABLING_AGENT,
+  TXT_UPDATING_AGENT,
+  TXT_NEW_CLI_DOCKER_VERSION,
+  TXT_NEW_CLI_VERSION,
+  TXT_NEW_AGENT_VERSION,
+  TXT_NEW_CLI_AGENT_VERSION,
+  ERR_WHITELIST_IS_NOT_VALID,
+  ERR_USER_AGENT_IS_NOT_VALID,
+  ERR_AGENT_ADMIN_RIGHTS,
+  ERR_BA_IS_NOT_VALID,
+  ERR_KEY_PATH_IS_NOT_VALID,
+  ERR_CA_PATH_IS_NOT_VALID,
+  ERR_WRONG_CA,
+  ERR_CB_THRESHOLD_IS_NOT_VALID,
+  ERR_DOMAIN_IS_NOT_VALID,
+  ERR_CERT_PATH_IS_NOT_VALID,
+  TXT_OPENING_TUNNEL,
+  LOG_SOCKET_CONNECTED,
+  LOG_SOCKET_DISCONNECTED,
+  LOG_SAVING_AGENT_CONFIG,
+  LOG_SAVING_AGENT_SYSTEM_CONFIG,
+  LOG_SAVING_AGENT_LOCAL_CONFIG,
+  LOG_ERROR_SAVING_AGENT_CONFIG,
+  LOG_ERROR_SAVING_AGENT_SYSTEM_CONFIG,
+  LOG_ERROR_SAVING_AGENT_LOCAL_CONFIG,
+  LOG_AGENT_SYSTEM_DIR,
+  LOG_AGENT_DOWNLOADING_ARCHIVE,
+  LOG_AGENT_EXTRACTING_ARCHIVE,
+  LOG_AGENT_SYSTEM_SERVICE_CONFIG,
+  LOG_AGENT_ENABLING_SYSTEM,
+  LOG_AGENT_STOPPING_SYSTEM,
+  LOG_AGENT_STARTING_SYSTEM,
+  LOG_AGENT_ENABLED,
+  LOG_AGENT_NSSM_DOWNLOADING,
+  LOG_AGENT_NSSM_EXTRACTING,
+  LOG_AGENT_NSSM_CLEARING
+};