bdy 1.7.46-dev

package/src/command/config/add/http.js

@@ -0,0 +1,33 @@
+const {
+  TUNNEL_HTTP
+} = require('../../../utils.js');
+const Input = require('../../../input.js');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_CONFIG_ADD_HTTP,
+  ERR_TUNNEL_ALREADY_EXISTS,
+  OPTION_FORCE,
+  OPTION_NAME,
+  OPTION_TARGET,
+  TXT_TUNNEL_ADDED
+} = require('../../../texts.js');
+const ApiBuddy = require('../../../api/buddy');
+const { getBasicCommandHttp } = require('../../../utils');
+
+const commandConfigAddHttp = getBasicCommandHttp();
+commandConfigAddHttp.description(DESC_COMMAND_CONFIG_ADD_HTTP);
+commandConfigAddHttp.option('-f, --force', OPTION_FORCE);
+commandConfigAddHttp.argument('<name>', OPTION_NAME);
+commandConfigAddHttp.argument('[protocol://host:port]', OPTION_TARGET);
+commandConfigAddHttp.action(async (n, target, options) => {
+  const name = Input.name(n);
+  if (Cfg.hasTunnel(name) && !options.force) {
+    Output.exitError(ERR_TUNNEL_ALREADY_EXISTS);
+  }
+  const myIp = await ApiBuddy.fetchMyIp();
+  await Cfg.addTunnel(name, TUNNEL_HTTP, target, options, myIp);
+  Output.exitSuccess(TXT_TUNNEL_ADDED);
+});
+
+module.exports = commandConfigAddHttp;

package/src/command/config/add/tcp.js

@@ -0,0 +1,33 @@
+const {
+  TUNNEL_TCP
+} = require('../../../utils.js');
+const Input = require('../../../input.js');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_CONFIG_ADD_TCP,
+  ERR_TUNNEL_ALREADY_EXISTS,
+  OPTION_FORCE,
+  OPTION_NAME,
+  OPTION_TARGET,
+  TXT_TUNNEL_ADDED
+} = require('../../../texts.js');
+const ApiBuddy = require('../../../api/buddy');
+const { getBasicCommandTcp } = require('../../../utils');
+
+const commandConfigAddTcp = getBasicCommandTcp();
+commandConfigAddTcp.description(DESC_COMMAND_CONFIG_ADD_TCP);
+commandConfigAddTcp.option('-f, --force', OPTION_FORCE);
+commandConfigAddTcp.argument('<name>', OPTION_NAME);
+commandConfigAddTcp.argument('[host:port]', OPTION_TARGET);
+commandConfigAddTcp.action(async (n, target, options) => {
+  const name = Input.name(n);
+  if (Cfg.hasTunnel(name) && !options.force) {
+    Output.exitError(ERR_TUNNEL_ALREADY_EXISTS);
+  }
+  const myIp = await ApiBuddy.fetchMyIp();
+  await Cfg.addTunnel(name, TUNNEL_TCP, target, options, myIp);
+  Output.exitSuccess(TXT_TUNNEL_ADDED);
+});
+
+module.exports = commandConfigAddTcp;

package/src/command/config/add/tls.js

@@ -0,0 +1,33 @@
+const {
+  TUNNEL_TLS
+} = require('../../../utils.js');
+const Input = require('../../../input.js');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_CONFIG_ADD_TLS,
+  ERR_TUNNEL_ALREADY_EXISTS,
+  OPTION_FORCE,
+  OPTION_NAME,
+  OPTION_TARGET,
+  TXT_TUNNEL_ADDED
+} = require('../../../texts.js');
+const ApiBuddy = require('../../../api/buddy');
+const { getBasicCommandTls } = require('../../../utils');
+
+const commandConfigAddTls = getBasicCommandTls();
+commandConfigAddTls.description(DESC_COMMAND_CONFIG_ADD_TLS);
+commandConfigAddTls.option('-f, --force', OPTION_FORCE);
+commandConfigAddTls.argument('<name>', OPTION_NAME);
+commandConfigAddTls.argument('[host:port]', OPTION_TARGET);
+commandConfigAddTls.action(async (n, target, options) => {
+  const name = Input.name(n);
+  if (Cfg.hasTunnel(name) && !options.force) {
+    Output.exitError(ERR_TUNNEL_ALREADY_EXISTS);
+  }
+  const myIp = await ApiBuddy.fetchMyIp();
+  await Cfg.addTunnel(name, TUNNEL_TLS, target, options, myIp);
+  Output.exitSuccess(TXT_TUNNEL_ADDED);
+});
+
+module.exports = commandConfigAddTls;

