clever-tools 3.8.3 → 3.10.0

package/bin/clever.js

@@ -1,64 +1,61 @@
 #! /usr/bin/env node
-'use strict';
 
-function hasParam (param, paramValue) {
-  const index = process.argv.indexOf(param);
-  if (index === -1) {
-    return false;
-  }
-  if (paramValue != null) {
-    return process.argv[index + 1] === paramValue;
-  }
-  return true;
-}
-
-// These need to be set before Logger and other stuffs
-if (hasParam('-v') || hasParam('--verbose')) {
-  process.env.CLEVER_VERBOSE = '1';
-}
-
-// These need to be set before Logger and other stuffs
-// Don't log anything in autocomplete mode
-if (hasParam('--autocomplete-index')) {
-  process.env.CLEVER_QUIET = '1';
-}
-
-// These need to be set before other stuffs
-const colors = require('colors');
-const colorExplicitFalse = hasParam('--no-color') || hasParam('--color', 'false');
-const colorExplicitTrue = hasParam('--color', 'true');
-if (colorExplicitFalse || (!process.stdout.isTTY && !colorExplicitTrue)) {
-  colors.disable();
-}
-
-// These need to be set before Logger and other stuffs
-const pkg = require('../package.json');
-const updateNotifierModule = require('update-notifier');
-const isRunThroughPackagedBinary = process.pkg != null;
-const updateNotifierExplicitFalse = hasParam('--no-update-notifier') || hasParam('--update-notifier', 'false');
-if (!updateNotifierExplicitFalse && !isRunThroughPackagedBinary) {
-  updateNotifierModule({
-    pkg,
-    tagsUrl: 'https://api.github.com/repos/CleverCloud/clever-tools/tags',
-  }).notify({
-    isGlobal: true,
-    getDetails () {
-      const docsUrl = 'https://github.com/CleverCloud/clever-tools/tree/master/docs#how-to-use-clever-tools';
-      return `\nPlease follow this link to update your clever-tools:\n${docsUrl}`;
-    },
-  });
-}
-
-const cliparse = require('cliparse');
-const cliparseCommands = require('cliparse/src/command.js');
-const _sortBy = require('lodash/sortBy.js');
-
-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');
-const { AVAILABLE_ZONES } = require('../src/models/application.js');
-const { getOutputFormatOption, getSameCommitPolicyOption, getExitOnOption } = require('../src/command-options.js');
+// WARNING: this needs to run before other imports
+import '../src/initial-setup.js';
+
+import cliparse from 'cliparse';
+import cliparseCommands from 'cliparse/src/command.js';
+import _sortBy from 'lodash/sortBy.js';
+
+import { getPackageJson } from '../src/load-package-json.cjs';
+import * as git from '../src/models/git.js';
+import * as Parsers from '../src/parsers.js';
+import { handleCommandPromise } from '../src/command-promise-handler.js';
+import * as Application from '../src/models/application.js';
+import { AVAILABLE_ZONES } from '../src/models/application.js';
+import { getExitOnOption, getOutputFormatOption, getSameCommitPolicyOption } from '../src/command-options.js';
+
+import * as Addon from '../src/models/addon.js';
+import * as ApplicationConfiguration from '../src/models/application_configuration.js';
+import * as Drain from '../src/models/drain.js';
+import * as Notification from '../src/models/notification.js';
+import * as Namespaces from '../src/models/namespaces.js';
+
+import * as accesslogsModule from '../src/commands/accesslogs.js';
+import * as activity from '../src/commands/activity.js';
+import * as addon from '../src/commands/addon.js';
+import * as applications from '../src/commands/applications.js';
+import * as cancelDeploy from '../src/commands/cancel-deploy.js';
+import * as config from '../src/commands/config.js';
+import * as create from '../src/commands/create.js';
+import * as deleteCommandModule from '../src/commands/delete.js';
+import * as deploy from '../src/commands/deploy.js';
+import * as diag from '../src/commands/diag.js';
+import * as domain from '../src/commands/domain.js';
+import * as drain from '../src/commands/drain.js';
+import * as env from '../src/commands/env.js';
+import * as link from '../src/commands/link.js';
+import * as login from '../src/commands/login.js';
+import * as logout from '../src/commands/logout.js';
+import * as logs from '../src/commands/logs.js';
+import * as makeDefault from '../src/commands/makeDefault.js';
+import * as notifyEmail from '../src/commands/notify-email.js';
+import * as open from '../src/commands/open.js';
+import * as consoleModule from '../src/commands/console.js';
+import * as profile from '../src/commands/profile.js';
+import * as publishedConfig from '../src/commands/published-config.js';
+import * as restart from '../src/commands/restart.js';
+import * as scale from '../src/commands/scale.js';
+import * as service from '../src/commands/service.js';
+import * as ssh from '../src/commands/ssh.js';
+import * as status from '../src/commands/status.js';
+import * as stop from '../src/commands/stop.js';
+import * as tcpRedirs from '../src/commands/tcp-redirs.js';
+import * as unlink from '../src/commands/unlink.js';
+import * as version from '../src/commands/version.js';
+import * as webhooks from '../src/commands/webhooks.js';
+import * as database from '../src/commands/database.js';
+import { curl } from '../src/commands/curl.js';
 
 // Exit cleanly if the program we pipe to exits abruptly
 process.stdout.on('error', (error) => {
@@ -67,35 +64,15 @@ process.stdout.on('error', (error) => {
   }
 });
 
-// Use this alias so we get less warnings in pkg build :p
-const dynamicRequire = module.require.bind(module);
-
-function lazyRequirePromiseModule (modulePath) {
-  return function (name) {
-    return function (...args) {
-      const module = dynamicRequire(modulePath);
-      const promise = module[name](...args);
-      handleCommandPromise(promise);
-    };
-  };
-}
-
-function lazyRequire (modulePath) {
-  return function (name) {
-    return function (...args) {
-      const module = dynamicRequire(modulePath);
-      return module[name].apply(this, args);
-    };
-  };
-}
+// Patch cliparse.command so we can catch errors
+const cliparseCommand = cliparse.command;
 
-const Addon = lazyRequire('../src/models/addon.js');
-const Application = lazyRequire('../src/models/application.js');
-const ApplicationConfiguration = lazyRequire('../src/models/application_configuration.js');
-const Drain = lazyRequire('../src/models/drain.js');
-const Notification = lazyRequire('../src/models/notification.js');
-const NetworkGroup = lazyRequire('../src/models/networkgroup.js');
-const Namespaces = lazyRequire('../src/models/namespaces.js');
+cliparse.command = function (name, options, commandFunction) {
+  return cliparseCommand(name, options, (...args) => {
+    const promise = commandFunction(...args);
+    handleCommandPromise(promise);
+  });
+};
 
 function run () {
 
@@ -121,7 +98,7 @@ function run () {
     drainId: cliparse.argument('drain-id', { description: 'Drain ID' }),
     drainType: cliparse.argument('drain-type', {
       description: 'Drain type',
-      complete: Drain('listDrainTypes'),
+      complete: Drain.listDrainTypes,
     }),
     drainUrl: cliparse.argument('drain-url', { description: 'Drain URL' }),
     fqdn: cliparse.argument('fqdn', { description: 'Domain name of the application' }),
@@ -141,15 +118,10 @@ function run () {
     configurationName: cliparse.argument('configuration-name', {
       description: 'The name of the configuration to manage',
       complete () {
-        return cliparse.autocomplete.words(ApplicationConfiguration('listAvailableIds')());
+        return cliparse.autocomplete.words(ApplicationConfiguration.listAvailableIds());
       },
     }),
     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
@@ -158,10 +130,6 @@ function run () {
     logsFormat: getOutputFormatOption(['json-stream']),
     activityFormat: getOutputFormatOption(['json-stream']),
     envFormat: getOutputFormatOption(['shell']),
-    accesslogsFollow: cliparse.flag('follow', {
-      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)',
     }),
@@ -181,7 +149,17 @@ function run () {
       aliases: ['a'],
       metavar: 'alias',
       description: 'Short name for the application',
-      complete: Application('listAvailableAliases'),
+      complete: Application.listAvailableAliases,
+    }),
+    domain: cliparse.option('filter', {
+      default: '',
+      metavar: 'TEXT',
+      description: 'Check only domains containing the provided text',
+    }),
+    domainOverviewFilter: cliparse.option('filter', {
+      default: '',
+      metavar: 'TEXT',
+      description: 'Get only domains containing the provided text',
     }),
     naturalName: cliparse.flag('natural-name', {
       aliases: ['n'],
@@ -224,12 +202,12 @@ function run () {
       metavar: 'namespace',
       description: 'Namespace in which the TCP redirection should be',
       required: true,
-      complete: Namespaces('completeNamespaces'),
+      complete: Namespaces.completeNamespaces,
     }),
     notificationEventType: cliparse.option('event', {
       metavar: 'type',
       description: 'Restrict notifications to specific event types',
-      complete: Notification('listMetaEvents'),
+      complete: Notification.listMetaEvents,
       parser: Parsers.commaSeparated,
     }),
     flavor: cliparse.option('flavor', {
@@ -237,7 +215,7 @@ function run () {
       parser: Parsers.flavor,
       description: 'The instance size of your application',
       complete () {
-        return cliparse.autocomplete.words(Application('listAvailableFlavors')());
+        return cliparse.autocomplete.words(Application.listAvailableFlavors());
       },
     }),
     follow: cliparse.flag('follow', {
@@ -273,7 +251,7 @@ function run () {
       aliases: ['l'],
       metavar: 'alias',
       description: 'Link the created add-on to the app with the specified alias',
-      complete: Application('listAvailableAliases'),
+      complete: Application.listAvailableAliases,
     }),
     listAllNotifications: cliparse.flag('list-all', { description: 'List all notifications for your user or for an organisation with the \'--org\' option' }),
     maxFlavor: cliparse.option('max-flavor', {
@@ -281,7 +259,7 @@ function run () {
       parser: Parsers.flavor,
       description: 'The maximum instance size of your application',
       complete () {
-        return cliparse.autocomplete.words(Application('listAvailableFlavors')());
+        return cliparse.autocomplete.words(Application.listAvailableFlavors());
       },
     }),
     buildFlavor: cliparse.option('build-flavor', {
@@ -299,7 +277,7 @@ function run () {
       parser: Parsers.flavor,
       description: 'The minimum scale size of your application',
       complete () {
-        return cliparse.autocomplete.words(Application('listAvailableFlavors')());
+        return cliparse.autocomplete.words(Application.listAvailableFlavors());
       },
     }),
     minInstances: cliparse.option('min-instances', {
@@ -345,7 +323,7 @@ function run () {
       default: '',
       metavar: 'plan',
       description: 'Add-on plan, depends on the provider',
-      complete: Addon('completePlan'),
+      complete: Addon.completePlan,
     }),
     quiet: cliparse.flag('quiet', { aliases: ['q'], description: 'Don\'t show logs during deployment' }),
     followDeployLogs: cliparse.flag('follow', {
@@ -356,7 +334,7 @@ function run () {
       default: 'par',
       metavar: 'region',
       description: 'Region to provision the add-on in, depends on the provider',
-      complete: Addon('completeRegion'),
+      complete: Addon.completeRegion,
     }),
     addonVersion: cliparse.option('addon-version', {
       metavar: 'addon-version',
@@ -364,6 +342,7 @@ function run () {
     }),
     addonOptions: cliparse.option('option', {
       metavar: 'option',
+      parser: Parsers.addonOptions,
       description: 'Option to enable for the add-on. Multiple --option argument can be passed to enable multiple options',
     }),
     region: cliparse.option('region', {
@@ -371,7 +350,7 @@ function run () {
       default: 'par',
       metavar: 'zone',
       description: `Region, can be ${AVAILABLE_ZONES.map((name) => `'${name}'`).join(', ')}`,
-      complete: Application('listAvailableZones'),
+      complete: Application.listAvailableZones,
     }),
     search: cliparse.option('search', {
       metavar: 'search',
@@ -403,7 +382,7 @@ function run () {
       required: true,
       metavar: 'type',
       description: 'Instance type',
-      complete: Application('listAvailableTypes'),
+      complete: Application.listAvailableTypes,
     }),
     drainUsername: cliparse.option('username', {
       aliases: ['u'],
@@ -447,128 +426,6 @@ 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 (e.g.: ${Formatter.formatCode('app_xxx')}), add-on ID (e.g.: ${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' }),
     humanJsonOutputFormat: getOutputFormatOption(),
     tag: cliparse.option('tag', {
@@ -603,107 +460,100 @@ function run () {
   };
 
   // ACCESSLOGS COMMAND
-  const accesslogsModule = lazyRequirePromiseModule('../src/commands/accesslogs.js');
   const accesslogsCommand = cliparse.command('accesslogs', {
     description: 'Fetch access logs',
     options: [opts.alias, opts.appIdOrName, opts.logsFormat, opts.before, opts.after, opts.addonId],
-  }, accesslogsModule('accessLogs'));
+  }, accesslogsModule.accessLogs);
 
   // ACTIVITY COMMAND
-  const activity = lazyRequirePromiseModule('../src/commands/activity.js');
   const activityCommand = cliparse.command('activity', {
     description: 'Show last deployments of an application',
     options: [opts.alias, opts.appIdOrName, opts.follow, opts.showAllActivity, opts.activityFormat],
-  }, activity('activity'));
+  }, activity.activity);
 
   // ADDON COMMANDS
-  const addon = lazyRequirePromiseModule('../src/commands/addon.js');
   const addonCreateCommand = cliparse.command('create', {
     description: 'Create an add-on',
     args: [args.addonProvider, args.addonName],
     options: [opts.linkAddon, opts.confirmAddonCreation, opts.addonPlan, opts.addonRegion, opts.addonVersion, opts.addonOptions, opts.humanJsonOutputFormat],
-  }, addon('create'));
+  }, addon.create);
   const addonDeleteCommand = cliparse.command('delete', {
     description: 'Delete an add-on',
     args: [args.addonIdOrName],
     options: [opts.confirmAddonDeletion],
-  }, addon('delete'));
+  }, addon.deleteAddon);
   const addonRenameCommand = cliparse.command('rename', {
     description: 'Rename an add-on',
     args: [args.addonIdOrName, args.addonName],
-  }, addon('rename'));
+  }, addon.rename);
   const addonShowProviderCommand = cliparse.command('show', {
     description: 'Show information about an add-on provider',
     args: [args.addonProvider],
-  }, addon('showProvider'));
+  }, addon.showProvider);
   const addonProvidersCommand = cliparse.command('providers', {
     description: 'List available add-on providers',
     commands: [addonShowProviderCommand],
     options: [opts.humanJsonOutputFormat],
-  }, addon('listProviders'));
+  }, addon.listProviders);
   const addonEnvCommand = cliparse.command('env', {
     description: 'List environment variables for an add-on',
     options: [opts.envFormat],
     args: [opts.addonId],
-  }, addon('env'));
+  }, addon.env);
   const addonListCommand = cliparse.command('list', {
     description: 'List available add-ons',
     options: [opts.humanJsonOutputFormat],
-  }, addon('list'));
+  }, addon.list);
 
   const addonCommands = cliparse.command('addon', {
     description: 'Manage add-ons',
     options: [opts.orgaIdOrName],
     privateOptions: [opts.humanJsonOutputFormat],
     commands: [addonCreateCommand, addonDeleteCommand, addonRenameCommand, addonListCommand, addonProvidersCommand, addonEnvCommand],
-  }, addon('list'));
+  }, addon.list);
 
   // APPLICATIONS COMMAND
