clever-tools 2.9.1 → 2.10.0-beta.2

package/CHANGELOG.md

@@ -2,7 +2,13 @@
 
 ## Unrelease (????-??-??)
 
-...
+## 2.10.0-beta.2 (2022-09-13)
+
+* NetworkGroups fix wrong function call.
+
+## 2.10.0-beta.0 (2022-09-06)
+
+* Add NetworkGroups commands `clever ng --help`
 
 ## 2.9.1 (2022-02-28)
 

package/bin/clever.js

@@ -18,6 +18,7 @@ const updateNotifier = require('update-notifier');
 const git = require('../src/models/git.js');
 const Parsers = require('../src/parsers.js');
 const handleCommandPromise = require('../src/command-promise-handler.js');
+const Formatter = require('../src/models/format-string.js');
 
 // Exit cleanly if the program we pipe to exits abruptly
 process.stdout.on('error', (error) => {
@@ -69,6 +70,7 @@ const ApplicationConfiguration = lazyRequire('../src/models/application_configur
 const Drain = lazyRequire('../src/models/drain.js');
 const Notification = lazyRequire('../src/models/notification.js');
 const Organisation = lazyRequire('../src/models/organisation.js');
+const NetworkGroup = lazyRequire('../src/models/networkgroup.js');
 
 function run () {
 
@@ -113,6 +115,11 @@ function run () {
       },
     }),
     configurationValue: cliparse.argument('configuration-value', { description: 'The new value of the configuration' }),
+    ngId: cliparse.argument('ng-id', { description: 'The Network Group id' }),
+    ngIdOrLabel: cliparse.argument('ng', {
+      description: 'Network Group ID or label',
+      parser: Parsers.ngIdOrLabel,
+    }),
   };
 
   // OPTIONS
@@ -132,7 +139,9 @@ function run () {
       aliases: ['f'],
       description: 'Display access logs continuously (ignores before/until, after/since)',
     }),