package/src/command/config/add.js

@@ -0,0 +1,13 @@
+const { Command } = require('commander');
+const commandConfigAddTcp = require('./add/tcp.js');
+const commandConfigAddHttp = require('./add/http.js');
+const commandConfigAddTls = require('./add/tls.js');
+const { DESC_COMMAND_CONFIG_ADD } = require('../../texts.js');
+
+const commandConfigAdd = new Command('add');
+commandConfigAdd.description(DESC_COMMAND_CONFIG_ADD);
+commandConfigAdd.addCommand(commandConfigAddTcp);
+commandConfigAdd.addCommand(commandConfigAddTls);
+commandConfigAdd.addCommand(commandConfigAddHttp);
+
+module.exports = commandConfigAdd;

package/src/command/config/get/region.js

@@ -0,0 +1,13 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const { DESC_COMMAND_CONFIG_GET_REGION } = require('../../../texts.js');
+const Format = require('../../../format');
+
+const commandConfigGetRegion = new Command('region');
+commandConfigGetRegion.description(DESC_COMMAND_CONFIG_GET_REGION);
+commandConfigGetRegion.action(() => {
+  Output.exitNormal(Format.region(Cfg.getRegion()));
+});
+
+module.exports = commandConfigGetRegion;

package/src/command/config/get/timeout.js

@@ -0,0 +1,13 @@
+const { Command } = require('commander');
+const Output = require('../../../output.js');
+const Cfg = require('../../../cfg.js');
+const { DESC_COMMAND_CONFIG_GET_TIMEOUT } = require('../../../texts.js');
+const Format = require('../../../format');
+
+const commandConfigGetTimeout = new Command('timeout');
+commandConfigGetTimeout.description(DESC_COMMAND_CONFIG_GET_TIMEOUT);
+commandConfigGetTimeout.action(() => {
+  Output.exitNormal(Format.timeout(Cfg.getTimeout()));
+});
+
+module.exports = commandConfigGetTimeout;

package/src/command/config/get/token.js

@@ -0,0 +1,13 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const { DESC_COMMAND_CONFIG_GET_TOKEN } = require('../../../texts.js');
+const Format = require('../../../format');
+
+const commandConfigGetToken = new Command('token');
+commandConfigGetToken.description(DESC_COMMAND_CONFIG_GET_TOKEN);
+commandConfigGetToken.action(() => {
+  Output.exitNormal(Format.token(Cfg.getToken()));
+});
+
+module.exports = commandConfigGetToken;

package/src/command/config/get/tunnel.js

@@ -0,0 +1,21 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_CONFIG_GET_TUNNEL,
+  ERR_TUNNEL_NOT_FOUND,
+  OPTION_NAME
+} = require('../../../texts.js');
+
+const commandConfigGetTunnel = new Command('tunnel');
+commandConfigGetTunnel.description(DESC_COMMAND_CONFIG_GET_TUNNEL);
+commandConfigGetTunnel.argument('<name>', OPTION_NAME);
+commandConfigGetTunnel.action((name) => {
+  if (!Cfg.hasTunnel(name)) {
+    Output.exitError(ERR_TUNNEL_NOT_FOUND(name));
+  }
+  Output.configTunnel(Cfg.getTunnel(name));
+  Output.exitNormal();
+});
+
+module.exports = commandConfigGetTunnel;

package/src/command/config/get/tunnels.js

@@ -0,0 +1,13 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const { DESC_COMMAND_CONFIG_GET_TUNNELS } = require('../../../texts.js');
+
+const commandConfigGetTunnels = new Command('tunnels');
+commandConfigGetTunnels.description(DESC_COMMAND_CONFIG_GET_TUNNELS);
+commandConfigGetTunnels.action(() => {
+  Output.configTunnels(Cfg.getTunnels());
+  Output.exitNormal();
+});
+
+module.exports = commandConfigGetTunnels;