-  const applications = lazyRequirePromiseModule('../src/commands/applications.js');
   const applicationsListRemoteCommand = cliparse.command('list', {
     description: 'List all applications',
     options: [opts.orgaIdOrName, opts.humanJsonOutputFormat],
-  }, applications('listAll'));
+  }, applications.listAll);
   const applicationsCommand = cliparse.command('applications', {
     description: 'List linked applications',
     privateOptions: [opts.onlyAliases, opts.jsonFormat],
     commands: [applicationsListRemoteCommand],
-  }, applications('list'));
+  }, applications.list);
 
   // CANCEL DEPLOY COMMAND
-  const cancelDeploy = lazyRequirePromiseModule('../src/commands/cancel-deploy.js');
   const cancelDeployCommand = cliparse.command('cancel-deploy', {
     description: 'Cancel an ongoing deployment',
     options: [opts.alias, opts.appIdOrName],
-  }, cancelDeploy('cancelDeploy'));
+  }, cancelDeploy.cancelDeploy);
 
   // CONFIG COMMAND
-  const config = lazyRequirePromiseModule('../src/commands/config.js');
   const configGetCommand = cliparse.command('get', {
     description: 'Display the current configuration',
     args: [args.configurationName],
-  }, config('get'));
+  }, config.get);
   const configSetCommand = cliparse.command('set', {
     description: 'Edit one configuration setting',
     args: [args.configurationName, args.configurationValue],
-  }, config('set'));
+  }, config.set);
   const configUpdateCommand = cliparse.command('update', {
     description: 'Edit multiple configuration settings at once',
-    options: ApplicationConfiguration('getUpdateOptions')(),
-  }, config('update'));
+    options: ApplicationConfiguration.getUpdateOptions(),
+  }, config.update);
   const configCommands = cliparse.command('config', {
     description: 'Display or edit the configuration of your application',
     options: [opts.alias, opts.appIdOrName],
     commands: [configGetCommand, configSetCommand, configUpdateCommand],
-  }, config('get'));
+  }, config.get);
 
   // CREATE COMMAND