-    importAsJson: cliparse.flag('json', { description: 'Import variables as JSON (an array of { "name": "THE_NAME", "value": "the value" } objects)' }),
+    importAsJson: cliparse.flag('json', {
+      description: 'Import variables as JSON (an array of { "name": "THE_NAME", "value": "the value" } objects)',
+    }),
     addonId: cliparse.option('addon', { metavar: 'addon_id', description: 'Addon ID' }),
     after: cliparse.option('after', {
       metavar: 'after',
@@ -151,6 +160,10 @@ function run () {
       description: 'Short name for the application',
       complete: Application('listAvailableAliases'),
     }),
+    naturalName: cliparse.flag('natural-name', {
+      aliases: ['n'],
+      description: 'Show application names or aliases if possible',
+    }),
     before: cliparse.option('before', {
       metavar: 'before',
       aliases: ['until'],
@@ -270,7 +283,7 @@ function run () {
     onlyAliases: cliparse.flag('only-aliases', { description: 'List only application aliases' }),
     onlyApps: cliparse.flag('only-apps', { description: 'Only show app dependencies' }),
     orgaIdOrName: cliparse.option('org', {
-      aliases: ['o'],
+      aliases: ['o', 'owner'],
       description: 'Organisation ID (or name, if unambiguous)',
       parser: Parsers.orgaIdOrName,
     }),
@@ -366,6 +379,158 @@ function run () {
       aliases: ['y'],
       description: 'Skip confirmation even if the TCP redirection is not free',
     }),
+    ngLabel: cliparse.option('label', {
+      required: true,
+      metavar: 'ng_label',
+      description: 'Network Group label, also used for dns context',
+    }),
+    ngIdOrLabel: cliparse.option('ng', {
+      required: true,
+      metavar: 'ng',
+      description: 'Network Group ID or label',
+      parser: Parsers.ngIdOrLabel,
+      // complete: NetworkGroup('xxx'),
+    }),
+    ngDescription: cliparse.option('description', {
+      required: true,
+      metavar: 'ng_description',
+      description: 'Network Group description',
+    }),
+    ngMemberId: cliparse.option('member-id', {
+      aliases: ['m'],
+      required: true,
+      metavar: 'member_id',
+      description: `The member ID: an app ID (i.e. ${Formatter.formatCode('app_xxx')}), add-on ID (i.e. ${Formatter.formatCode('addon_xxx')}) or external node category ID`,
+      // complete: NetworkGroup('xxx'),
+    }),
+    ngMemberDomainName: cliparse.option('domain-name', {
+      required: true,
+      metavar: 'domain_name',
+      description: `Member name used in the ${Formatter.formatUrl('<memberName>.m.<ngID>.ng.clever-cloud.com', false)} domain name alias`,
+    }),
+    ngPeerId: cliparse.option('peer-id', {
+      required: true,
+      metavar: 'peer_id',
+      description: 'The peer ID',
+      // complete: NetworkGroup('xxx'),
+    }),
+    ngPeerRole: cliparse.option('role', {
+      required: true,
+      metavar: 'peer_role',
+      description: `The peer role, (${Formatter.formatString('client')} or ${Formatter.formatString('server')})`,
+      parser: Parsers.ngPeerRole,
+      complete: NetworkGroup('listAvailablePeerRoles'),
+    }),
+    // FIXME: Add "internal" member type
+    ngMemberType: cliparse.option('type', {
+      required: true,
+      metavar: 'member_type',
+      description: `The member type (${Formatter.formatString('application')}, ${Formatter.formatString('addon')} or ${Formatter.formatString('external')})`,
+      parser: Parsers.ngMemberType,
+      complete: NetworkGroup('listAvailableMemberTypes'),
+    }),
+    ngMemberLabel: cliparse.option('label', {
+      required: true,
+      metavar: 'member_label',
+      description: 'Network Group member label',
+    }),
+    ngNodeCategoryId: cliparse.option('node-category-id', {
+      required: true,
+      aliases: ['c'],
+      metavar: 'node_category_id',
+      description: 'The external node category ID',
+      // complete: NetworkGroup('xxx'),
+    }),
+    ngPeerLabel: cliparse.option('label', {
+      required: true,
+      metavar: 'peer_label',
+      description: 'Network Group peer label',
+    }),
+    ngPeerParentMemberId: cliparse.option('parent', {
+      required: true,
+      metavar: 'member_id',
+      description: 'Network Group peer category ID (parent member ID)',
+      // complete: NetworkGroup('xxx'),
+    }),
+    optNgIdOrLabel: cliparse.option('ng', {
+      required: false,
+      metavar: 'ng',
+      description: 'Network Group ID or label',
+      parser: Parsers.ngIdOrLabel,
+      // complete: NetworkGroup('xxx'),
+    }),
+    optNgMemberLabel: cliparse.option('label', {
+      required: false,
+      metavar: 'member_label',
+      description: 'The member label',
+    }),
+    optNgNodeCategoryId: cliparse.option('node-category-id', {
+      required: false,
+      aliases: ['c'],
+      metavar: 'node_category_id',
+      description: 'The external node category ID',
+      // complete: NetworkGroup('xxx'),
+    }),
+    optNgPeerId: cliparse.option('peer-id', {
+      required: false,
+      metavar: 'peer_id',
+      description: 'The peer ID',
+      // complete: NetworkGroup('xxx'),
+    }),
+    optNgPeerRole: cliparse.option('role', {
+      required: false,
+      default: 'client',
+      metavar: 'peer_role',
+      description: `The peer role, (${Formatter.formatString('client')} or ${Formatter.formatString('server')})`,
+      parser: Parsers.ngPeerRole,
+      complete: NetworkGroup('listAvailablePeerRoles'),
+    }),
+    optNgSearchAppId: cliparse.option('app-id', {
+      required: false,
+      metavar: 'app_id',
+      description: 'The app id to search',
+      // complete: NetworkGroup('xxx'),
+    }),
+    wgPublicKey: cliparse.option('public-key', {
+      required: true,
+      metavar: 'public_key',
+      description: 'A WireGuard® public key',
+    }),
+    optWgPrivateKey: cliparse.option('private-key', {
+      required: false,
+      metavar: 'private_key',
+      description: 'A WireGuard® private key',
+    }),
+    jsonFormat: cliparse.flag('json', { aliases: ['j'], description: 'Show result in JSON format' }),
+    tag: cliparse.option('tag', {
+      required: true,
+      metavar: 'tag',
+      description: 'A tag',
+      parser: Parsers.tag,
+    }),
+    tags: cliparse.option('tags', {
+      required: true,
+      metavar: 'tags',
+      description: 'List of tags separated by a comma',
+      parser: Parsers.tags,
+    }),
+    optTags: cliparse.option('tags', {
+      metavar: 'tags',
+      description: 'List of tags separated by a comma',
+      parser: Parsers.tags,
+    }),
+    optIpAddress: cliparse.option('ip', {
+      required: false,
+      metavar: 'ip_address',
+      description: 'An IP address',
+      parser: Parsers.ipAddress,
+    }),
+    optPortNumber: cliparse.option('port', {
+      required: false,
+      metavar: 'port_number',
+      description: 'A port number',
+      parser: Parsers.portNumber,
+    }),
   };
 
   // ACCESSLOGS COMMAND
@@ -416,7 +581,7 @@ function run () {
   const applications = lazyRequirePromiseModule('../src/commands/applications.js');
   const applicationsCommand = cliparse.command('applications', {
     description: 'List linked applications',
-    options: [opts.onlyAliases],
+    options: [opts.onlyAliases, opts.jsonFormat],
   }, applications('list'));
 
   // CANCEL DEPLOY COMMAND
@@ -586,6 +751,84 @@ function run () {
     args: [args.alias],
   }, makeDefault('makeDefault'));
 
+  // NETWORK GROUPS COMMANDS
+  const networkgroups = lazyRequirePromiseModule('../src/commands/networkgroups/commands.js');
+
+  // network group category - start
+  const networkGroupsListCommand = cliparse.command('list', {
+    description: 'List Network Groups with their labels',
+    options: [opts.jsonFormat],
+  }, networkgroups('listNetworkGroups'));
+  const networkGroupsCreateCommand = cliparse.command('create', {
+    description: 'Create a Network Group',
+    options: [opts.ngLabel, opts.ngDescription, opts.optTags, opts.jsonFormat],
+  }, networkgroups('createNg'));
+  const networkGroupsDeleteCommand = cliparse.command('delete', {
+    description: 'Delete a Network Group',
+    options: [opts.ngIdOrLabel],
+  }, networkgroups('deleteNg'));
+  // network group category - end
+
+  // member category - start
+  const networkGroupsMemberListCommand = cliparse.command('list', {
+    description: 'List members of a Network Group',
+    // Add option opts.optNgSearchAppId ?
+    options: [opts.ngIdOrLabel, opts.naturalName, opts.jsonFormat],
+  }, networkgroups('listMembers'));
+  const networkGroupsMemberGetCommand = cliparse.command('get', {
+    description: 'Get a Network Group member details',
+    options: [opts.ngIdOrLabel, opts.ngMemberId, opts.naturalName, opts.jsonFormat],
+  }, networkgroups('getMember'));
+  const networkGroupsMemberAddCommand = cliparse.command('add', {
+    description: 'Add an app or addon as a Network Group member',
+    options: [opts.ngIdOrLabel, opts.ngMemberId, opts.ngMemberType, opts.ngMemberDomainName, opts.optNgMemberLabel],
+  }, networkgroups('addMember'));
+  const networkGroupsMemberRemoveCommand = cliparse.command('remove', {
+    description: 'Remove an app or addon from a Network Group',
+    options: [opts.ngIdOrLabel, opts.ngMemberId],
+  }, networkgroups('removeMember'));
+
+  const networkGroupsMembersCategoryCommand = cliparse.command('members', {
+    description: 'List commands for interacting with Network Group members',
+    commands: [networkGroupsMemberListCommand, networkGroupsMemberGetCommand, networkGroupsMemberAddCommand, networkGroupsMemberRemoveCommand],
+  });
+  // member category - end
+
+  // peer category - start
+  const networkGroupsPeerListCommand = cliparse.command('list', {
+    description: 'List peers of a Network Group',
+    options: [opts.ngIdOrLabel, opts.jsonFormat],
+  }, networkgroups('listPeers'));
+  const networkGroupsPeerGetCommand = cliparse.command('get', {
+    description: 'Get a Network Group peer details',
+    options: [opts.ngIdOrLabel, opts.ngPeerId, opts.jsonFormat],
+  }, networkgroups('getPeer'));
+  const networkGroupsPeerAddCommand = cliparse.command('add-external', {
+    description: 'Add an external node as a Network Group peer',
+    options: [opts.ngIdOrLabel, opts.ngPeerRole, opts.wgPublicKey, opts.ngPeerLabel, opts.ngPeerParentMemberId],
+  }, networkgroups('addExternalPeer'));
+  const networkGroupsPeerRemoveExternalCommand = cliparse.command('remove-external', {
+    description: 'Remove an external node from a Network Group',
+    options: [opts.ngIdOrLabel, opts.ngPeerId],
+  }, networkgroups('removeExternalPeer'));
+
+  const networkGroupsPeersCategoryCommand = cliparse.command('peers', {
+    description: 'List commands for interacting with Network Group peers',
+    commands: [networkGroupsPeerListCommand, networkGroupsPeerGetCommand, networkGroupsPeerAddCommand, networkGroupsPeerRemoveExternalCommand],
+  });
+  // peer category - end
+
+  const networkGroupsCommand = cliparse.command('networkgroups', {
+    description: 'List Network Group commands',
+    options: [opts.orgaIdOrName, opts.alias],
+    commands: [networkGroupsListCommand, networkGroupsCreateCommand, networkGroupsDeleteCommand, networkGroupsMembersCategoryCommand, networkGroupsPeersCategoryCommand],
+  });
+  const ngCommand = cliparse.command('ng', {
+    description: `Alias for ${Formatter.formatCommand('clever networkgroups')}`,
+    options: [opts.orgaIdOrName, opts.alias],
+    commands: [networkGroupsListCommand, networkGroupsCreateCommand, networkGroupsDeleteCommand, networkGroupsMembersCategoryCommand, networkGroupsPeersCategoryCommand],
+  });
+
   // NOTIFY-EMAIL COMMAND
   const notifyEmail = lazyRequirePromiseModule('../src/commands/notify-email.js');
   const addEmailNotificationCommand = cliparse.command('add', {
@@ -780,6 +1023,8 @@ function run () {
       logoutCommand,
       logsCommand,
       makeDefaultCommand,
+      networkGroupsCommand,
+      ngCommand,
       openCommand,
       consoleCommand,
       profileCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clever-tools",
-  "version": "2.9.1",
+  "version": "2.10.0-beta.2",
   "description": "Command Line Interface for Clever Cloud.",
   "main": "bin/clever.js",
   "keywords": [
@@ -15,9 +15,9 @@
   "author": "Clever Cloud <ci@clever-cloud.com>",
   "license": "Apache-2.0",
   "bin": {
-    "clever": "./bin/clever.js",
-    "install-clever-completion": "./scripts/install-autocomplete.sh",
-    "uninstall-clever-completion": "./scripts/uninstall-autocomplete.sh"
+    "clever": "bin/clever.js",
+    "install-clever-completion": "scripts/install-autocomplete.sh",
+    "uninstall-clever-completion": "scripts/uninstall-autocomplete.sh"
   },
   "files": [
     "bin",
@@ -25,7 +25,7 @@
     "scripts/*.sh"
   ],
   "dependencies": {
-    "@clevercloud/client": "^7.4.0",
+    "@clevercloud/client": "7.9.0",
     "clf-date": "^0.2.0",
     "cliparse": "^0.3.3",
     "colors": "1.4.0",
@@ -42,6 +42,7 @@
     "superagent": "^6.1.0",
     "text-table": "^0.2.0",
     "update-notifier": "^5.1.0",
+    "uuid": "^8.3.2",
     "ws": "^7.4.6",
     "xdg": "^0.1.1"
   },

package/src/commands/applications.js

@@ -6,29 +6,38 @@ const AppConfig = require('../models/app_configuration.js');
 const Logger = require('../logger.js');
 
 async function list (params) {
-  const { 'only-aliases': onlyAliases } = params.options;
+  const { 'only-aliases': onlyAliases, json } = params.options;
 
   const { apps } = await AppConfig.loadApplicationConf();
 
-  const formattedApps = formatApps(apps, onlyAliases);
+  const formattedApps = formatApps(apps, onlyAliases, json);
   Logger.println(formattedApps);
 };
 
-function formatApps (apps, onlyAliases) {
+function formatApps (apps, onlyAliases, json) {
 
-  if (onlyAliases) {
-    return apps.map((a) => a.alis).join('\n');
+  if (json) {
+    if (onlyAliases) {
+      apps = apps.map((a) => a.alias);
+    }
+    return JSON.stringify(apps, null, 2);
+  }
+  else {
+    if (onlyAliases) {
+      return apps.map((a) => a.alias).join('\n');
+    }
+    else {
+      return apps
+        .map((app) =>
+          [
+            `Application ${app.name}`,
+            `  alias: ${colors.bold(app.alias)}`,
+            `  id: ${app.app_id}`,
+            `  deployment url: ${app.deploy_url}`].join('\n'),
+        )
+        .join('\n\n');
+    }
   }
-
-  return apps
-    .map((app) => {
-      return [
-        `Application ${app.name}`,
-        `  alias: ${colors.bold(app.alias)}`,
-        `  id: ${app.app_id}`,
-        `  deployment url: ${app.deploy_url}`].join('\n');
-    })
-    .join('\n\n');
 }
 
 module.exports = { list };

package/src/commands/networkgroups/commands.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  ...require('./index.js'),
+  ...require('./members.js'),
+  ...require('./peers.js'),
+};

package/src/commands/networkgroups/index.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const ngApi = require('@clevercloud/client/cjs/api/v4/network-group.js');
+
+const { sendToApi } = require('../../models/send-to-api.js');
+
+const Logger = require('../../logger.js');
+const NetworkGroup = require('../../models/networkgroup.js');
+const Formatter = require('../../models/format-string.js');
+const TableFormatter = require('../../models/format-ng-table.js');
+
+async function listNetworkGroups(params) {
+  const { org: orgaIdOrName, alias, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+
+  Logger.info(`Listing Network Groups from owner ${Formatter.formatString(ownerId)}`);
+  const result = await ngApi.listNetworkGroups({ ownerId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    if (result.length === 0) {
+      Logger.println(`No Network Group found for ${ownerId}. You can create one with ${Formatter.formatCommand('clever networkgroups create')}.`);
+    }
+    else {
+      TableFormatter.printNetworkGroupsTableHeader();
+      result
+        .map((ng) => TableFormatter.formatNetworkGroupsLine(ng))
+        .forEach((ng) => Logger.println(ng));
+    }
+  }
+}
+
+async function createNg(params) {
+  const { org: orgaIdOrName, alias, label, description, tags, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+
+  Logger.info(`Creating Network Group from owner ${Formatter.formatString(ownerId)}`);
+  const body = { ownerId: ownerId, label, description, tags };
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  const result = await ngApi.createNetworkGroup({ ownerId }, body).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    Logger.println(`Network Group ${Formatter.formatString(label)} creation will be performed asynchronously.`);
+  }
+}
+
+async function deleteNg(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Deleting Network Group ${Formatter.formatString(networkGroupId)} from owner ${Formatter.formatString(ownerId)}`);
+  await ngApi.deleteNetworkGroup({ ownerId, networkGroupId }).then(sendToApi);
+
+  Logger.println(`Network Group ${Formatter.formatString(networkGroupId)} deletion will be performed asynchronously.`);
+}
+
+module.exports = {
+  listNetworkGroups,
+  createNg,
+  deleteNg,
+};

package/src/commands/networkgroups/members.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const ngApi = require('@clevercloud/client/cjs/api/v4/network-group.js');
+
+const { sendToApi } = require('../../models/send-to-api.js');
+
+const Logger = require('../../logger.js');
+const NetworkGroup = require('../../models/networkgroup.js');
+const Formatter = require('../../models/format-string.js');
+const TableFormatter = require('../../models/format-ng-table.js');
+
+async function listMembers(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'natural-name': naturalName, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Listing members from Network Group '${networkGroupId}'`);
+  const result = await ngApi.listNetworkGroupMembers({ ownerId, networkGroupId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    if (result.length === 0) {
+      Logger.println(`No member found. You can add one with ${Formatter.formatCommand('clever networkgroups members add')}.`);
+    }
+    else {
+      await TableFormatter.printMembersTableHeader(naturalName);
+      for (const ng of result) {
+        Logger.println(await TableFormatter.formatMembersLine(ng, naturalName));
+      }
+    }
+  }
+}
+
+async function getMember(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'member-id': memberId, 'natural-name': naturalName, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);;
+
+  Logger.info(`Getting details for member ${Formatter.formatString(memberId)} in Network Group ${Formatter.formatString(networkGroupId)}`);
+  const result = await ngApi.getNetworkGroupMember({ ownerId, networkGroupId, memberId: memberId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    await TableFormatter.printMembersTableHeader(naturalName);
+    Logger.println(await TableFormatter.formatMembersLine(result, naturalName));
+  }
+}
+
+async function addMember(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'member-id': memberId, type, 'domain-name': domainName, label } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  const body = { id: memberId, label, domain_name: domainName, type };
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  await ngApi.createNetworkGroupMember({ ownerId, networkGroupId }, body).then(sendToApi);
+
+  Logger.println(`Successfully added member ${Formatter.formatString(memberId)} to Network Group ${Formatter.formatString(networkGroupId)}.`);
+}
+
+async function removeMember(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'member-id': memberId } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  await ngApi.deleteNetworkGroupMember({ ownerId, networkGroupId, memberId }).then(sendToApi);
+
+  Logger.println(`Successfully removed member ${Formatter.formatString(memberId)} from Network Group ${Formatter.formatString(networkGroupId)}.`);
+}
+
+module.exports = {
+  listMembers,
+  getMember,
+  addMember,
+  removeMember,
+};

package/src/commands/networkgroups/peers.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const ngApi = require('@clevercloud/client/cjs/api/v4/network-group.js');
+
+const { sendToApi } = require('../../models/send-to-api.js');
+
+const Logger = require('../../logger.js');
+const NetworkGroup = require('../../models/networkgroup.js');
+const Formatter = require('../../models/format-string.js');
+const TableFormatter = require('../../models/format-ng-table.js');
+
+async function listPeers(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Listing peers from Network Group ${Formatter.formatString(networkGroupId)}`);
+  const result = await ngApi.listNetworkGroupPeers({ ownerId, networkGroupId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(result, null, 2));
+  }
+  else {
+    if (result.length === 0) {
+      Logger.println(`No peer found. You can add an external one with ${Formatter.formatCommand('clever networkgroups peers add-external')}.`);
+    }
+    else {
+      TableFormatter.printPeersTableHeader();
+      result.forEach((peer) => {
+        Logger.println(TableFormatter.formatPeersLine(peer));
+      });
+    }
+  }
+}
+
+async function getPeer(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'peer-id': peerId, json } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Getting details for peer ${Formatter.formatString(peerId)} in Network Group ${Formatter.formatString(networkGroupId)}`);
+  const peer = await ngApi.getNetworkGroupPeer({ ownerId, networkGroupId, peerId }).then(sendToApi);
+
+  if (json) {
+    Logger.println(JSON.stringify(peer, null, 2));
+  }
+  else {
+    TableFormatter.printPeersTableHeader();
+    Logger.println(TableFormatter.formatPeersLine(peer));
+  }
+}
+
+async function addExternalPeer(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, role, 'public-key': publicKey, label, parent, ip, port } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  const body = { peer_role: role, public_key: publicKey, label, parent_member: parent, ip, port };
+  Logger.info(`Adding external peer to Network Group ${Formatter.formatString(networkGroupId)}`);
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  const { id: peerId } = await ngApi.createNetworkGroupExternalPeer({ ownerId, networkGroupId }, body).then(sendToApi);
+
+  Logger.println(`External peer ${Formatter.formatString(peerId)} must have been added to Network Group ${Formatter.formatString(networkGroupId)}.`);
+  return peerId;
+}
+
+async function removeExternalPeer(params) {
+  const { org: orgaIdOrName, alias, ng: networkGroupIdOrLabel, 'peer-id': peerId } = params.options;
+  const ownerId = await NetworkGroup.getOwnerId(orgaIdOrName, alias);
+  const networkGroupId = await NetworkGroup.getId(ownerId, networkGroupIdOrLabel);
+
+  Logger.info(`Removing external peer ${Formatter.formatString(peerId)} from Network Group ${Formatter.formatString(networkGroupId)}`);
+  await ngApi.deleteNetworkGroupExternalPeer({ ownerId, networkGroupId, peerId }).then(sendToApi);
+
+  Logger.println(`External peer ${Formatter.formatString(peerId)} must have been removed from Network Group ${Formatter.formatString(networkGroupId)}.`);
+}
+
+module.exports = {
+  listPeers,
+  getPeer,
+  addExternalPeer,
+  removeExternalPeer,
+};

package/src/models/app_configuration.js

@@ -79,6 +79,14 @@ function findApp (config, alias) {
     return appByAlias;
   }
 
+  return findDefaultApp(config);
+}
+
+function findDefaultApp (config) {
+  if (_.isEmpty(config.apps)) {
+    throw new Error('There are no applications linked. You can add one with `clever link`');
+  }
+
   if (config.default != null) {
     const defaultApp = _.find(config.apps, { app_id: config.default });
     if (defaultApp == null) {
@@ -95,6 +103,25 @@ function findApp (config, alias) {
   throw new Error(`Several applications are linked. You can specify one with the "--alias" option. Run "clever applications" to list linked applications. Available aliases: ${aliases}`);
 }
 
+async function getAppDetailsForId (appId) {
+  const config = await loadApplicationConf();
+
+  if (_.isEmpty(config.apps)) {
+    throw new Error('There are no applications linked. You can add one with `clever link`');
+  }
+
+  const [appById, secondAppById] = _.filter(config.apps, { app_id: appId });
+  if (appById == null) {
+    throw new Error(`There are no applications matching id '${appId}'`);
+  }
+  if (secondAppById != null) {
+    throw new Error(`There are several applications matching id '${appId}'.`
+                  + 'This should not happen, your `.clever.json` should be fixed.');
+  }
+
+  return appById;
+}
+
 async function getAppDetails ({ alias }) {
   const config = await loadApplicationConf();
   const app = findApp(config, alias);
@@ -110,6 +137,16 @@ async function getAppDetails ({ alias }) {
   };
 };
 
+async function getMostNaturalName (appId) {
+  try {
+    const details = await getAppDetailsForId(appId);
+    return details.alias || details.name || appId;
+  }
+  catch {
+    return appId;
+  }
+}
+
 function persistConfig (modifiedConfig) {
   const jsonContents = JSON.stringify(modifiedConfig, null, 2);
   return fs.writeFile(conf.APP_CONFIGURATION_FILE, jsonContents);
@@ -128,5 +165,6 @@ module.exports = {
   removeLinkedApplication,
   findApp,
   getAppDetails,
+  getMostNaturalName,
   setDefault,
 };

package/src/models/format-ng-table.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const formatNgTable = require('../format-table.js');
+const colors = require('colors/safe');
+
+const AppConfig = require('./app_configuration.js');
+const Logger = require('../logger.js');
+const Formatter = require('./format-string.js');
+
+function printSeparator (columnLengths) {
+  Logger.println('─'.repeat(columnLengths.reduce((a, b) => a + b + 2)));
+}
+
+// We use examples of maximum width text to have a clean display
+const networkGroupsTableColumnLengths = [
+  39, /* id length */
+  48, /* label length */
+  7, /* members length */
+  5, /* peers length */
+  48, /* description */
+];
+const formatNetworkGroupsTable = formatNgTable(networkGroupsTableColumnLengths);
+function formatNetworkGroupsLine (ng) {
+  return formatNetworkGroupsTable([
+    [
+      Formatter.formatId(ng.id),
+      Formatter.formatString(ng.label, false),
+      Formatter.formatNumber(ng.members.length),
+      Formatter.formatNumber(ng.peers.length),
+      Formatter.formatString(ng.description || ' ', false),
+    ],
+  ]);
+};
+function printNetworkGroupsTableHeader () {
+  Logger.println(colors.bold(formatNetworkGroupsTable([
+    ['Network Group ID', 'Label', 'Members', 'Peers', 'Description'],
+  ])));
+  printSeparator(networkGroupsTableColumnLengths);
+}
+
+const membersTableColumnLengths = [
+  48, /* id length */
+  12, /* type length */
+  48, /* label length */
+  24, /* domain-name length */
+];
+const formatMembersTable = formatNgTable(membersTableColumnLengths);
+async function formatMembersLine (member, showAliases = false) {
+  return formatMembersTable([
+    [
+      showAliases
+        ? Formatter.formatString(await AppConfig.getMostNaturalName(member.id), false)
+        : Formatter.formatId(member.id),
+      Formatter.formatString(member.type, false),
+      Formatter.formatString(member.label, false),
+      Formatter.formatString(member.domain_name || ' ', false),
+    ],
+  ]);
+};
+async function printMembersTableHeader (naturalName = false) {
+  Logger.println(colors.bold(formatMembersTable([
+    [
+      naturalName ? 'Member' : 'Member ID',
+      'Member Type',
+      'Label',
+      'Domain Name',
+    ],
+  ])));
+  printSeparator(membersTableColumnLengths);
+}
+
+const peersTableColumnLengths = [
+  45, /* id length */
+  12, /* type length */
+  14, /* endpoint type length */
+  48, /* label length */
+  24, /* hostname */
+  15, /* ip */
+];
+const formatPeersTable = formatNgTable(peersTableColumnLengths);
+function formatPeersLine (peer) {
+  const ip = (peer.endpoint.type === 'ServerEndpoint') ? peer.endpoint.ng_term.ip : peer.endpoint.ng_ip;
+  return formatPeersTable([
+    [
+      Formatter.formatId(peer.id),
+      Formatter.formatString(peer.type, false),
+      Formatter.formatString(peer.endpoint.type, false),
+      Formatter.formatString(peer.label, false),
+      Formatter.formatString(peer.hostname, false),
+      Formatter.formatIp(ip),
+    ],
+  ]);
+};
+function printPeersTableHeader () {
+  Logger.println(colors.bold(formatPeersTable([
+    [
+      'Peer ID',
+      'Peer Type',
+      'Endpoint Type',
+      'Label',
+      'Hostname',
+      'IP Address',
+    ],
+  ])));
+  printSeparator(peersTableColumnLengths);
+}
+
+module.exports = {
+  formatNetworkGroupsLine,
+  printNetworkGroupsTableHeader,
+  formatMembersLine,
+  printMembersTableHeader,
+  formatPeersLine,
+  printPeersTableHeader,
+};

package/src/models/format-string.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const colors = require('colors/safe');
+
+function formatId (id) {
+  return colors.dim(id);
+}
+
+function formatString (str, decorated = true) {
+  const string = decorated ? `'${str}'` : str;
+  return colors.green(string);
+}
+
+function formatNumber (number) {
+  return colors.yellow(number);
+}
+
+function formatIp (ip) {
+  return colors.cyan(ip);
+}
+
+function formatUrl (url, decorated = true) {
+  const string = decorated ? `<${url}>` : url;
+  return colors.cyan(string);
+}
+
+function formatCommand (command, decorated = true) {
+  const string = decorated ? `\`${command}\`` : command;
+  return colors.magenta(string);
+}
+
+function formatCode (code, decorated = true) {
+  return formatCommand(code, decorated);
+}
+
+module.exports = {
+  formatId,
+  formatString,
+  formatNumber,
+  formatIp,
+  formatUrl,
+  formatCommand,
+  formatCode,
+};

package/src/models/networkgroup.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const autocomplete = require('cliparse').autocomplete;
+const Organisation = require('../models/organisation.js');
+const User = require('../models/user.js');
+const AppConfig = require('./app_configuration.js');
+const ngApi = require('@clevercloud/client/cjs/api/v4/network-group.js');
+const { sendToApi } = require('./send-to-api.js');
+
+async function getOwnerId(orgaIdOrName, alias) {
+  if (orgaIdOrName == null) {
+    try {
+      return (await AppConfig.getAppDetails({alias})).ownerId;
+    } catch (error) {
+      return (await User.getCurrentId())
+    }
+  } else {
+    return (await Organisation.getId(orgaIdOrName));
+  }
+}
+
+async function getId(ownerId, ngIdOrLabel) {
+  if (ngIdOrLabel == null) {
+    return null;
+  }
+
+  if (ngIdOrLabel.ng_id != null) {
+    return ngIdOrLabel.ng_id;
+  }
+
+  return getByLabel(ownerId, ngIdOrLabel.ng_label)
+    .then((ng) => ng.id);
+}
+
+async function getByLabel(owner_id, label) {
+  const networkGroups = await ngApi.listNetworkGroups({ owner_id }).then(sendToApi);
+  const filteredNgs = networkGroups.filter((ng) => ng.label === label);
+
+  if (filteredNgs.length === 0) {
+    throw new Error('Network Group not found');
+  }
+  if (filteredNgs.length > 1) {
+    throw new Error('Ambiguous Network Group label');
+  }
+
+  return filteredNgs[0];
+}
+
+function listAvailablePeerRoles() {
+  return autocomplete.words(['client', 'server']);
+}
+
+function listAvailableMemberTypes() {
+  return autocomplete.words(['application', 'addon', 'external']);
+}
+
+module.exports = {
+  getOwnerId,
+  getId,
+  listAvailablePeerRoles,
+  listAvailableMemberTypes,
+};

package/src/models/wireguard-conf.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const os = require('os');
+const { promises: fs, existsSync } = require('fs');
+const path = require('path');
+
+const Logger = require('../logger.js');
+const Formatter = require('./format-string.js');
+
+function getWgConfFolder () {
+  // TODO: See if we can use runtime dirs
+  return path.join(os.tmpdir(), 'com.clever-cloud.networkgroups');
+}
+
+async function createWgConfFolderIfNeeded () {
+  const confFolder = getWgConfFolder();
+  if (!existsSync(confFolder)) {
+    await fs.mkdir(confFolder);
+  }
+}
+
+function getWgConfInformation (ngId) {
+  const confName = `wgcc${ngId.slice(-8)}`;
+  const confPath = path.join(getWgConfFolder(), `${confName}.conf`);
+
+  return { confName, confPath };
+}
+
+function getPeerIdPath (confName) {
+  return path.join(getWgConfFolder(), `${confName}.id`);
+}
+
+async function storePeerId (peerId, confName) {
+  const filePath = getPeerIdPath(confName);
+
+  try {
+    await fs.writeFile(filePath, peerId, { mode: 0o600, flag: 'wx' });
+    Logger.info(`Saved peer ID file to ${Formatter.formatUrl(filePath)}`);
+  }
+  catch (error) {
+    throw new Error(`Error saving peer ID: ${error}`);
+  }
+}
+
+async function getPeerId (ngId) {
+  const { confName } = getWgConfInformation(ngId);
+  const filePath = getPeerIdPath(confName);
+  if (existsSync(filePath)) {
+    Logger.debug(`Reading peer ID from ${Formatter.formatUrl(filePath)}`);
+    return (await fs.readFile(filePath, { encoding: 'utf-8' })).trim();
+  }
+  else {
+    Logger.debug(`No file found at ${Formatter.formatUrl(filePath)}`);
+    return null;
+  }
+}
+
+async function deletePeerIdFile (ngId) {
+  const { confName } = getWgConfInformation(ngId);
+  const filePath = getPeerIdPath(confName);
+  // We need `force: true` to avoid errors if file doesn't exist
+  await fs.rm(filePath, { force: true });
+  Logger.info(`Deleted peer ID from ${Formatter.formatUrl(filePath)}`);
+}
+
+async function getInterfaceName (confName) {
+  // This file is created by WireGuard®, hence the file path (`/var/run/…`)
+  // TODO: Handle Windows (not yet supported by `wg-quick` anyway)
+  const interfaceNameFile = path.join('/var', 'run', 'wireguard', `${confName}.name`);
+
+  Logger.debug(`Reading WireGuard® interface name in ${Formatter.formatUrl(interfaceNameFile)}…`);
+  const interfaceName = (await fs.readFile(interfaceNameFile, { encoding: 'utf-8' })).trim();
+  Logger.debug(`Found WireGuard® interface name ${Formatter.formatString(interfaceName)} for ${Formatter.formatString(confName)}`);
+  return interfaceName;
+}
+
+function confWithoutPlaceholders (conf, { privateKey }) {
+  conf = conf.replace('<%PrivateKey%>', privateKey);
+
+  // TODO: This just removes leading and trailing new lines in the configuration file
+  //       It should be better formatted on the API's side
+  conf = conf.trim();
+
+  return conf;
+}
+
+module.exports = {
+  createWgConfFolderIfNeeded,
+  getWgConfInformation,
+  storePeerId,
+  getPeerId,
+  deletePeerIdFile,
+  getInterfaceName,
+  confWithoutPlaceholders,
+};

package/src/models/wireguard.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+const Logger = require('../logger.js');
+
+function privateKey () {
+  return execSync('wg genkey', { encoding: 'utf-8' }).trim();
+}
+
+function publicKey (privateKey) {
+  return execSync(`echo '${privateKey}' | wg pubkey`, { encoding: 'utf-8' }).trim();
+}
+
+function up (confPath) {
+  // We must use `spawn` with `detached: true` instead of `exec`
+  // because `wg-quick up` starts a `wireguard-go` used by `wg-quick down`
+  const { stdout, stderr } = spawnSync('wg-quick', ['up', confPath], { detached: true, encoding: 'utf-8' });
+  if (stdout.length > 0) {
+    Logger.debug(stdout.trim());
+  }
+  if (stderr.length > 0) {
+    Logger.debug(stderr.trim());
+  }
+  Logger.println('Activated WireGuard® tunnel');
+}
+
+function update (confPath, interfaceName) {
+  try {
+    // Update WireGuard® configuration
+    execSync(`wg-quick strip ${confPath} | wg syncconf ${interfaceName} /dev/stdin`);
+    Logger.info('Updated WireGuard® tunnel configuration');
+  }
+  catch (error) {
+    throw new Error(`Error updating WireGuard® tunnel configuration: ${error}`);
+  }
+}
+
+function down (confPath) {
+  const { stdout, stderr } = spawnSync('wg-quick', ['down', confPath], { encoding: 'utf-8' });
+  if (stdout.length > 0) {
+    Logger.debug(stdout.trim());
+  }
+  if (stderr.length > 0) {
+    Logger.debug(stderr.trim());
+  }
+}
+
+/**
+ * Check that `wg` and `wg-quick` are installed
+ */
+function checkAvailable () {
+  try {
+    // The redirect to `/dev/null` ensures that your program does not produce the output of these commands.
+    execSync('which wg > /dev/null 2>&1');
+    execSync('which wg-quick > /dev/null 2>&1');
+
+    // TODO: Handle Windows
+    //        - Those checks won't work on Windows, and wg-quick doesn't exist anyway.
+    //          - We need to wait for a Windows version of wg-quick to support the rest of the operations
+    //          - Or we could use vanilla wg on Windows, and wg-quick on other OSs
+    return true;
+  }
+  catch {
+    return false;
+  }
+}
+
+module.exports = {
+  privateKey,
+  publicKey,
+  up,
+  update,
+  down,
+  checkAvailable,
+};

package/src/parsers.js

@@ -48,7 +48,7 @@ function appIdOrName (string) {
   return cliparse.parsers.success({ app_name: string });
 }
 
-const orgaIdRegex = /^orga_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const orgaIdRegex = /^(user_|orga_)[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 function orgaIdOrName (string) {
   if (string.match(orgaIdRegex)) {
@@ -66,6 +66,15 @@ function addonIdOrName (string) {
   return cliparse.parsers.success({ addon_name: string });
 }
 
+const ngIdRegex = /^ng_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function ngIdOrLabel (string) {
+  if (string.match(ngIdRegex)) {
+    return cliparse.parsers.success({ ng_id: string });
+  }
+  return cliparse.parsers.success({ ng_label: string });
+}
+
 function commaSeparated (string) {
   return cliparse.parsers.success(string.split(','));
 }
@@ -86,6 +95,63 @@ function integer (string) {
   return cliparse.parsers.success(integer);
 }
 
+// /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/i;
+const tagRegex = /^[^,\s]+$/;
+
+function tag (string) {
+  if (string.match(tagRegex)) {
+    return cliparse.parsers.success(string);
+  }
+  return cliparse.parsers.error(`Invalid tag '${string}'. Should match ${tagRegex}`);
+}
+
+function tags (string) {
+  if (String(string).length === 0) {
+    return cliparse.parsers.success([]);
+  }
+  const tags = String(string).split(',');
+  for (const current of tags) {
+    if (tag(current).error) {
+      return cliparse.parsers.error(`Invalid tag '${current}'. Should match \`${tagRegex}\``);
+    }
+  }
+  return cliparse.parsers.success(tags);
+}
+
+function ngMemberType (string) {
+  const possible = ['application', 'addon', 'external'];
+  if (possible.includes(string)) {
+    return cliparse.parsers.success(string);
+  }
+  return cliparse.parsers.error(`Invalid member type '${string}'. Should be in ${JSON.stringify(possible)}`);
+}
+
+function ngPeerRole (string) {
+  const possible = ['client', 'server'];
+  if (possible.includes(string)) {
+    return cliparse.parsers.success(string);
+  }
+  return cliparse.parsers.error(`Invalid peer role '${string}'. Should be in ${JSON.stringify(possible)}`);
+}
+
+const ipAddressRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])$/;
+
+function ipAddress (string) {
+  if (string.match(ipAddressRegex)) {
+    return cliparse.parsers.success(string);
+  }
+  return cliparse.parsers.error(`Invalid IP address '${string}'. Should match ${ipAddressRegex}`);
+}
+
+const portNumberRegex = /^\d{1,5}$/;
+
+function portNumber (number) {
+  if (String(number).match(portNumberRegex)) {
+    return cliparse.parsers.success(number);
+  }
+  return cliparse.parsers.error(`Invalid port number '${number}'. Should match ${portNumberRegex}`);
+}
+
 module.exports = {
   buildFlavor,
   flavor,
@@ -94,7 +160,16 @@ module.exports = {
   appIdOrName,
   orgaIdOrName,
   addonIdOrName,
+  ngIdOrLabel,
   commaSeparated,
   accessLogsFormat,
   integer,
+  tag,
+  tags,
+  ngMemberType,
+  ngPeerRole,
+  ipAddressRegex,
+  ipAddress,
+  portNumberRegex,
+  portNumber,
 };