package/src/command/config/get/whitelist.js

@@ -0,0 +1,13 @@
+const { Command } = require('commander');
+const Output = require('../../../output.js');
+const Cfg = require('../../../cfg.js');
+const { DESC_COMMAND_CONFIG_GET_WHITELIST } = require('../../../texts.js');
+const Format = require('../../../format');
+
+const commandConfigGetWhitelist = new Command('whitelist');
+commandConfigGetWhitelist.description(DESC_COMMAND_CONFIG_GET_WHITELIST);
+commandConfigGetWhitelist.action(() => {
+  Output.exitNormal(Format.whitelist(Cfg.getWhitelist()));
+});
+
+module.exports = commandConfigGetWhitelist;

package/src/command/config/get.js

@@ -0,0 +1,19 @@
+const { Command } = require('commander');
+const commandConfigGetRegion = require('./get/region.js');
+const commandConfigGetToken = require('./get/token.js');
+const commandConfigGetTunnel = require('./get/tunnel.js');
+const commandConfigGetWhitelist = require('./get/whitelist.js');
+const commandConfigGetTimeout = require('./get/timeout.js');
+const commandConfigGetTunnels = require('./get/tunnels.js');
+const { DESC_COMMAND_CONFIG_GET } = require('../../texts.js');
+
+const commandConfigGet = new Command('get');
+commandConfigGet.description(DESC_COMMAND_CONFIG_GET);
+commandConfigGet.addCommand(commandConfigGetRegion);
+commandConfigGet.addCommand(commandConfigGetToken);
+commandConfigGet.addCommand(commandConfigGetWhitelist);
+commandConfigGet.addCommand(commandConfigGetTimeout);
+commandConfigGet.addCommand(commandConfigGetTunnels);
+commandConfigGet.addCommand(commandConfigGetTunnel);
+
+module.exports = commandConfigGet;

package/src/command/config/remove/tunnel.js

@@ -0,0 +1,22 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_CONFIG_REMOVE_TUNNEL,
+  ERR_TUNNEL_NOT_FOUND,
+  OPTION_NAME,
+  TXT_TUNNEL_REMOVED
+} = require('../../../texts.js');
+
+const commandConfigRemoveTunnel = new Command('tunnel');
+commandConfigRemoveTunnel.description(DESC_COMMAND_CONFIG_REMOVE_TUNNEL);
+commandConfigRemoveTunnel.argument('<name>', OPTION_NAME);
+commandConfigRemoveTunnel.action((name) => {
+  if (!Cfg.hasTunnel(name)) {
+    Output.exitError(ERR_TUNNEL_NOT_FOUND(name));
+  }
+  Cfg.removeTunnel(name);
+  Output.exitSuccess(TXT_TUNNEL_REMOVED);
+});
+
+module.exports = commandConfigRemoveTunnel;

package/src/command/config/remove.js

@@ -0,0 +1,9 @@
+const { Command } = require('commander');
+const commandConfigRemoveTunnel = require('./remove/tunnel.js');
+const { DESC_COMMAND_CONFIG_REMOVE } = require('../../texts.js');
+
+const commandConfigRemove = new Command('rm');
+commandConfigRemove.description(DESC_COMMAND_CONFIG_REMOVE);
+commandConfigRemove.addCommand(commandConfigRemoveTunnel);
+
+module.exports = commandConfigRemove;

package/src/command/config/set/region.js

@@ -0,0 +1,19 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const Input = require('../../../input.js');
+const {
+  DESC_COMMAND_CONFIG_SET_REGION,
+  OPTION_DEFAULT_REGION,
+  TXT_REGION_SAVED
+} = require('../../../texts.js');
+
+const commandConfigSetRegion = new Command('region');
+commandConfigSetRegion.description(DESC_COMMAND_CONFIG_SET_REGION);
+commandConfigSetRegion.argument('<region>', OPTION_DEFAULT_REGION);
+commandConfigSetRegion.action((region) => {
+  Cfg.setRegion(Input.region(region));
+  Output.exitSuccess(TXT_REGION_SAVED);
+});
+
+module.exports = commandConfigSetRegion;