-  const create = lazyRequirePromiseModule('../src/commands/create.js');
   const appCreateCommand = cliparse.command('create', {
     description: 'Create an application',
     args: [args.appNameCreation],
     options: [opts.instanceType, opts.orgaIdOrName, opts.aliasCreation, opts.region, opts.github, opts.taskCommand, opts.humanJsonOutputFormat],
-  }, create('create'));
+  }, create.create);
 
   // CURL COMMAND
   // NOTE: it's just here for documentation purposes, look at the bottom of the file for the real "clever curl" command
@@ -712,401 +562,305 @@ function run () {
   }, () => null);
 
   // DELETE COMMAND
-  const deleteCommandModule = lazyRequirePromiseModule('../src/commands/delete.js');
   const deleteCommand = cliparse.command('delete', {
     description: 'Delete an application',
     options: [opts.alias, opts.appIdOrName, opts.confirmApplicationDeletion],
-  }, deleteCommandModule('deleteApp'));
+  }, deleteCommandModule.deleteApp);
 
   // DEPLOY COMMAND
-  const deploy = lazyRequirePromiseModule('../src/commands/deploy.js');
   const deployCommand = cliparse.command('deploy', {
     description: 'Deploy an application',
     options: [opts.alias, opts.branch, opts.gitTag, opts.quiet, opts.forceDeploy, opts.followDeployLogs, opts.sameCommitPolicy, opts.exitOnDeploy],
-  }, deploy('deploy'));
+  }, deploy.deploy);
 
   // DIAG COMMAND
