bdy 1.7.46-dev

package/src/command/agent/enable.js

@@ -0,0 +1,117 @@
+const { Command } = require('commander');
+const Output = require('../../output.js');
+const Input = require('../../input.js');
+const {
+  DESC_COMMAND_AGENT_ENABLE,
+  ERR_SWW_AGENT_ENABLING,
+  OPTION_AGENT_ID,
+  OPTION_AGENT_PORT,
+  OPTION_AGENT_START,
+  OPTION_AGENT_TOKEN,
+  TXT_AGENT_ALREADY_ENABLED
+} = require('../../texts.js');
+const Cfg = require('../../cfg.js');
+const AgentManager = require('../../agent/manager.js');
+const ApiBuddy = require('../../api/buddy.js');
+const ApiAgent = require('../../api/agent');
+const waitUntilAgentEnabled = require('../../agent/wait.js');
+const {
+  ERR_AGENT_NOT_FOUND,
+  ERR_AGENT_ADMIN_RIGHTS,
+  TXT_ENABLING_AGENT,
+  ERR_AGENT_NOT_SUPPORTED,
+  OPTION_USER,
+  OPTION_PASS,
+  TXT_AGENT_ENABLED,
+  OPTION_AGENT_DEBUG
+} = require('../../texts');
+
+const removeAllAndExit = async (txt, id, host, token) => {
+  try {
+    await AgentManager.system.disable();
+  } catch {
+    // do nothing
+  }
+  try {
+    await ApiBuddy.unregister(id, host, token);
+  } catch {
+    // do nothing
+  }
+  try {
+    AgentManager.system.clearSystemFiles();
+  } catch {
+    // do nothing
+  }
+  Output.exitError(txt);
+};
+
+const commandAgentEnable = new Command('enable');
+commandAgentEnable.description(DESC_COMMAND_AGENT_ENABLE);
+commandAgentEnable.option('-s, --start', OPTION_AGENT_START);
+commandAgentEnable.option('-i, --id <id>', OPTION_AGENT_ID);
+commandAgentEnable.option('-t, --token <token>', OPTION_AGENT_TOKEN);
+commandAgentEnable.option('-p, --port <port>', OPTION_AGENT_PORT, '7456');
+commandAgentEnable.option('-u, --user <user>', OPTION_USER);
+commandAgentEnable.option('--pass <password>', OPTION_PASS);
+commandAgentEnable.option('-d, --debug', OPTION_AGENT_DEBUG);
+commandAgentEnable.action(async (options) => {
+  const hasAdminRights = await AgentManager.system.hasAdminRights();
+  if (!hasAdminRights) {
+    Output.exitError(ERR_AGENT_ADMIN_RIGHTS);
+  }
+  const isSupported = await AgentManager.system.isSupported();
+  if (!isSupported) {
+    Output.exitError(ERR_AGENT_NOT_SUPPORTED);
+  }
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (isEnabled) {
+    Output.exitSuccess(TXT_AGENT_ALREADY_ENABLED);
+  }
+  let id;
+  let token;
+  let agent;
+  let port = Input.port(options.port);
+  if (options.id && options.token) {
+    // if id & token passed set as it is
+    id = options.id;
+    token = options.token;
+    try {
+      agent = await ApiBuddy.fetchAgent(id, Cfg.getTokenHost(), token);
+    } catch {
+      Output.exitError(ERR_AGENT_NOT_FOUND);
+    }
+  } else if (options.token) {
+    // set global token if passed
+    Cfg.setToken(options.token);
+  }
+  let host = Cfg.getTokenHost();
+  if (!agent) {
+    agent = await ApiBuddy.register(true, host, Cfg.getToken(), (region) => {
+      Cfg.setRegionIfNotSet(region);
+    });
+    id = agent.id;
+    token = agent.token;
+  }
+  const saved = AgentManager.system.saveSystemConfig(id, host, token, port);
+  if (!saved) {
+    await removeAllAndExit(ERR_SWW_AGENT_ENABLING, id, host, token);
+  }
+  await Output.spinner(TXT_ENABLING_AGENT);
+  if (process.env.DEBUG === '1') {
+    AgentManager.start(id, host, token, port, !!options.start);
+    return;
+  }
+  try {
+    await AgentManager.system.enable(id, host, token, port, !!options.start, options.user, options.pass, !!options.debug);
+  } catch {
+    await removeAllAndExit(ERR_SWW_AGENT_ENABLING, id, host, token);
+  }
+  const api = new ApiAgent(port);
+  await waitUntilAgentEnabled(api,15000, () => {
+    removeAllAndExit(ERR_SWW_AGENT_ENABLING, id, host, token);
+  }, () => {
+    Output.exitSuccess(TXT_AGENT_ENABLED);
+  });
+});
+
+module.exports = commandAgentEnable;