package/src/command/config/set/timeout.js

@@ -0,0 +1,22 @@
+const { Command } = require('commander');
+const Output = require('../../../output.js');
+const Cfg = require('../../../cfg.js');
+const Input = require('../../../input.js');
+const {
+  DEFAULT_TIMEOUT,
+} = require('../../../utils.js');
+const {
+  DESC_COMMAND_CONFIG_SET_TIMEOUT,
+  OPTION_TIMEOUT,
+  TXT_TIMEOUT_SAVED
+} = require('../../../texts.js');
+
+const commandConfigSetTimeout = new Command('timeout');
+commandConfigSetTimeout.description(DESC_COMMAND_CONFIG_SET_TIMEOUT);
+commandConfigSetTimeout.argument('[timeout]', OPTION_TIMEOUT, DEFAULT_TIMEOUT);
+commandConfigSetTimeout.action((timeout) => {
+  Cfg.setTimeout(Input.timeout(timeout));
+  Output.exitSuccess(TXT_TIMEOUT_SAVED);
+});
+
+module.exports = commandConfigSetTimeout;

package/src/command/config/set/token.js

@@ -0,0 +1,18 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_CONFIG_SET_TOKEN,
+  OPTION_TOKEN,
+  TXT_TOKEN_SAVED
+} = require('../../../texts.js');
+
+const commandConfigSetToken = new Command('token');
+commandConfigSetToken.description(DESC_COMMAND_CONFIG_SET_TOKEN);
+commandConfigSetToken.argument('[token]', OPTION_TOKEN, '');
+commandConfigSetToken.action((token) => {
+  Cfg.setToken(token);
+  Output.exitSuccess(TXT_TOKEN_SAVED);
+});
+
+module.exports = commandConfigSetToken;

package/src/command/config/set/whitelist.js

@@ -0,0 +1,19 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const Input = require('../../../input.js');
+const {
+  DESC_COMMAND_CONFIG_SET_WHITELIST,
+  OPTION_WHITELIST,
+  TXT_WHITELIST_SAVED
+} = require('../../../texts.js');
+
+const commandConfigSetWhitelist = new Command('whitelist');
+commandConfigSetWhitelist.description(DESC_COMMAND_CONFIG_SET_WHITELIST);
+commandConfigSetWhitelist.argument('[cidrs...]', OPTION_WHITELIST, []);
+commandConfigSetWhitelist.action((whitelist) => {
+  Cfg.setWhitelist(Input.whitelist(whitelist));
+  Output.exitSuccess(TXT_WHITELIST_SAVED);
+});
+
+module.exports = commandConfigSetWhitelist;

package/src/command/config/set.js

@@ -0,0 +1,15 @@
+const { Command } = require('commander');
+const commandConfigSetToken = require('./set/token.js');
+const commandConfigSetRegion = require('./set/region.js');
+const commandConfigSetWhitelist = require('./set/whitelist.js');
+const commandConfigSetTimeout = require('./set/timeout.js');
+const { DESC_COMMAND_CONFIG_SET } = require('../../texts.js');
+
+const commandConfigSet = new Command('set');
+commandConfigSet.description(DESC_COMMAND_CONFIG_SET);
+commandConfigSet.addCommand(commandConfigSetToken);
+commandConfigSet.addCommand(commandConfigSetRegion);
+commandConfigSet.addCommand(commandConfigSetWhitelist);
+commandConfigSet.addCommand(commandConfigSetTimeout);
+
+module.exports = commandConfigSet;

package/src/command/config.js

@@ -0,0 +1,15 @@
+const { Command } = require('commander');
+const commandConfigSet = require('./config/set.js');
+const commandConfigGet = require('./config/get.js');
+const commandConfigAdd = require('./config/add.js');
+const commandConfigRemove = require('./config/remove.js');
+const { DESC_COMMAND_CONFIG } = require('../texts.js');
+
+const commandConfig = new Command('config');
+commandConfig.description(DESC_COMMAND_CONFIG);
+commandConfig.addCommand(commandConfigSet);
+commandConfig.addCommand(commandConfigAdd);
+commandConfig.addCommand(commandConfigGet);
+commandConfig.addCommand(commandConfigRemove);
+
+module.exports = commandConfig;