-  const diag = lazyRequirePromiseModule('../src/commands/diag.js');
   const diagCommand = cliparse.command('diag', {
     description: 'Diagnose the current installation (prints various informations for support)',
     args: [],
     options: [opts.humanJsonOutputFormat],
-  }, diag('diag'));
+  }, diag.diag);
 
   // DOMAIN COMMANDS
-  const domain = lazyRequirePromiseModule('../src/commands/domain.js');
   const domainCreateCommand = cliparse.command('add', {
     description: 'Add a domain name to an application',
     args: [args.fqdn],
-  }, domain('add'));
+    options: [opts.alias, opts.appIdOrName],
+  }, domain.add);
   const domainRemoveCommand = cliparse.command('rm', {
     description: 'Remove a domain name from an application',
     args: [args.fqdn],
-  }, domain('rm'));
+    options: [opts.alias, opts.appIdOrName],
+  }, domain.rm);
   const domainSetFavouriteCommand = cliparse.command('set', {
     description: 'Set the favourite domain for an application',
     args: [args.fqdn],
-  }, domain('setFavourite'));
+  }, domain.setFavourite);
   const domainUnsetFavouriteCommand = cliparse.command('unset', {
     description: 'Unset the favourite domain for an application',
-  }, domain('unsetFavourite'));
+  }, domain.unsetFavourite);
   const domainFavouriteCommands = cliparse.command('favourite', {
     description: 'Manage the favourite domain name for an application',
+    options: [opts.alias, opts.appIdOrName],
     commands: [domainSetFavouriteCommand, domainUnsetFavouriteCommand],
-  }, domain('getFavourite'));
+  }, domain.getFavourite);
+  const domainDiagApplicationCommand = cliparse.command('diag', {
+    description: 'Check if domains associated to a specific app are properly configured',
+    options: [opts.alias, opts.appIdOrName, opts.humanJsonOutputFormat, opts.domain],
+  }, domain.diagApplication);
+  const domainOverviewCommand = cliparse.command('overview', {
+    description: 'Get an overview of all your domains (all orgas, all apps)',
+    options: [opts.humanJsonOutputFormat, opts.domainOverviewFilter],
+  }, domain.overview);
   const domainCommands = cliparse.command('domain', {
     description: 'Manage domain names for an application',
-    options: [opts.alias, opts.appIdOrName],
-    commands: [domainCreateCommand, domainFavouriteCommands, domainRemoveCommand],
-  }, domain('list'));
+    privateOptions: [opts.alias, opts.appIdOrName],
+    commands: [domainCreateCommand, domainFavouriteCommands, domainRemoveCommand, domainDiagApplicationCommand, domainOverviewCommand],
+  }, domain.list);
 
   // DRAIN COMMANDS