package/src/command/agent/restart.js

@@ -0,0 +1,28 @@
+const { Command } = require('commander');
+const Output = require('../../output.js');
+const {
+  DESC_COMMAND_AGENT_RESTART,
+  TXT_AGENT_RESTARTED
+} = require('../../texts.js');
+const ApiAgent = require('../../api/agent.js');
+const AgentManager = require('../../agent/manager');
+const { ERR_AGENT_NOT_ENABLED } = require('../../texts');
+
+const commandAgentRestart = new Command('restart');
+commandAgentRestart.description(DESC_COMMAND_AGENT_RESTART);
+commandAgentRestart.action(async () => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  try {
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    await api.restartAgent();
+    Output.exitSuccess(TXT_AGENT_RESTARTED);
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentRestart;

package/src/command/agent/run.js

@@ -0,0 +1,16 @@
+const { Command } = require('commander');
+const AgentManager = require('../../agent/manager');
+const logger = require('../../logger');
+
+const commandAgentRun = new Command('run');
+commandAgentRun.option('--id <id>');
+commandAgentRun.option('--host <host>');
+commandAgentRun.option('--token <token>');
+commandAgentRun.option('--port <port>');
+commandAgentRun.option('--start <start>');
+commandAgentRun.action(async (options) => {
+  logger.changeRootPath(AgentManager.system.getAgentConfigDir());
+  AgentManager.start(options.id, options.host, options.token, options.port, !!options.start);
+});
+
+module.exports = commandAgentRun;

package/src/command/agent/start.js

@@ -0,0 +1,28 @@
+const { Command } = require('commander');
+const Output = require('../../output.js');
+const {
+  DESC_COMMAND_AGENT_START,
+  TXT_AGENT_STARTED
+} = require('../../texts.js');
+const ApiAgent = require('../../api/agent.js');
+const AgentManager = require('../../agent/manager');
+const { ERR_AGENT_NOT_ENABLED } = require('../../texts');
+
+const commandAgentStart = new Command('start');
+commandAgentStart.description(DESC_COMMAND_AGENT_START);
+commandAgentStart.action(async () => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  try {
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    await api.startAgent();
+    Output.exitSuccess(TXT_AGENT_STARTED);
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentStart;

package/src/command/agent/status.js

@@ -0,0 +1,45 @@
+const { Command } = require('commander');
+const Output = require('../../output.js');
+const {
+  DESC_COMMAND_AGENT_STATUS,
+  ERR_AGENT_NOT_ENABLED,
+  TXT_AGENT_IS_DISABLED,
+  TXT_AGENT_IS_ENABLED_AND_HAVE_TROUBLES,
+  TXT_AGENT_IS_ENABLED_AND_INITIALIZING,
+  TXT_AGENT_IS_ENABLED_AND_STARTED,
+  TXT_AGENT_IS_ENABLED_AND_STOPPED
+} = require('../../texts.js');
+const {
+  AGENT_STATUS_ENABLED,
+  AGENT_STATUS_FETCH_FAILED,
+  AGENT_STATUS_INITIALIZING
+} = require('../../utils.js');
+const AgentManager = require('../../agent/manager');
+const { ERR_AGENT_NOT_RUNNING } = require('../../texts');
+
+const commandAgentStatus = new Command('status');
+commandAgentStatus.description(DESC_COMMAND_AGENT_STATUS);
+commandAgentStatus.action(async () => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  if (!commandAgentStatus.agentStatus) {
+    Output.exitError(ERR_AGENT_NOT_RUNNING);
+  }
+  if (commandAgentStatus.agentStatus.status === AGENT_STATUS_INITIALIZING)  {
+    Output.exitError(TXT_AGENT_IS_ENABLED_AND_INITIALIZING);
+  }
+  if (commandAgentStatus.agentStatus.status === AGENT_STATUS_FETCH_FAILED)  {
+    Output.exitError(TXT_AGENT_IS_ENABLED_AND_HAVE_TROUBLES);
+  }
+  if (commandAgentStatus.agentStatus.status !== AGENT_STATUS_ENABLED) {
+    Output.exitError(TXT_AGENT_IS_DISABLED);
+  }
+  if (commandAgentStatus.agentStatus.started) {
+    Output.exitSuccess(TXT_AGENT_IS_ENABLED_AND_STARTED);
+  }
+  Output.exitError(TXT_AGENT_IS_ENABLED_AND_STOPPED);
+});
+
+module.exports = commandAgentStatus;

package/src/command/agent/stop.js

@@ -0,0 +1,28 @@
+const { Command } = require('commander');
+const Output = require('../../output.js');
+const {
+  DESC_COMMAND_AGENT_STOP,
+  TXT_AGENT_STOPPED
+} = require('../../texts.js');
+const ApiAgent = require('../../api/agent.js');
+const AgentManager = require('../../agent/manager');
+const { ERR_AGENT_NOT_ENABLED } = require('../../texts');
+
+const commandAgentStop = new Command('stop');
+commandAgentStop.description(DESC_COMMAND_AGENT_STOP);
+commandAgentStop.action(async () => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  try {
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    await api.stopAgent();
+    Output.exitSuccess(TXT_AGENT_STOPPED);
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentStop;

package/src/command/agent/tunnel/http.js

@@ -0,0 +1,47 @@
+const { TUNNEL_HTTP } = require('../../../utils.js');
+const Output = require('../../../output.js');
+const Cfg = require('../../../cfg.js');
+const {
+  DESC_COMMAND_AGENT_TUNNEL_HTTP,
+  ERR_AGENT_NOT_ENABLED,
+  OPTION_TARGET,
+  TXT_OPENING_TUNNEL,
+  TXT_TUNNEL_STARTED
+} = require('../../../texts.js');
+const ApiAgent = require('../../../api/agent.js');
+const ApiBuddy = require('../../../api/buddy');
+const { getBasicCommandHttp } = require('../../../utils');
+const AgentManager = require('../../../agent/manager');
+const { OPTION_FOLLOW } = require('../../../texts');
+const AgentSocketTunnel = require('../../../agent/socket/tunnel');
+
+const commandAgentTunnelHttp = getBasicCommandHttp();
+commandAgentTunnelHttp.description(DESC_COMMAND_AGENT_TUNNEL_HTTP);
+commandAgentTunnelHttp.option('-f, --follow', OPTION_FOLLOW);
+commandAgentTunnelHttp.argument('[protocol://host:port]', OPTION_TARGET);
+commandAgentTunnelHttp.action(async (target, options) => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  const myIp = await ApiBuddy.fetchMyIp();
+  const prepared = await Cfg.prepareTunnel(TUNNEL_HTTP, target, options, true, myIp);
+  try {
+    await Output.spinner(TXT_OPENING_TUNNEL);
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    const data = await api.addTunnel(prepared);
+    if (options.follow) {
+      const ws = await api.socketTunnel(data.id);
+      const tunnel = new AgentSocketTunnel(ws, data.id);
+      await tunnel.waitForReady();
+      Output.tunnel(tunnel);
+    } else {
+      Output.exitSuccess(TXT_TUNNEL_STARTED(data.type));
+    }
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentTunnelHttp;

package/src/command/agent/tunnel/list.js

@@ -0,0 +1,27 @@
+const { Command } = require('commander');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_AGENT_TUNNEL_LIST,
+  ERR_AGENT_NOT_ENABLED
+} = require('../../../texts.js');
+const ApiAgent = require('../../../api/agent');
+const AgentManager = require('../../../agent/manager');
+
+const commandAgentTunnelList = new Command('list');
+commandAgentTunnelList.description(DESC_COMMAND_AGENT_TUNNEL_LIST);
+commandAgentTunnelList.action(async () => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  try {
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    const data = await api.fetchTunnels();
+    Output.agentTunnels(data.tunnels);
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentTunnelList;

package/src/command/agent/tunnel/start.js

@@ -0,0 +1,38 @@
+const { Command } = require('commander');
+const Cfg = require('../../../cfg.js');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_AGENT_TUNNEL_START,
+  ERR_AGENT_NOT_ENABLED,
+  ERR_TUNNEL_NOT_FOUND,
+  OPTION_NAME,
+  TXT_OPENING_TUNNEL,
+  TXT_TUNNEL_STARTED
+} = require('../../../texts.js');
+const ApiAgent = require('../../../api/agent.js');
+const AgentManager = require('../../../agent/manager');
+
+const commandAgentTunnelStart = new Command('start');
+commandAgentTunnelStart.description(DESC_COMMAND_AGENT_TUNNEL_START);
+commandAgentTunnelStart.argument('<name>', OPTION_NAME);
+commandAgentTunnelStart.action(async (name) => {
+  if (!Cfg.hasTunnel(name)) {
+    Output.exitError(ERR_TUNNEL_NOT_FOUND(name));
+  }
+  const prepared = Cfg.getTunnel(name);
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  try {
+    await Output.spinner(TXT_OPENING_TUNNEL);
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    const data = await api.addTunnel(prepared);
+    Output.exitSuccess(TXT_TUNNEL_STARTED(data.type));
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentTunnelStart;

package/src/command/agent/tunnel/status.js

@@ -0,0 +1,32 @@
+const { Command } = require('commander');
+const {
+  DESC_COMMAND_AGENT_TUNNEL_STATUS,
+  ERR_AGENT_NOT_ENABLED,
+  OPTION_ID
+} = require('../../../texts.js');
+const Output = require('../../../output.js');
+const ApiAgent = require('../../../api/agent.js');
+const AgentSocketTunnel = require('../../../agent/socket/tunnel.js');
+const AgentManager = require('../../../agent/manager');
+
+const commandAgentTunnelStatus = new Command('status');
+commandAgentTunnelStatus.description(DESC_COMMAND_AGENT_TUNNEL_STATUS);
+commandAgentTunnelStatus.argument('<id>', OPTION_ID);
+commandAgentTunnelStatus.action(async (id) => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  try {
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    const ws = await api.socketTunnel(id);
+    const tunnel = new AgentSocketTunnel(ws, id);
+    await tunnel.waitForReady();
+    Output.tunnel(tunnel);
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentTunnelStatus;

package/src/command/agent/tunnel/stop.js

@@ -0,0 +1,30 @@
+const { Command } = require('commander');
+const Output = require('../../../output.js');
+const {
+  DESC_COMMAND_AGENT_TUNNEL_STOP,
+  ERR_AGENT_NOT_ENABLED,
+  OPTION_ID,
+  TXT_TUNNEL_STOPPED
+} = require('../../../texts.js');
+const ApiAgent = require('../../../api/agent.js');
+const AgentManager = require('../../../agent/manager');
+
+const commandAgentTunnelStop = new Command('stop');
+commandAgentTunnelStop.description(DESC_COMMAND_AGENT_TUNNEL_STOP);
+commandAgentTunnelStop.argument('<id>', OPTION_ID);
+commandAgentTunnelStop.action(async (id) => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  try {
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    await api.stopTunnel(id);
+    Output.exitSuccess(TXT_TUNNEL_STOPPED);
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentTunnelStop;

package/src/command/agent/tunnel/tcp.js

@@ -0,0 +1,47 @@
+const { TUNNEL_TCP } = require('../../../utils.js');
+const Output = require('../../../output.js');
+const Cfg = require('../../../cfg.js');
+const {
+  DESC_COMMAND_AGENT_TUNNEL_TCP,
+  ERR_AGENT_NOT_ENABLED,
+  OPTION_FOLLOW,
+  OPTION_TARGET,
+  TXT_OPENING_TUNNEL,
+  TXT_TUNNEL_STARTED
+} = require('../../../texts.js');
+const ApiAgent = require('../../../api/agent.js');
+const AgentSocketTunnel = require('../../../agent/socket/tunnel.js');
+const ApiBuddy = require('../../../api/buddy');
+const { getBasicCommandTcp } = require('../../../utils');
+const AgentManager = require('../../../agent/manager');
+
+const commandAgentTunnelTcp = getBasicCommandTcp();
+commandAgentTunnelTcp.description(DESC_COMMAND_AGENT_TUNNEL_TCP);
+commandAgentTunnelTcp.option('-f, --follow', OPTION_FOLLOW);
+commandAgentTunnelTcp.argument('[host:port]', OPTION_TARGET);
+commandAgentTunnelTcp.action(async (target, options) => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  const myIp = await ApiBuddy.fetchMyIp();
+  const prepared = await Cfg.prepareTunnel(TUNNEL_TCP, target, options, true, myIp);
+  try {
+    await Output.spinner(TXT_OPENING_TUNNEL);
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    const data = await api.addTunnel(prepared);
+    if (options.follow) {
+      const ws = await api.socketTunnel(data.id);
+      const tunnel = new AgentSocketTunnel(ws, data.id);
+      await tunnel.waitForReady();
+      Output.tunnel(tunnel);
+    } else {
+      Output.exitSuccess(TXT_TUNNEL_STARTED(data.type));
+    }
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentTunnelTcp;

package/src/command/agent/tunnel/tls.js

@@ -0,0 +1,47 @@
+const { TUNNEL_TLS } = require('../../../utils.js');
+const Output = require('../../../output.js');
+const Cfg = require('../../../cfg.js');
+const {
+  DESC_COMMAND_AGENT_TUNNEL_TLS,
+  ERR_AGENT_NOT_ENABLED,
+  OPTION_TARGET,
+  TXT_OPENING_TUNNEL,
+  TXT_TUNNEL_STARTED
+} = require('../../../texts.js');
+const ApiAgent = require('../../../api/agent.js');
+const ApiBuddy = require('../../../api/buddy');
+const { getBasicCommandTls } = require('../../../utils');
+const AgentManager = require('../../../agent/manager');
+const { OPTION_FOLLOW } = require('../../../texts');
+const AgentSocketTunnel = require('../../../agent/socket/tunnel');
+
+const commandAgentTunnelTls = getBasicCommandTls();
+commandAgentTunnelTls.description(DESC_COMMAND_AGENT_TUNNEL_TLS);
+commandAgentTunnelTls.option('-f, --follow', OPTION_FOLLOW);
+commandAgentTunnelTls.argument('[host:port]', OPTION_TARGET);
+commandAgentTunnelTls.action(async (target, options) => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  const myIp = await ApiBuddy.fetchMyIp();
+  const prepared = await Cfg.prepareTunnel(TUNNEL_TLS, target, options, true, myIp);
+  try {
+    await Output.spinner(TXT_OPENING_TUNNEL);
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    const data = await api.addTunnel(prepared);
+    if (options.follow) {
+      const ws = await api.socketTunnel(data.id);
+      const tunnel = new AgentSocketTunnel(ws, data.id);
+      await tunnel.waitForReady();
+      Output.tunnel(tunnel);
+    } else {
+      Output.exitSuccess(TXT_TUNNEL_STARTED(data.type));
+    }
+  } catch (err) {
+    Output.exitError(err);
+  }
+});
+
+module.exports = commandAgentTunnelTls;

package/src/command/agent/tunnel.js

@@ -0,0 +1,21 @@
+const { Command } = require('commander');
+const commandAgentTunnelTcp = require('./tunnel/tcp.js');
+const commandAgentTunnelList = require('./tunnel/list.js');
+const commandAgentTunnelStop = require('./tunnel/stop.js');
+const commandAgentTunnelTls = require('./tunnel/tls.js');
+const commandAgentTunnelHttp = require('./tunnel/http.js');
+const commandAgentTunnelStart = require('./tunnel/start.js');
+const { DESC_COMMAND_AGENT_TUNNEL } = require('../../texts.js');
+const commandAgentTunnelStatus = require('./tunnel/status.js');
+
+const commandAgentTunnel = new Command('tunnel');
+commandAgentTunnel.description(DESC_COMMAND_AGENT_TUNNEL);
+commandAgentTunnel.addCommand(commandAgentTunnelTcp);
+commandAgentTunnel.addCommand(commandAgentTunnelTls);
+commandAgentTunnel.addCommand(commandAgentTunnelHttp);
+commandAgentTunnel.addCommand(commandAgentTunnelStart);
+commandAgentTunnel.addCommand(commandAgentTunnelStop);
+commandAgentTunnel.addCommand(commandAgentTunnelList);
+commandAgentTunnel.addCommand(commandAgentTunnelStatus);
+
+module.exports = commandAgentTunnel;

package/src/command/agent/update.js

@@ -0,0 +1,43 @@
+const { Command } = require('commander');
+const {
+  DESC_COMMAND_AGENT_UPDATE,
+  ERR_AGENT_NOT_ENABLED,
+  ERR_SWW_AGENT_UPDATING,
+} = require('../../texts.js');
+const Output = require('../../output.js');
+const waitUntilAgentEnabled = require('../../agent/wait.js');
+const AgentManager = require('../../agent/manager');
+const { ERR_AGENT_ADMIN_RIGHTS,
+  TXT_AGENT_UPDATED,
+  TXT_UPDATING_AGENT
+} = require('../../texts');
+const ApiAgent = require('../../api/agent');
+
+const commandAgentUpdate = new Command('update');
+commandAgentUpdate.description(DESC_COMMAND_AGENT_UPDATE);
+commandAgentUpdate.hideVersionUpdate = true;
+commandAgentUpdate.action(async () => {
+  const hasAdminRights = await AgentManager.system.hasAdminRights();
+  if (!hasAdminRights) {
+    Output.exitError(ERR_AGENT_ADMIN_RIGHTS);
+  }
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  Output.normal(TXT_UPDATING_AGENT);
+  try {
+    await AgentManager.system.update();
+    const json = AgentManager.system.loadSystemConfig();
+    const api = new ApiAgent(json.port);
+    await waitUntilAgentEnabled(api,15000, () => {
+      Output.exitError(ERR_SWW_AGENT_UPDATING);
+    }, () => {
+      Output.exitSuccess(TXT_AGENT_UPDATED);
+    });
+  } catch {
+    Output.exitError(ERR_SWW_AGENT_UPDATING);
+  }
+});
+
+module.exports = commandAgentUpdate;

package/src/command/agent/version.js

@@ -0,0 +1,23 @@
+const { Command } = require('commander');
+const Output = require('../../output.js');
+const {
+  DESC_COMMAND_AGENT_VERSION,
+  ERR_AGENT_NOT_ENABLED,
+  ERR_SWW
+} = require('../../texts.js');
+const AgentManager = require('../../agent/manager');
+
+const commandAgentVersion = new Command('version');
+commandAgentVersion.description(DESC_COMMAND_AGENT_VERSION);
+commandAgentVersion.action(async () => {
+  const isEnabled = await AgentManager.system.isEnabled();
+  if (!isEnabled) {
+    Output.exitError(ERR_AGENT_NOT_ENABLED);
+  }
+  if (!commandAgentVersion.agentStatus) {
+    Output.exitError(ERR_SWW);
+  }
+  Output.exitNormal(commandAgentVersion.agentStatus.version);
+});
+
+module.exports = commandAgentVersion;

package/src/command/agent.js

@@ -0,0 +1,27 @@
+const { Command } = require('commander');
+const commandAgentStart = require('./agent/start.js');
+const commandAgentStatus = require('./agent/status.js');
+const commandAgentRestart = require('./agent/restart.js');
+const commandAgentStop = require('./agent/stop.js');
+const commandAgentUpdate = require('./agent/update.js');
+const commandAgentTunnel = require('./agent/tunnel.js');
+const commandAgentEnable = require('./agent/enable.js');
+const commandAgentDisable = require('./agent/disable.js');
+const commandAgentVersion = require('./agent/version.js');
+const { DESC_COMMAND_AGENT } = require('../texts.js');
+const commandAgentRun = require('./agent/run');
+
+const commandAgent = new Command('agent');
+commandAgent.description(DESC_COMMAND_AGENT);
+commandAgent.addCommand(commandAgentEnable);
+commandAgent.addCommand(commandAgentStart);
+commandAgent.addCommand(commandAgentStop);
+commandAgent.addCommand(commandAgentRestart);
+commandAgent.addCommand(commandAgentDisable);
+commandAgent.addCommand(commandAgentStatus);
+commandAgent.addCommand(commandAgentTunnel);
+commandAgent.addCommand(commandAgentUpdate);
+commandAgent.addCommand(commandAgentVersion);
+commandAgent.addCommand(commandAgentRun, { hidden: true });
+
+module.exports = commandAgent;