package/src/command/http.js

@@ -0,0 +1,34 @@
+const { TUNNEL_HTTP } = require('../utils.js');
+const Cfg = require('../cfg.js');
+const Output = require('../output.js');
+const {
+  DESC_COMMAND_HTTP,
+  OPTION_SERVE,
+  OPTION_TARGET,
+  OPTION_TOKEN,
+  TXT_OPENING_TUNNEL
+} = require('../texts.js');
+const ApiBuddy = require('../api/buddy.js');
+const { getBasicCommandHttp } = require('../utils');
+
+const commandHttp = getBasicCommandHttp();
+commandHttp.description(DESC_COMMAND_HTTP);
+commandHttp.option('-s, --serve <directory>', OPTION_SERVE);
+commandHttp.option('--token <token>', OPTION_TOKEN);
+commandHttp.argument('[protocol://host:port]', OPTION_TARGET);
+commandHttp.action(async (target, options) => {
+  if (options.token) Cfg.setToken(options.token);
+  const myIp = await ApiBuddy.fetchMyIp();
+  const prepared = await Cfg.prepareTunnel(TUNNEL_HTTP, target, options, true, myIp);
+  await Output.spinner(TXT_OPENING_TUNNEL);
+  const agent = await ApiBuddy.register(false, Cfg.getTokenHost(), Cfg.getToken(), (region) => {
+    Cfg.setRegionIfNotSet(region);
+  });
+  await agent.start();
+  agent.startRefreshingConfiguration();
+  const tunnel = await ApiBuddy.addTunnel(agent.id, agent.host, agent.token, prepared);
+  agent.addTunnel(tunnel);
+  Output.tunnel(tunnel);
+});
+
+module.exports = commandHttp;

package/src/command/pre.js

@@ -0,0 +1,47 @@
+const {
+  getLatestVersion,
+  getVersion
+} = require('../utils.js');
+const Output = require('../output.js');
+const AgentManager = require('../agent/manager.js');
+const ApiAgent = require('../api/agent.js');
+const { isDocker } = require('../utils');
+
+const commandPre = async (_, command) => {
+  command.agentStatus = null;
+  try {
+    if (!isDocker()) {
+      const isEnabled = await AgentManager.system.isEnabled();
+      if (isEnabled) {
+        const json = AgentManager.system.loadSystemConfig();
+        const api = new ApiAgent(json.port);
+        command.agentStatus = await api.fetchStatus();
+      }
+    }
+  } catch {
+    // do nothing
+  }
+  command.currentVersion = getVersion();
+  try {
+    command.latestVersion = await getLatestVersion();
+  } catch {
+    // do nothing
+    return;
+  }
+  if (command.hideVersionUpdate) {
+    return;
+  }
+  const newCli = command.currentVersion !== command.latestVersion;
+  const newAgent = command.agentStatus && command.agentStatus.version !== command.latestVersion;
+  if (isDocker() && newCli) {
+    Output.newCliDockerVersion(command.latestVersion);
+  } else if (newCli && newAgent) {
+    Output.newCliAgentVersion(command.latestVersion);
+  } else if (newCli) {
+    Output.newCliVersion(command.latestVersion);
+  } else if (newAgent) {
+    Output.newAgentVersion(command.latestVersion);
+  }
+};
+
+module.exports = commandPre;

package/src/command/start.js

@@ -0,0 +1,31 @@
+const { Command } = require('commander');
+const Cfg = require('../cfg.js');
+const Output = require('../output.js');
+const {
+  DESC_COMMAND_START,
+  ERR_TUNNEL_NOT_FOUND,
+  OPTION_NAME,
+  TXT_OPENING_TUNNEL
+} = require('../texts.js');
+const ApiBuddy = require('../api/buddy.js');
+
+const commandStart = new Command('start');
+commandStart.description(DESC_COMMAND_START);
+commandStart.argument('<name>', OPTION_NAME);
+commandStart.action(async (name) => {
+  if (!Cfg.hasTunnel(name)) {
+    Output.exitError(ERR_TUNNEL_NOT_FOUND(name));
+  }
+  const prepared = Cfg.getTunnel(name);
+  await Output.spinner(TXT_OPENING_TUNNEL);
+  const agent = await ApiBuddy.register(false, Cfg.getTokenHost(), Cfg.getToken(), (region) => {
+    Cfg.setRegionIfNotSet(region);
+  });
+  await agent.start();
+  agent.startRefreshingConfiguration();
+  const tunnel = await ApiBuddy.addTunnel(agent.id, agent.host, agent.token, prepared);
+  agent.addTunnel(tunnel);
+  Output.tunnel(tunnel);
+});
+
+module.exports = commandStart;