-  const drain = lazyRequirePromiseModule('../src/commands/drain.js');
   const drainCreateCommand = cliparse.command('create', {
     description: 'Create a drain',
     args: [args.drainType, args.drainUrl],
     options: [opts.drainUsername, opts.drainPassword, opts.drainAPIKey, opts.drainIndexPrefix, opts.drainSDParameters],
-  }, drain('create'));
+  }, drain.create);
   const drainRemoveCommand = cliparse.command('remove', {
     description: 'Remove a drain',
     args: [args.drainId],
-  }, drain('rm'));
+  }, drain.rm);
   const drainEnableCommand = cliparse.command('enable', {
     description: 'Enable a drain',
     args: [args.drainId],
-  }, drain('enable'));
+  }, drain.enable);
   const drainDisableCommand = cliparse.command('disable', {
     description: 'Disable a drain',
     args: [args.drainId],
-  }, drain('disable'));
+  }, drain.disable);
   const drainCommands = cliparse.command('drain', {
     description: 'Manage drains',
     options: [opts.alias, opts.appIdOrName, opts.addonId],
     privateOptions: [opts.humanJsonOutputFormat],
     commands: [drainCreateCommand, drainRemoveCommand, drainEnableCommand, drainDisableCommand],
-  }, drain('list'));
+  }, drain.list);
 
   // ENV COMMANDS
-  const env = lazyRequirePromiseModule('../src/commands/env.js');
   const envSetCommand = cliparse.command('set', {
     description: 'Add or update an environment variable named <variable-name> with the value <variable-value>',
     args: [args.envVariableName, args.envVariableValue],
-  }, env('set'));
+  }, env.set);
   const envRemoveCommand = cliparse.command('rm', {
     description: 'Remove an environment variable from an application',
     args: [args.envVariableName],
-  }, env('rm'));
+  }, env.rm);
   const envImportCommand = cliparse.command('import', {
     description: 'Load environment variables from STDIN\n(WARNING: this deletes all current variables and replace them with the new list loaded from STDIN)',
     options: [opts.importAsJson],
-  }, env('importEnv'));
+  }, env.importEnv);
   const envImportVarsFromLocalEnvCommand = cliparse.command('import-vars', {
     description: 'Add or update environment variables named <variable-names> (comma-separated), taking their values from the current environment',
     args: [args.envVariableNames],
-  }, env('importVarsFromLocalEnv'));
+  }, env.importVarsFromLocalEnv);
   const envCommands = cliparse.command('env', {
     description: 'Manage environment variables of an application',
     options: [opts.alias, opts.appIdOrName, opts.sourceableEnvVarsList],
     privateOptions: [opts.envFormat],
     commands: [envSetCommand, envRemoveCommand, envImportCommand, envImportVarsFromLocalEnvCommand],
-  }, env('list'));
+  }, env.list);
 
   // LINK COMMAND
