bdy 1.7.46-dev

package/src/utils.js

@@ -0,0 +1,496 @@
+const { resolve } = require('path');
+const path = require('path');
+const { readFileSync, mkdirSync, existsSync } = require('fs');
+const { homedir } = require('os');
+const os = require('os');
+const { ERR_FETCH_VERSION } = require('./texts.js');
+const { Command } = require('commander');
+const { getAsset, isSea } = require('node:sea');
+const Ssh2 = require('ssh2');
+const {
+  OPTION_REGION,
+  OPTION_WHITELIST,
+  OPTION_SUBDOMAIN,
+  OPTION_DOMAIN,
+  OPTION_TIMEOUT,
+  OPTION_HTTP_HOST,
+  OPTION_HEADER,
+  OPTION_RESPONSE_HEADER,
+  OPTION_HEADER_USER_AGENT,
+  OPTION_HTTP_AUTH,
+  OPTION_HTTP_LOG,
+  OPTION_HTTP_VERIFY,
+  OPTION_HTTP_2,
+  OPTION_HTTP_COMPRESSION,
+  OPTION_TLS_CA,
+  OPTION_HTTP_CIRCUIT_BREAKER,
+  OPTION_TLS_KEY,
+  OPTION_TLS_CERT,
+  OPTION_TLS_TERMINATE,
+  ERR_FAILED_TO_CONNECT,
+  ERR_WRONG_TOKEN,
+  ERR_AGENT_REMOVED,
+  ERR_SUBDOMAIN_TAKEN,
+  ERR_TUNNELS_DISABLED,
+  ERR_AGENT_LIMIT_REACHED,
+  ERR_TUNNEL_LIMIT_REACHED
+} = require('./texts');
+
+const REGION_US = 'US';
+const REGION_EU = 'EU';
+
+const TLS_TERMINATE_AT_TARGET = 'TARGET';
+const TLS_TERMINATE_AT_AGENT = 'AGENT';
+const TLS_TERMINATE_AT_REGION = 'REGION';
+
+const TUNNEL_HTTP = 'HTTP';
+const TUNNEL_TCP = 'TCP';
+const TUNNEL_TLS = 'TLS';
+const TUNNEL_SSH = 'SSH';
+
+const EVENT_TUNNEL_IDENTIFIED = 'tunnel identified';
+const TUNNEL_IDENTIFIED_HTTP1 = '1.1';
+const TUNNEL_IDENTIFIED_HTTP2 = '2.0';
+
+const HTTP1_SOCKET_OPEN = 'http socket open';
+const HTTP1_SOCKET_CLOSED = 'http socket closed';
+const HTTP1_REQUEST = 'http request';
+
+const HTTP2_SESSION_OPEN = 'http session open';
+const HTTP2_SESSION_CLOSED = 'http session closed';
+const HTTP2_REQUEST = 'http request';
+
+const TLS_SOCKET = 'tls socket';
+
+const SSH_CLIENT_EVENT_CONNECTED = 'connected';
+const SSH_CLIENT_EVENT_DISCONNECTED = 'disconnected';
+const SSH_CLIENT_EVENT_STREAM_SSH = 'stream ssh';
+const SSH_CLIENT_EVENT_STREAM_TCP = 'stream tcp';
+const SSH_CLIENT_EVENT_STREAM_TLS = 'stream tls';
+const SSH_CLIENT_EVENT_STREAM_HTTP1 = 'stream http1';
+const SSH_CLIENT_EVENT_STREAM_HTTP2 = 'stream http2';
+
+const SOCKET_TYPE_TCP = 0;
+const SOCKET_TYPE_TLS = 1;
+const SOCKET_TYPE_HTTP1 = 2;
+const SOCKET_TYPE_HTTP2 = 3;
+const SOCKET_TYPE_SSH = 4;
+
+const TUNNEL_HTTP_RATE_LIMIT = 2000;
+const TUNNEL_HTTP_RATE_WINDOW = 60000;
+const TUNNEL_HTTP_LOG_MAX_BODY = 5242880; // 5MB
+const TUNNEL_HTTP_LOG_MAX_REQUESTS = 20;
+const TUNNEL_MAX_REQUEST_SIZE_TO_SYNC = 25600; // 25kB (1 request do frontu moze miec max 1MB, 20 requestow po req i res body)
+const TUNNEL_HTTP_CB_WINDOW = 10000;
+const TUNNEL_HTTP_CB_MIN_REQUESTS = 20;
+const EVENT_TUNNEL_HTTP_NEW_REQUEST = 'new request';
+const EVENT_TUNNEL_HTTP_NEW_REQUEST_END = 'new request end';
+const EVENT_TUNNEL_HTTP_NEW_RESPONSE = 'new response';
+const EVENT_TUNNEL_HTTP_NEW_RESPONSE_END = 'new response end';
+
+const TUNNEL_EVENT_OPEN = 'open';
+const TUNNEL_EVENT_CLOSED = 'closed';
+const TUNNEL_EVENT_TCP_OPEN = 'tcp open';
+const TUNNEL_EVENT_TCP_CLOSED = 'tcp closed';
+const TUNNEL_EVENT_TLS_OPEN = 'tls open';
+const TUNNEL_EVENT_TLS_CLOSED = 'tls closed';
+const TUNNEL_EVENT_HTTP_OPEN = 'http open';
+const TUNNEL_EVENT_HTTP_CLOSED = 'http closed';
+const TUNNEL_EVENT_HTTP_IDENTIFIED = 'http identified';
+const TUNNEL_EVENT_HTTP_REQUEST = 'http request';
+const TUNNEL_EVENT_HTTP_RESPONSE = 'http response';
+const TUNNEL_EVENT_STOPPED = 'stopped';
+
+const TUNNEL_OPEN = 'OPEN';
+const TUNNEL_CLOSED = 'CLOSED';
+
+const DEFAULT_TIMEOUT = 30;
+
+const AGENT_STATUS_DISABLED = 'disabled';
+const AGENT_STATUS_INITIALIZING = 'initializing';
+const AGENT_STATUS_FETCH_FAILED = 'fetch agent failed, retrying';
+const AGENT_STATUS_ENABLED = 'enabled';
+
+const AGENT_ACTION_STOP = 'STOP';
+const AGENT_ACTION_START = 'START';
+const AGENT_ACTION_RESTART = 'RESTART';
+const AGENT_ACTION_DELETE = 'DELETE';
+
+const AGENT_SOCKET_MESSAGE_READY = 'ready';
+const AGENT_SOCKET_MESSAGE_TUNNEL = 'tunnel';
+const AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED = 'tunnel stopped';
+const AGENT_SOCKET_MESSAGE_TUNNEL_OPEN = 'tunnel open';
+const AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED = 'tunnel closed';
+const AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN = 'tunnel tcp open';
+const AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED = 'tunnel tcp closed';
+const AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN = 'tunnel tls open';
+const AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED = 'tunnel tls closed';
+const AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED = 'tunnel http identified';
+const AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS = 'tunnel http requests';
+const AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST = 'tunnel http request';
+const AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE = 'tunnel http response';
+const AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY = 'tunnel http retry';
+
+const SOCKET_IO_EVENT_CONNECTED = 'socket connected';
+const SOCKET_IO_EVENT_DISCONNECTED = 'socket disconnected';
+const SOCKET_IO_EVENT_FETCH_SUCCESS = 'fetch success';
+const SOCKET_IO_EVENT_FETCH_FAILED = 'fetch failed';
+const SOCKET_IO_EVENT_AGENT = 'agent';
+const SOCKET_IO_EVENT_TUNNEL = 'tunnel';
+
+function apiErrorCodeToClass (code, host) {
+  if (code === 234000) {
+    return new ApiErrorAgentNotFound();
+  }
+  if (code === 234020) {
+    return new ApiErrorWrongToken();
+  }
+  if (code === 234003) {
+    return new ApiErrorSubdomainTaken();
+  }
+  if (code === 234500) {
+    return new ApiErrorTunnelsDisabled();
+  }
+  if (code === 234502) {
+    return new ApiErrorAgentLimitReached();
+  }
+  if (code === 234501) {
+    return new ApiErrorTunnelLimitReached();
+  }
+  return new ApiErrorFailedToConnect(host);
+}
+
+class ApiErrorAgentNotFound extends Error {
+  constructor() {
+    super(ERR_AGENT_REMOVED);
+  }
+}
+class ApiErrorFailedToConnect extends Error {
+  constructor(host) {
+    super(ERR_FAILED_TO_CONNECT(host));
+  }
+}
+class ApiErrorWrongToken extends Error {
+  constructor() {
+    super(ERR_WRONG_TOKEN);
+  }
+}
+class ApiErrorSubdomainTaken extends Error {
+  constructor() {
+    super(ERR_SUBDOMAIN_TAKEN);
+  }
+}
+
+class ApiErrorAgentLimitReached extends Error {
+  constructor() {
+    super(ERR_AGENT_LIMIT_REACHED);
+  }
+}
+
+class ApiErrorTunnelLimitReached extends Error {
+  constructor() {
+    super(ERR_TUNNEL_LIMIT_REACHED);
+  }
+}
+
+class ApiErrorTunnelsDisabled extends Error {
+  constructor() {
+    super(ERR_TUNNELS_DISABLED);
+  }
+}
+
+const TARGET_TCP_TLS_REGEX = /^(([^:]+):)?(\d+)$/i;
+const TARGET_HTTP_REGEX = /^((https?):\/\/)?([^:/]+:[^@:]+@)?([^:]+)(:(\d+))?$/i;
+const TARGET_ONLY_PORT_REGEX = /^\d+$/i;
+
+const TUNNEL_COMPRESSION_METHOD_IDENTITY = 'identity';
+const TUNNEL_COMPRESSION_METHOD_BR = 'br';
+const TUNNEL_COMPRESSION_METHOD_GZIP = 'gzip';
+const TUNNEL_COMPRESSION_METHOD_DEFLATE = 'deflate';
+
+const TUNNEL_LATENCY_EVENT_RECONNECTED = 'reconnected';
+
+const TCP_EVENT_CLOSED = 'closed';
+
+let cachedVersion;
+let cachedRoot;
+
+const getRootDir = () => {
+  if (!cachedRoot) {
+    cachedRoot = path.resolve(__dirname, '..');
+  }
+  return cachedRoot;
+};
+
+const isStringRegExp = (str) => /^\/.*\/$/.test(str);
+
+const getHostname = () => {
+  return os.hostname();
+};
+
+const getPlatform = () => {
+  return os.platform();
+};
+
+const getHomeDirectory = () => {
+  if (isDocker()) return '/buddy';
+  const r = homedir();
+  const p = path.join(r, '.bdy');
+  if (!existsSync(p)) mkdirSync(p, { recursive: true });
+  return p;
+};
+
+const getVersion = () => {
+  if (!cachedVersion) {
+    let packageJson;
+    if (isSea()) {
+      packageJson = JSON.parse(getAsset('package.json', 'utf8'));
+    } else {
+      const root = getRootDir();
+      packageJson = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8'));
+    }
+    cachedVersion = packageJson.version;
+  }
+  return cachedVersion;
+};
+
+const getVersionWithoutEnv = () => {
+  const v = getVersion();
+  const m = v.match(/^\d+\.\d+\.\d+/);
+  if (m) return m[0];
+  return '0.0.0';
+};
+
+const getVersionEnv = () => {
+  const v = getVersion();
+  if (/dev/.test(v)) return 'dev';
+  if (/beta/.test(v)) return 'beta';
+  if (/stage/.test(v)) return 'stage';
+  if (/master/.test(v)) return 'master';
+  return 'prod';
+};
+
+const getLatestVersion = async () => {
+  try {
+    const env = getVersionEnv();
+    const c = new AbortController();
+    setTimeout(() => {
+      c.abort();
+    }, 10000);
+    const response = await fetch(`https://es.buddy.works/tunnel/${env}/latest`, {
+      method: 'GET',
+      signal: c.signal,
+    });
+    if (response.status === 200) {
+      const data = await response.text();
+      const v = data.trim();
+      if (env === 'prod') return v;
+      return `${v}-${env}`;
+    } else {
+      return '0.0.0';
+    }
+  } catch {
+    throw new Error(ERR_FETCH_VERSION);
+  }
+};
+
+const sleep = (ms) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+
+const isDocker = () => {
+  return process.env['IS_IN_DOCKER'] === '1';
+};
+
+const isOsx = () => {
+  return os.platform() === 'darwin';
+};
+
+const isLinux = () => {
+  return os.platform() === 'linux';
+};
+
+const isWindows = () => {
+  return os.platform() === 'win32';
+};
+
+const getRealTargetHost = (target) => {
+  return target;
+};
+
+const createSshHostKey = () => {
+  const keys = Ssh2.utils.generateKeyPairSync('ed25519', {});
+  return keys.private;
+};
+
+const getBasicCommandTcp = () => {
+  const commandTcp = new Command('tcp');
+  commandTcp.alias('TCP');
+  commandTcp.option('-r, --region <region>', OPTION_REGION);
+  commandTcp.option('-w, --whitelist <cidrs...>', OPTION_WHITELIST);
+  commandTcp.option('-b, --subdomain <subdomain>', OPTION_SUBDOMAIN);
+  commandTcp.option('-d, --domain <domain>', OPTION_DOMAIN);
+  commandTcp.option('-t, --timeout <seconds>', OPTION_TIMEOUT);
+  return commandTcp;
+};
+
+const getBasicCommandHttp = () => {
+  const commandHttp = new Command('http');
+  commandHttp.alias('HTTP');
+  commandHttp.option('-r, --region <region>', OPTION_REGION);
+  commandHttp.option('-w, --whitelist <cidrs...>', OPTION_WHITELIST);
+  commandHttp.option('-b, --subdomain <subdomain>', OPTION_SUBDOMAIN);
+  commandHttp.option('-d, --domain <domain>', OPTION_DOMAIN);
+  commandHttp.option('-t, --timeout <seconds>', OPTION_TIMEOUT);
+  commandHttp.option('-h, --host <host>', OPTION_HTTP_HOST);
+  commandHttp.option('--header <headers...>', OPTION_HEADER);
+  commandHttp.option('--response-header <headers...>', OPTION_RESPONSE_HEADER);
+  commandHttp.option('--useragent <useragent...>', OPTION_HEADER_USER_AGENT);
+  commandHttp.option('-a, --auth <user:pass>', OPTION_HTTP_AUTH);
+  commandHttp.option('-l, --log', OPTION_HTTP_LOG);
+  commandHttp.option('-v, --verify', OPTION_HTTP_VERIFY);
+  commandHttp.option('-2, --http2', OPTION_HTTP_2);
+  commandHttp.option('-c, --compression', OPTION_HTTP_COMPRESSION);
+  commandHttp.option('--ca <ca>', OPTION_TLS_CA);
+  commandHttp.option('--circuit-breaker <threshold>', OPTION_HTTP_CIRCUIT_BREAKER);
+  return commandHttp;
+};
+
+const getBasicCommandTls = () => {
+  const commandTls = new Command('tls');
+  commandTls.alias('TLS');
+  commandTls.option('-r, --region <region>', OPTION_REGION);
+  commandTls.option('-w, --whitelist <cidrs...>', OPTION_WHITELIST);
+  commandTls.option('-b, --subdomain <subdomain>', OPTION_SUBDOMAIN);
+  commandTls.option('-d, --domain <domain>', OPTION_DOMAIN);
+  commandTls.option('-t, --timeout <seconds>', OPTION_TIMEOUT);
+  commandTls.option('-k, --key <key>', OPTION_TLS_KEY);
+  commandTls.option('-c, --cert <cert>', OPTION_TLS_CERT);
+  commandTls.option('--ca <ca>', OPTION_TLS_CA);
+  commandTls.option('-i, --terminate <at>', OPTION_TLS_TERMINATE);
+  return commandTls;
+};
+
+module.exports = {
+  apiErrorCodeToClass,
+  SOCKET_IO_EVENT_FETCH_SUCCESS,
+  SOCKET_IO_EVENT_FETCH_FAILED,
+  getBasicCommandHttp,
+  getBasicCommandTcp,
+  getBasicCommandTls,
+  ApiErrorAgentNotFound,
+  ApiErrorFailedToConnect,
+  ApiErrorWrongToken,
+  ApiErrorSubdomainTaken,
+  ApiErrorTunnelsDisabled,
+  AGENT_SOCKET_MESSAGE_READY,
+  AGENT_SOCKET_MESSAGE_TUNNEL,
+  AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED,
+  AGENT_SOCKET_MESSAGE_TUNNEL_OPEN,
+  AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED,
+  AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN,
+  AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED,
+  AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN,
+  AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED,
+  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED,
+  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS,
+  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST,
+  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE,
+  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY,
+  EVENT_TUNNEL_IDENTIFIED,
+  TUNNEL_IDENTIFIED_HTTP1,
+  TUNNEL_IDENTIFIED_HTTP2,
+  AGENT_ACTION_STOP,
+  AGENT_ACTION_RESTART,
+  AGENT_ACTION_START,
+  AGENT_ACTION_DELETE,
+  getRootDir,
+  getHostname,
+  getPlatform,
+  getVersion,
+  getVersionEnv,
+  getVersionWithoutEnv,
+  REGION_EU,
+  REGION_US,
+  TUNNEL_HTTP,
+  TUNNEL_TCP,
+  TUNNEL_TLS,
+  TUNNEL_SSH,
+  TUNNEL_OPEN,
+  TUNNEL_CLOSED,
+  DEFAULT_TIMEOUT,
+  TLS_TERMINATE_AT_REGION,
+  TLS_TERMINATE_AT_TARGET,
+  TLS_TERMINATE_AT_AGENT,
+  getLatestVersion,
+  getHomeDirectory,
+  sleep,
+  getRealTargetHost,
+  isStringRegExp,
+  isDocker,
+  isOsx,
+  isLinux,
+  isWindows,
+  createSshHostKey,
+  AGENT_STATUS_INITIALIZING,
+  AGENT_STATUS_FETCH_FAILED,
+  AGENT_STATUS_DISABLED,
+  AGENT_STATUS_ENABLED,
+  TARGET_TCP_TLS_REGEX,
+  TARGET_ONLY_PORT_REGEX,
+  TARGET_HTTP_REGEX,
+  HTTP1_SOCKET_OPEN,
+  HTTP1_SOCKET_CLOSED,
+  HTTP1_REQUEST,
+  HTTP2_SESSION_OPEN,
+  HTTP2_SESSION_CLOSED,
+  HTTP2_REQUEST,
+  TLS_SOCKET,
+  SSH_CLIENT_EVENT_CONNECTED,
+  SSH_CLIENT_EVENT_DISCONNECTED,
+  SSH_CLIENT_EVENT_STREAM_TCP,
+  SSH_CLIENT_EVENT_STREAM_SSH,
+  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,
+  TUNNEL_HTTP_RATE_LIMIT,
+  TUNNEL_HTTP_RATE_WINDOW,
+  TUNNEL_HTTP_LOG_MAX_BODY,
+  TUNNEL_HTTP_LOG_MAX_REQUESTS,
+  TUNNEL_MAX_REQUEST_SIZE_TO_SYNC,
+  TUNNEL_HTTP_CB_WINDOW,
+  TUNNEL_HTTP_CB_MIN_REQUESTS,
+  EVENT_TUNNEL_HTTP_NEW_REQUEST,
+  EVENT_TUNNEL_HTTP_NEW_REQUEST_END,
+  EVENT_TUNNEL_HTTP_NEW_RESPONSE_END,
+  EVENT_TUNNEL_HTTP_NEW_RESPONSE,
+  TUNNEL_COMPRESSION_METHOD_IDENTITY,
+  TUNNEL_COMPRESSION_METHOD_BR,
+  TUNNEL_COMPRESSION_METHOD_GZIP,
+  TUNNEL_COMPRESSION_METHOD_DEFLATE,
+  TUNNEL_LATENCY_EVENT_RECONNECTED,
+  TCP_EVENT_CLOSED,
+  SOCKET_IO_EVENT_CONNECTED,
+  SOCKET_IO_EVENT_DISCONNECTED,
+  SOCKET_IO_EVENT_AGENT,
+  SOCKET_IO_EVENT_TUNNEL,
+  TUNNEL_EVENT_HTTP_OPEN,
+  TUNNEL_EVENT_HTTP_CLOSED,
+  TUNNEL_EVENT_OPEN,
+  TUNNEL_EVENT_CLOSED,
+  TUNNEL_EVENT_TCP_OPEN,
+  TUNNEL_EVENT_TCP_CLOSED,
+  TUNNEL_EVENT_TLS_OPEN,
+  TUNNEL_EVENT_TLS_CLOSED,
+  TUNNEL_EVENT_HTTP_IDENTIFIED,
+  TUNNEL_EVENT_HTTP_REQUEST,
+  TUNNEL_EVENT_HTTP_RESPONSE,
+  TUNNEL_EVENT_STOPPED
+};

package/unlink.sh

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