package/src/command/tcp.js

@@ -0,0 +1,32 @@
+const { TUNNEL_TCP } = require('../utils.js');
+const Cfg = require('../cfg.js');
+const Output = require('../output.js');
+const {
+  DESC_COMMAND_TCP,
+  OPTION_TARGET,
+  OPTION_TOKEN,
+  TXT_OPENING_TUNNEL
+} = require('../texts.js');
+const ApiBuddy = require('../api/buddy.js');
+const { getBasicCommandTcp } = require('../utils');
+
+const commandTcp = getBasicCommandTcp();
+commandTcp.description(DESC_COMMAND_TCP);
+commandTcp.option('--token <token>', OPTION_TOKEN);
+commandTcp.argument('[host:port]', OPTION_TARGET);
+commandTcp.action(async (target, options) => {
+  if (options.token) Cfg.setToken(options.token);
+  const myIp = await ApiBuddy.fetchMyIp();
+  const prepared = await Cfg.prepareTunnel(TUNNEL_TCP, target, options, true, myIp);
+  await Output.spinner(TXT_OPENING_TUNNEL);
+  const agent = await ApiBuddy.register(false, Cfg.getTokenHost(), Cfg.getToken(), (region) => {
+    Cfg.setRegionIfNotSet(region);
+  });
+  await agent.start();
+  agent.startRefreshingConfiguration();
+  const tunnel = await ApiBuddy.addTunnel(agent.id, agent.host, agent.token, prepared);
+  agent.addTunnel(tunnel);
+  Output.tunnel(tunnel);
+});
+
+module.exports = commandTcp;

package/src/command/tls.js

@@ -0,0 +1,32 @@
+const { TUNNEL_TLS } = require('../utils.js');
+const Cfg = require('../cfg.js');
+const Output = require('../output.js');
+const {
+  DESC_COMMAND_TLS,
+  OPTION_TARGET,
+  OPTION_TOKEN,
+  TXT_OPENING_TUNNEL
+} = require('../texts.js');
+const ApiBuddy = require('../api/buddy.js');
+const { getBasicCommandTls } = require('../utils');
+
+const commandTls = getBasicCommandTls();
+commandTls.description(DESC_COMMAND_TLS);
+commandTls.option('--token <token>', OPTION_TOKEN);
+commandTls.argument('[host:port]', OPTION_TARGET);
+commandTls.action(async (target, options) => {
+  if (options.token) Cfg.setToken(options.token);
+  const myIp = await ApiBuddy.fetchMyIp();
+  const prepared = await Cfg.prepareTunnel(TUNNEL_TLS, target, options, true, myIp);
+  await Output.spinner(TXT_OPENING_TUNNEL);
+  const agent = await ApiBuddy.register(false, Cfg.getTokenHost(), Cfg.getToken(), (region) => {
+    Cfg.setRegionIfNotSet(region);
+  });
+  await agent.start();
+  agent.startRefreshingConfiguration();
+  const tunnel = await ApiBuddy.addTunnel(agent.id, agent.host, agent.token, prepared);
+  agent.addTunnel(tunnel);
+  Output.tunnel(tunnel);
+});
+
+module.exports = commandTls;

package/src/command/version.js

@@ -0,0 +1,10 @@
+const { Command } = require('commander');
+const { getVersion } = require('../utils.js');
+const Output = require('../output.js');
+
+const commandVersion = new Command('version');
+commandVersion.action(() => {
+  Output.exitNormal(getVersion());
+});
+
+module.exports = commandVersion;