-  const link = lazyRequirePromiseModule('../src/commands/link.js');
   const appLinkCommand = cliparse.command('link', {
     description: 'Link this repo to an existing application',
     args: [args.appIdOrName],
     options: [opts.aliasCreation, opts.orgaIdOrName],
-  }, link('link'));
+  }, link.link);
 
   // LOGIN COMMAND
-  const login = lazyRequirePromiseModule('../src/commands/login.js');
   const loginCommand = cliparse.command('login', {
     description: 'Login to Clever Cloud',
     options: [opts.loginToken, opts.loginSecret],
-  }, login('login'));
+  }, login.login);
 
   // LOGOUT COMMAND
-  const logout = lazyRequirePromiseModule('../src/commands/logout.js');
   const logoutCommand = cliparse.command('logout', {
     description: 'Logout from Clever Cloud',
-  }, logout('logout'));
+  }, logout.logout);
 
   // LOGS COMMAND
-  const logs = lazyRequirePromiseModule('../src/commands/logs.js');
   const logsCommand = cliparse.command('logs', {
     description: 'Fetch application logs, continuously',
     options: [opts.alias, opts.appIdOrName, opts.before, opts.after, opts.search, opts.deploymentId, opts.addonId, opts.logsFormat],
-  }, logs('appLogs'));
+  }, logs.appLogs);
 
   // MAKE DEFAULT COMMAND
-  const makeDefault = lazyRequirePromiseModule('../src/commands/makeDefault.js');
   const makeDefaultCommand = cliparse.command('make-default', {
     description: 'Make a linked application the default one',
     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\'s details',
-    options: [opts.ngIdOrLabel, opts.ngMemberId, opts.naturalName, opts.jsonFormat],
-  }, networkgroups('getMember'));
-  const networkGroupsMemberAddCommand = cliparse.command('add', {
-    description: 'Add an app or add-on 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 add-on 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\'s 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
-
-  // eslint-disable-next-line no-unused-vars
-  const networkGroupsCommand = cliparse.command('networkgroups', {
-    description: 'List Network Group commands',
-    options: [opts.orgaIdOrName, opts.alias],
-    commands: [networkGroupsListCommand, networkGroupsCreateCommand, networkGroupsDeleteCommand, networkGroupsMembersCategoryCommand, networkGroupsPeersCategoryCommand],
-  });
-  // eslint-disable-next-line no-unused-vars
-  const ngCommand = cliparse.command('ng', {
-    description: `Alias for ${Formatter.formatCommand('clever networkgroups')}`,
-    options: [opts.orgaIdOrName, opts.alias],
-    commands: [networkGroupsListCommand, networkGroupsCreateCommand, networkGroupsDeleteCommand, networkGroupsMembersCategoryCommand, networkGroupsPeersCategoryCommand],
-  });
+  }, makeDefault.makeDefault);
 
   // NOTIFY-EMAIL COMMAND
-  const notifyEmail = lazyRequirePromiseModule('../src/commands/notify-email.js');
   const addEmailNotificationCommand = cliparse.command('add', {
     description: 'Add a new email notification',
     options: [opts.notificationEventType, opts.notificationScope, opts.emailNotificationTarget],
     args: [args.notificationName],
-  }, notifyEmail('add'));
+  }, notifyEmail.add);
   const removeEmailNotificationCommand = cliparse.command('remove', {
     description: 'Remove an existing email notification',
     args: [args.notificationId],
-  }, notifyEmail('remove'));
+  }, notifyEmail.remove);
   const emailNotificationsCommand = cliparse.command('notify-email', {
     description: 'Manage email notifications',
     options: [opts.orgaIdOrName, opts.listAllNotifications],
     privateOptions: [opts.humanJsonOutputFormat],
     commands: [addEmailNotificationCommand, removeEmailNotificationCommand],
-  }, notifyEmail('list'));
+  }, notifyEmail.list);
 
   // OPEN COMMAND
-  const open = lazyRequirePromiseModule('../src/commands/open.js');
   const openCommand = cliparse.command('open', {
     description: 'Open an application in your browser',
     options: [opts.alias, opts.appIdOrName],
-  }, open('open'));
+  }, open.open);
 
   // CONSOLE COMMAND
-  const consoleModule = lazyRequirePromiseModule('../src/commands/console.js');
   const consoleCommand = cliparse.command('console', {
     description: 'Open an application in the Console',
     options: [opts.alias, opts.appIdOrName],
-  }, consoleModule('openConsole'));
+  }, consoleModule.openConsole);
 
   // PROFILE COMMAND
-  const profile = lazyRequirePromiseModule('../src/commands/profile.js');
   const profileCommand = cliparse.command('profile', {
     description: 'Display the profile of the current user',
     options: [opts.humanJsonOutputFormat],
-  }, profile('profile'));
+  }, profile.profile);
 
   // PUBLISHED CONFIG COMMANDS
-  const publishedConfig = lazyRequirePromiseModule('../src/commands/published-config.js');
   const publishedConfigSetCommand = cliparse.command('set', {
     description: 'Add or update a published configuration item named <variable-name> with the value <variable-value>',
     args: [args.envVariableName, args.envVariableValue],
-  }, publishedConfig('set'));
+  }, publishedConfig.set);
   const publishedConfigRemoveCommand = cliparse.command('rm', {
     description: 'Remove a published configuration variable from an application',
     args: [args.envVariableName],
-  }, publishedConfig('rm'));
+  }, publishedConfig.rm);
   const publishedConfigImportCommand = cliparse.command('import', {
     description: 'Load published configuration from STDIN\n(WARNING: this deletes all current variables and replace them with the new list loaded from STDIN)',
     options: [opts.importAsJson],
-  }, publishedConfig('importEnv'));
+  }, publishedConfig.importEnv);
   const publishedConfigCommands = cliparse.command('published-config', {
     description: 'Manage the configuration made available to other applications by this application',
     options: [opts.alias, opts.appIdOrName],
     privateOptions: [opts.envFormat],
     commands: [publishedConfigSetCommand, publishedConfigRemoveCommand, publishedConfigImportCommand],
-  }, publishedConfig('list'));
+  }, publishedConfig.list);
 
   // RESTART COMMAND
-  const restart = lazyRequirePromiseModule('../src/commands/restart.js');
   const restartCommand = cliparse.command('restart', {
     description: 'Start or restart an application',
     options: [opts.alias, opts.appIdOrName, opts.commit, opts.withoutCache, opts.quiet, opts.followDeployLogs, opts.exitOnDeploy],
-  }, restart('restart'));
+  }, restart.restart);
 
   // SCALE COMMAND
-  const scale = lazyRequirePromiseModule('../src/commands/scale.js');
   const scaleCommand = cliparse.command('scale', {
     description: 'Change scalability of an application',
     options: [opts.alias, opts.appIdOrName, opts.flavor, opts.minFlavor, opts.maxFlavor, opts.instances, opts.minInstances, opts.maxInstances, opts.buildFlavor],
-  }, scale('scale'));
+  }, scale.scale);
 
   // SERVICE COMMANDS
-  const service = lazyRequirePromiseModule('../src/commands/service.js');
   const serviceLinkAppCommand = cliparse.command('link-app', {
     description: 'Add an existing app as a dependency',
     args: [args.appIdOrName],
-  }, service('linkApp'));
+  }, service.linkApp);
   const serviceUnlinkAppCommand = cliparse.command('unlink-app', {
     description: 'Remove an app from the dependencies',
     args: [args.appIdOrName],
-  }, service('unlinkApp'));
+  }, service.unlinkApp);
   const serviceLinkAddonCommand = cliparse.command('link-addon', {
     description: 'Link an existing add-on to this application',
     args: [args.addonIdOrName],
-  }, service('linkAddon'));
+  }, service.linkAddon);
   const serviceUnlinkAddonCommand = cliparse.command('unlink-addon', {
     description: 'Unlink an add-on from this application',
     args: [args.addonIdOrName],
-  }, service('unlinkAddon'));
+  }, service.unlinkAddon);
   const serviceCommands = cliparse.command('service', {
     description: 'Manage service dependencies',
     options: [opts.alias, opts.appIdOrName, opts.onlyApps, opts.onlyAddons, opts.showAll],
     privateOptions: [opts.humanJsonOutputFormat],
     commands: [serviceLinkAppCommand, serviceUnlinkAppCommand, serviceLinkAddonCommand, serviceUnlinkAddonCommand],
-  }, service('list'));
+  }, service.list);
 
   // SSH COMMAND
-  const ssh = lazyRequirePromiseModule('../src/commands/ssh.js');
   const sshCommand = cliparse.command('ssh', {
     description: 'Connect to running instances through SSH',
     options: [opts.alias, opts.appIdOrName, opts.sshIdentityFile],
-  }, ssh('ssh'));
+  }, ssh.ssh);
 
   // STATUS COMMAND
-  const status = lazyRequirePromiseModule('../src/commands/status.js');
   const statusCommand = cliparse.command('status', {
     description: 'See the status of an application',
     options: [opts.alias, opts.appIdOrName, opts.humanJsonOutputFormat],
-  }, status('status'));
+  }, status.status);
 
   // STOP COMMAND
-  const stop = lazyRequirePromiseModule('../src/commands/stop.js');
   const stopCommand = cliparse.command('stop', {
     description: 'Stop a running application',
     options: [opts.alias, opts.appIdOrName],
-  }, stop('stop'));
+  }, stop.stop);
 
   // TCP-REDIRS COMMAND
-  const tcpRedirs = lazyRequirePromiseModule('../src/commands/tcp-redirs.js');
   const tcpRedirsListNamespacesCommand = cliparse.command('list-namespaces', {
     description: 'List the namespaces in which you can create new TCP redirections',
     options: [opts.humanJsonOutputFormat],
-  }, tcpRedirs('listNamespaces'));
+  }, tcpRedirs.listNamespaces);
   const tcpRedirsAddCommand = cliparse.command('add', {
     description: 'Add a new TCP redirection to the application',
     options: [opts.namespace, opts.confirmTcpRedirCreation],
-  }, tcpRedirs('add'));
+  }, tcpRedirs.add);
   const tcpRedirsRemoveCommand = cliparse.command('remove', {
     description: 'Remove a TCP redirection from the application',
     options: [opts.namespace],
     args: [args.port],
-  }, tcpRedirs('remove'));
+  }, tcpRedirs.remove);
   const tcpRedirsCommands = cliparse.command('tcp-redirs', {
     description: 'Control the TCP redirections from reverse proxies to your application',
     options: [opts.alias, opts.appIdOrName],
     privateOptions: [opts.humanJsonOutputFormat],
     commands: [tcpRedirsListNamespacesCommand, tcpRedirsAddCommand, tcpRedirsRemoveCommand],
-  }, tcpRedirs('list'));
+  }, tcpRedirs.list);
 
   // UNLINK COMMAND
-  const unlink = lazyRequirePromiseModule('../src/commands/unlink.js');
   const appUnlinkCommand = cliparse.command('unlink', {
     description: 'Unlink this repo from an existing application',
     args: [args.alias],
-  }, unlink('unlink'));
+  }, unlink.unlink);
 
   // VERSION COMMAND
-  const version = lazyRequirePromiseModule('../src/commands/version.js');
   const versionCommand = cliparse.command('version', {
     description: 'Display the clever-tools version',
     args: [],
-  }, version('version'));
+  }, version.version);
 
   // WEBHOOKS COMMAND
-  const webhooks = lazyRequirePromiseModule('../src/commands/webhooks.js');
   const addWebhookCommand = cliparse.command('add', {
     description: 'Register webhook to be called when events happen',
     options: [opts.webhookFormat, opts.notificationEventType, opts.notificationScope],
     args: [args.notificationName, args.webhookUrl],
-  }, webhooks('add'));
+  }, webhooks.add);
   const removeWebhookCommand = cliparse.command('remove', {
     description: 'Remove an existing webhook',
     args: [args.notificationId],
-  }, webhooks('remove'));
+  }, webhooks.remove);
   const webhooksCommand = cliparse.command('webhooks', {
     description: 'Manage webhooks',
     options: [opts.orgaIdOrName, opts.listAllNotifications],
     privateOptions: [opts.humanJsonOutputFormat],
     commands: [addWebhookCommand, removeWebhookCommand],
-  }, webhooks('list'));
+  }, webhooks.list);
 
   // DATABASES COMMANDS
-  const database = lazyRequirePromiseModule('../src/commands/database.js');
   const downloadBackupCommand = cliparse.command('download', {
     description: 'Download a database backup',
     args: [args.databaseId, args.backupId],
     options: [opts.output],
-  }, database('downloadBackups'));
+  }, database.downloadBackups);
   const backupsCommand = cliparse.command('backups', {
     description: 'List available database backups',
     args: [args.databaseId],
@@ -1114,11 +868,11 @@ function run () {
     commands: [
       downloadBackupCommand,
     ],
-  }, database('listBackups'));
+  }, database.listBackups);
   const databaseCommand = cliparse.command('database', {
     description: 'List available databases',
     commands: [backupsCommand],
-  }, () => {
+  }, async () => {
     console.info('This command is not available, you can try the following commands:');
     console.info('clever database backups');
     console.info('clever database backups download');
@@ -1151,9 +905,6 @@ function run () {
     logoutCommand,
     logsCommand,
     makeDefaultCommand,
-    // Not ready for stable release yet
-    // networkGroupsCommand,
-    // ngCommand,
     openCommand,
     consoleCommand,
     profileCommand,
@@ -1173,7 +924,7 @@ function run () {
   const cliParser = cliparse.cli({
     name: 'clever',
     description: 'CLI tool to manage Clever Cloud\'s data and products',
-    version: pkg.version,
+    version: getPackageJson().version,
     options: [opts.color, opts.updateNotifier, opts.verbose],
     helpCommand: false,
     commands,
@@ -1188,7 +939,7 @@ function run () {
 // Right now, this is the only way to do this properly
 // cliparse doesn't allow unknown options/arguments
 if (process.argv[2] === 'curl') {
-  require('../src/commands/curl.js').curl();
+  curl();
 }
 else {
   run();