clever-tools 3.11.0 → 3.13.0

package/bin/clever.js

@@ -16,7 +16,7 @@ import * as Application from '../src/models/application.js';
 import { AVAILABLE_ZONES } from '../src/models/application.js';
 import { EXPERIMENTAL_FEATURES } from '../src/experimental-features.js';
 import { getExitOnOption, getOutputFormatOption, getSameCommitPolicyOption } from '../src/command-options.js';
-import { getFeatures } from '../src/models/configuration.js';
+import { getFeatures, conf } from '../src/models/configuration.js';
 
 import * as Addon from '../src/models/addon.js';
 import * as ApplicationConfiguration from '../src/models/application_configuration.js';
@@ -36,26 +36,34 @@ 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 emails from '../src/commands/emails.js';
 import * as env from '../src/commands/env.js';
 import * as features from '../src/commands/features.js';
+import * as keycloak from '../src/commands/keycloak.js';
 import * as kv from '../src/commands/kv.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 matomo from '../src/commands/matomo.js';
+import * as metabase from '../src/commands/metabase.js';
 import * as makeDefault from '../src/commands/makeDefault.js';
+import * as ng from '../src/commands/ng.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 otoroshi from '../src/commands/otoroshi.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 sshKeys from '../src/commands/ssh-keys.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 tokens from '../src/commands/tokens.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';
@@ -94,6 +102,45 @@ async function run () {
     kvIdOrName: cliparse.argument('kv-id', {
       description: 'Add-on/Real ID (or name, if unambiguous) of a Materia KV or Redis® add-on',
     }),
+    apiTokenId: cliparse.argument('api-token-id', { description: 'API token ID' }),
+    apiTokenName: cliparse.argument('api-token-name', { description: 'API token name' }),
+    ngId: cliparse.argument('id', {
+      description: 'Network Group ID',
+      parser: Parsers.ngResourceType,
+    }),
+    ngLabel: cliparse.argument('ng-label', {
+      description: 'Network Group label',
+      parser: Parsers.ngResourceType,
+    }),
+    ngIdOrLabel: cliparse.argument('ng-id-or-label', {
+      description: 'Network Group ID or label',
+      parser: Parsers.ngResourceType,
+    }),
+    ngDescription: cliparse.argument('ng-description', {
+      description: 'Network Group description',
+    }),
+    ngExternalPeerLabel: cliparse.argument('external-peer-label', {
+      description: 'External peer label',
+      parser: Parsers.ngResourceType,
+    }),
+    ngExternalIdOrLabel: cliparse.argument('external-peer-id-or-label', {
+      description: 'External peer ID or label',
+      parser: Parsers.ngResourceType,
+    }),
+    ngAnyIdOrLabel: cliparse.argument('id-or-label', {
+      description: 'ID or Label of a Network group, a member or an (external) peer',
+      parser: Parsers.ngResourceType,
+    }),
+    wgPublicKey: cliparse.argument('public-key', {
+      metavar: 'public_key',
+      description: 'Wireguard public key of the external peer to link to a Network Group',
+    }),
+    email: cliparse.argument('email', {
+      description: 'Email address',
+      parser: Parsers.email,
+    }),
+    sshKeyName: cliparse.argument('ssh-key-name', { description: 'SSH key name' }),
+    sshKeyPath: cliparse.argument('ssh-key-path', { description: 'SSH public key path (.pub)' }),
     addonIdOrName: cliparse.argument('addon-id', {
       description: 'Add-on ID (or name, if unambiguous)',
       parser: Parsers.addonIdOrName,
@@ -137,7 +184,7 @@ async function run () {
       parser: Parsers.integer,
     }),
     configurationName: cliparse.argument('configuration-name', {
-      description: 'The name of the configuration to manage',
+      description: `Configuration to manage: ${ApplicationConfiguration.listAvailableIds(true)}`,
       complete () {
         return cliparse.autocomplete.words(ApplicationConfiguration.listAvailableIds());
       },
@@ -147,6 +194,40 @@ async function run () {
 
   // OPTIONS
   const opts = {
+    targetVersion: cliparse.option('target', {
+      metavar: 'version',
+      description: 'Target version to upgrade to (e.g.: 24, 2.4, 2.4.1)',
+    }),
+    apiTokenExpiration: cliparse.option('expiration', {
+      aliases: ['e'],
+      metavar: 'expiration',
+      parser: Parsers.futureDateOrDuration,
+      description: 'Duration until API token expiration (e.g.: 1h, 4d, 2w, 6M), default 1y',
+    }),
+    // Network Groups options
+    ngDescription: cliparse.option('description', {
+      metavar: 'description',
+      description: 'Network Group description',
+    }),
+    ngMembersIdsToLink: cliparse.option('link', {
+      metavar: 'members_ids',
+      description: "Comma separated list of members IDs to link to a Network Group ('app_xxx', 'addon_xxx', 'external_xxx')",
+      parser: Parsers.commaSeparated,
+    }),
+    ngMemberLabel: cliparse.option('label', {
+      required: false,
+      metavar: 'member_label',
+      description: 'The member label',
+      parser: Parsers.ngResourceType,
+    }),
+    ngPeerGetConfig: cliparse.flag('config', {
+      description: 'Get the Wireguard configuration of an external peer',
+    }),
+    ngResourceType: cliparse.option('type', {
+      metavar: 'type',
+      description: 'Type of resource to look for (NetworkGroup, Member, CleverPeer, ExternalPeer)',
+      parser: Parsers.ngValidType,
+    }),
     sourceableEnvVarsList: cliparse.flag('add-export', { description: 'Display sourceable env variables setting' }),
     logsFormat: getOutputFormatOption(['json-stream']),
     activityFormat: getOutputFormatOption(['json-stream']),
@@ -443,10 +524,18 @@ async function run () {
       aliases: ['y'],
       description: 'Skip confirmation and delete the application directly',
     }),
+    confirmSshKeyClean: cliparse.flag('yes', {
+      aliases: ['y'],
+      description: 'Skip confirmation and remove all SSH keys directly',
+    }),
     confirmTcpRedirCreation: cliparse.flag('yes', {
       aliases: ['y'],
       description: 'Skip confirmation even if the TCP redirection is not free',
     }),
+    yes: cliparse.flag('yes', {
+      aliases: ['y'],
+      description: 'Skip confirmation',
+    }),
     jsonFormat: cliparse.flag('json', { aliases: ['j'], description: 'Show result in JSON format' }),
     humanJsonOutputFormat: getOutputFormatOption(),
     tag: cliparse.option('tag', {
@@ -567,7 +656,7 @@ async function run () {
     description: 'Display or edit the configuration of your application',
     options: [opts.alias, opts.appIdOrName],
     commands: [configGetCommand, configSetCommand, configUpdateCommand],
-  }, config.get);
+  }, config.list);
 
   // CREATE COMMAND
   const appCreateCommand = cliparse.command('create', {
@@ -663,6 +752,32 @@ async function run () {
     commands: [drainCreateCommand, drainRemoveCommand, drainEnableCommand, drainDisableCommand],
   }, drain.list);
 
+  // EMAILS COMMANDS
+  const emailsAddCommand = cliparse.command('add', {
+    description: 'Add a new secondary email address to the current user',
+    args: [args.email],
+  }, emails.addSecondary);
+  const emailsPrimaryCommand = cliparse.command('primary', {
+    description: 'Set the primary email address of the current user',
+    args: [args.email],
+  }, emails.setPrimary);
+  const emailsRemoveCommand = cliparse.command('remove', {
+    description: 'Remove a secondary email address from the current user',
+    args: [args.email],
+  }, emails.removeSecondary);
+  const emailsClearCommand = cliparse.command('remove-all', {
+    description: 'Remove all secondary email addresses from the current user',
+    options: [opts.yes],
+  }, emails.removeAllSecondary);
+  const emailsOpenConsoleCommand = cliparse.command('open', {
+    description: 'Open the email addresses management page in the Console',
+  }, emails.openConsole);
+  const emailsCommands = cliparse.command('emails', {
+    description: 'Manage email addresses of the current user',
+    privateOptions: [opts.humanJsonOutputFormat],
+    commands: [emailsAddCommand, emailsPrimaryCommand, emailsRemoveCommand, emailsClearCommand, emailsOpenConsoleCommand],
+  }, emails.list);
+
   // ENV COMMANDS
   const envSetCommand = cliparse.command('set', {
     description: 'Add or update an environment variable named <variable-name> with the value <variable-value>',
@@ -709,6 +824,63 @@ async function run () {
     commands: [enableFeatureCommand, disableFeatureCommand, listFeaturesCommand, infoFeaturesCommand],
   }, features.list);
 
+  // KEYCLOAK COMMAND
+  const keycloakGetCommand = cliparse.command('get', {
+    description: 'Get information about a deployed Keycloak',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+  }, keycloak.get);
+  const keycloakEnableNgCommand = cliparse.command('enable-ng', {
+    description: 'Link Keycloak to a Network Group, used for multi-instances secure communication',
+    args: [args.addonIdOrName],
+  }, keycloak.ngEnable);
+  const keycloakDisableNgCommand = cliparse.command('disable-ng', {
+    description: 'Unlink Keycloak from its Network Group',
+    args: [args.addonIdOrName],
+  }, keycloak.ngDisable);
+  const keycloakOpenLogsCommand = cliparse.command('logs', {
+    description: 'Open the Keycloak application logs in Clever Cloud Console',
+    args: [args.addonIdOrName],
+  }, keycloak.openLogs);
+  const keycloakOpenWebUiCommand = cliparse.command('webui', {
+    description: 'Open the Keycloak admin console in your browser',
+    args: [args.addonIdOrName],
+  }, keycloak.openWebUi);
+  const keycloakOpenCommand = cliparse.command('open', {
+    description: 'Open the Keycloak dashboard in Clever Cloud Console',
+    args: [args.addonIdOrName],
+    commands: [keycloakOpenLogsCommand, keycloakOpenWebUiCommand],
+  }, keycloak.open);
+  const keycloakRestartCommand = cliparse.command('restart', {
+    description: 'Restart Keycloak',
+    args: [args.addonIdOrName],
+  }, keycloak.reboot);
+  const keycloakRebuildCommand = cliparse.command('rebuild', {
+    description: 'Rebuild Keycloak',
+    args: [args.addonIdOrName],
+  }, keycloak.rebuild);
+  const keycloakVersionCheckCommand = cliparse.command('check', {
+    description: 'Check Keycloak deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+  }, keycloak.checkVersion);
+  const keycloakVersionUpdateCommand = cliparse.command('update', {
+    description: 'Update Keycloak deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.targetVersion],
+  }, keycloak.updateVersion);
+  const keycloakVersionsCommands = cliparse.command('version', {
+    description: 'Check Keycloak deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+    commands: [keycloakVersionCheckCommand, keycloakVersionUpdateCommand],
+  }, keycloak.checkVersion);
+  const keycloakCommand = cliparse.command('keycloak', {
+    description: 'Manage Clever Cloud Keycloak services',
+    privateOptions: [opts.humanJsonOutputFormat],
+    commands: [keycloakGetCommand, keycloakEnableNgCommand, keycloakDisableNgCommand, keycloakOpenCommand, keycloakRestartCommand, keycloakRebuildCommand, keycloakVersionsCommands],
+  }, keycloak.list);
+
   // KV COMMAND
   const kvRawCommand = cliparse.command('kv', {
     description: 'Send a raw command to a Materia KV or Redis® add-on',
@@ -746,6 +918,138 @@ async function run () {
     args: [args.alias],
   }, makeDefault.makeDefault);
 
+  // MATOMO COMMAND
+  const matomoGetCommand = cliparse.command('get', {
+    description: 'Get information about a deployed Matomo',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+  }, matomo.get);
+  const matomoOpenLogsCommand = cliparse.command('logs', {
+    description: 'Open the Matomo application logs in Clever Cloud Console',
+    args: [args.addonIdOrName],
+  }, matomo.openLogs);
+  const matomoOpenWebUiCommand = cliparse.command('webui', {
+    description: 'Open the Matomo admin console in your browser',
+    args: [args.addonIdOrName],
+  }, matomo.openWebUi);
+  const matomoOpenCommand = cliparse.command('open', {
+    description: 'Open the Matomo dashboard in Clever Cloud Console',
+    args: [args.addonIdOrName],
+    commands: [matomoOpenLogsCommand, matomoOpenWebUiCommand],
+  }, matomo.open);
+  const matomoRestartCommand = cliparse.command('restart', {
+    description: 'Restart Matomo',
+    args: [args.addonIdOrName],
+  }, matomo.reboot);
+  const matomoRebuildCommand = cliparse.command('rebuild', {
+    description: 'Rebuild Matomo',
+    args: [args.addonIdOrName],
+  }, matomo.rebuild);
+  const matomoCommand = cliparse.command('matomo', {
+    description: 'Manage Clever Cloud Matomo services',
+    privateOptions: [opts.humanJsonOutputFormat],
+    commands: [matomoGetCommand, matomoOpenCommand, matomoRestartCommand, matomoRebuildCommand],
+  }, matomo.list);
+
+  // METABASE COMMAND
+  const metabaseGetCommand = cliparse.command('get', {
+    description: 'Get information about a deployed Metabase',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+  }, metabase.get);
+  const metabaseOpenLogsCommand = cliparse.command('logs', {
+    description: 'Open the Metabase application logs in Clever Cloud Console',
+    args: [args.addonIdOrName],
+  }, metabase.openLogs);
+  const metabaseOpenWebUiCommand = cliparse.command('webui', {
+    description: 'Open the Metabase admin console in your browser',
+    args: [args.addonIdOrName],
+  }, metabase.openWebUi);
+  const metabaseOpenCommand = cliparse.command('open', {
+    description: 'Open the Metabase dashboard in Clever Cloud Console',
+    args: [args.addonIdOrName],
+    commands: [metabaseOpenLogsCommand, metabaseOpenWebUiCommand],
+  }, metabase.open);
+  const metabaseRestartCommand = cliparse.command('restart', {
+    description: 'Restart Metabase',
+    args: [args.addonIdOrName],
+  }, metabase.reboot);
+  const metabaseRebuildCommand = cliparse.command('rebuild', {
+    description: 'Rebuild Metabase',
+    args: [args.addonIdOrName],
+  }, metabase.rebuild);
+  const metabaseVersionCheckCommand = cliparse.command('check', {
+    description: 'Check Metabase deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+  }, metabase.checkVersion);
+  const metabaseVersionUpdateCommand = cliparse.command('update', {
+    description: 'Update Metabase deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.targetVersion],
+  }, metabase.updateVersion);
+  const metabaseVersionsCommands = cliparse.command('version', {
+    description: 'Manage Metabase deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+    commands: [metabaseVersionCheckCommand, metabaseVersionUpdateCommand],
+  }, metabase.checkVersion);
+  const metabaseCommand = cliparse.command('metabase', {
+    description: 'Manage Clever Cloud Metabase services',
+    privateOptions: [opts.humanJsonOutputFormat],
+    commands: [metabaseGetCommand, metabaseOpenCommand, metabaseRestartCommand, metabaseRebuildCommand, metabaseVersionsCommands],
+  }, metabase.list);
+
+  // NETWORK GROUP COMMANDS
+  const ngCreateExternalPeerCommand = cliparse.command('external', {
+    description: 'Create an external peer in a Network Group',
+    args: [args.ngExternalPeerLabel, args.ngIdOrLabel, args.wgPublicKey],
+  }, ng.createExternalPeer);
+  const ngDeleteExternalPeerCommand = cliparse.command('external', {
+    description: 'Delete an external peer from a Network Group',
+    args: [args.ngExternalIdOrLabel, args.ngIdOrLabel],
+  }, ng.deleteExternalPeer);
+  const ngCreateCommand = cliparse.command('create', {
+    description: 'Create a Network Group',
+    args: [args.ngLabel],
+    privateOptions: [opts.ngMembersIdsToLink, opts.ngDescription, opts.optTags],
+    commands: [ngCreateExternalPeerCommand],
+  }, ng.createNg);
+  const ngDeleteCommand = cliparse.command('delete', {
+    description: 'Delete a Network Group',
+    args: [args.ngIdOrLabel],
+    commands: [ngDeleteExternalPeerCommand],
+  }, ng.deleteNg);
+  const ngLinkCommand = cliparse.command('link', {
+    description: 'Link an application or a database add-on by its ID to a Network Group',
+    args: [args.ngAnyIdOrLabel, args.ngIdOrLabel],
+  }, ng.linkToNg);
+  const ngUnlinkCommand = cliparse.command('unlink', {
+    description: 'Unlink an application or a database add-on by its ID from a Network Group',
+    args: [args.ngAnyIdOrLabel, args.ngIdOrLabel],
+  }, ng.unlinkFromNg);
+  const ngGetCommand = cliparse.command('get', {
+    description: 'Get details about a Network Group, a member or a peer',
+    args: [args.ngAnyIdOrLabel],
+    options: [opts.ngResourceType, opts.humanJsonOutputFormat],
+  }, ng.get);
+  const ngGetConfigCommand = cliparse.command('get-config', {
+    description: 'Get the Wireguard configuration of a peer in a Network Group',
+    args: [args.ngExternalIdOrLabel, args.ngIdOrLabel],
+    options: [opts.humanJsonOutputFormat],
+  }, ng.getPeerConfig);
+  const ngSearchCommand = cliparse.command('search', {
+    description: 'Search Network Groups, members or peers and get their details',
+    args: [args.ngAnyIdOrLabel],
+    options: [opts.ngResourceType, opts.humanJsonOutputFormat],
+  }, ng.search);
+  const networkGroupsCommand = cliparse.command('ng', {
+    description: 'List Network Groups',
+    options: [opts.orgaIdOrName],
+    privateOptions: [opts.humanJsonOutputFormat],
+    commands: [ngCreateCommand, ngDeleteCommand, ngLinkCommand, ngUnlinkCommand, ngGetCommand, ngGetConfigCommand, ngSearchCommand],
+  }, ng.listNg);
+
   // NOTIFY-EMAIL COMMAND
   const addEmailNotificationCommand = cliparse.command('add', {
     description: 'Add a new email notification',
@@ -769,6 +1073,63 @@ async function run () {
     options: [opts.alias, opts.appIdOrName],
   }, open.open);
 
+  // OTOROSHI COMMAND
+  const otoroshiGetCommand = cliparse.command('get', {
+    description: 'Get information about a deployed Otoroshi',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+  }, otoroshi.get);
+  const otoroshiEnableNgCommand = cliparse.command('enable-ng', {
+    description: 'Link Otoroshi to a Network Group',
+    args: [args.addonIdOrName],
+  }, otoroshi.ngEnable);
+  const otoroshiDisableNgCommand = cliparse.command('disable-ng', {
+    description: 'Unlink Otoroshi from its Network Group',
+    args: [args.addonIdOrName],
+  }, otoroshi.ngDisable);
+  const otoroshiOpenLogsCommand = cliparse.command('logs', {
+    description: 'Open the Otoroshi application logs in Clever Cloud Console',
+    args: [args.addonIdOrName],
+  }, otoroshi.openLogs);
+  const otoroshiOpenWebUiCommand = cliparse.command('webui', {
+    description: 'Open the Otoroshi admin console in your browser',
+    args: [args.addonIdOrName],
+  }, otoroshi.openWebUi);
+  const otoroshiOpenCommand = cliparse.command('open', {
+    description: 'Open the Otoroshi dashboard in Clever Cloud Console',
+    args: [args.addonIdOrName],
+    commands: [otoroshiOpenLogsCommand, otoroshiOpenWebUiCommand],
+  }, otoroshi.open);
+  const otoroshiRestartCommand = cliparse.command('restart', {
+    description: 'Restart Otoroshi',
+    args: [args.addonIdOrName],
+  }, otoroshi.reboot);
+  const otoroshiRebuildCommand = cliparse.command('rebuild', {
+    description: 'Rebuild Otoroshi',
+    args: [args.addonIdOrName],
+  }, otoroshi.rebuild);
+  const otoroshiVersionCheckCommand = cliparse.command('check', {
+    description: 'Check Otoroshi deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+  }, otoroshi.checkVersion);
+  const otoroshiVersionUpdateCommand = cliparse.command('update', {
+    description: 'Update Otoroshi deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.targetVersion],
+  }, otoroshi.updateVersion);
+  const otoroshiVersionsCommands = cliparse.command('version', {
+    description: 'Manage Otoroshi deployed version',
+    args: [args.addonIdOrName],
+    options: [opts.humanJsonOutputFormat],
+    commands: [otoroshiVersionCheckCommand, otoroshiVersionUpdateCommand],
+  }, otoroshi.checkVersion);
+  const otoroshiCommand = cliparse.command('otoroshi', {
+    description: 'Manage Clever Cloud Otoroshi services',
+    privateOptions: [opts.humanJsonOutputFormat],
+    commands: [otoroshiGetCommand, otoroshiEnableNgCommand, otoroshiDisableNgCommand, otoroshiOpenCommand, otoroshiRestartCommand, otoroshiRebuildCommand, otoroshiVersionsCommands],
+  }, otoroshi.list);
+
   // CONSOLE COMMAND
   const consoleCommand = cliparse.command('console', {
     description: 'Open an application in the Console',
@@ -847,6 +1208,28 @@ async function run () {
     options: [opts.alias, opts.appIdOrName, opts.sshIdentityFile],
   }, ssh.ssh);
 
+  // SSH KEYS COMMANDS
+  const sshKeysAddCommand = cliparse.command('add', {
+    description: 'Add a new SSH key to the current user',
+    args: [args.sshKeyName, args.sshKeyPath],
+  }, sshKeys.add);
+  const sshKeysRemoveCommand = cliparse.command('remove', {
+    description: 'Remove a SSH key from the current user',
+    args: [args.sshKeyName],
+  }, sshKeys.remove);
+  const sshKeysRemoveAllCommand = cliparse.command('remove-all', {
+    description: 'Remove all SSH keys from the current user',
+    options: [opts.confirmSshKeyClean],
+  }, sshKeys.removeAll);
+  const sshKeysOpenConsoleCommand = cliparse.command('open', {
+    description: 'Open the SSH keys management page in the Console',
+  }, sshKeys.openConsole);
+  const sshKeysCommands = cliparse.command('ssh-keys', {
+    description: 'Manage SSH keys of the current user',
+    privateOptions: [opts.humanJsonOutputFormat],
+    commands: [sshKeysAddCommand, sshKeysRemoveCommand, sshKeysRemoveAllCommand, sshKeysOpenConsoleCommand],
+  }, sshKeys.list);
+
   // STATUS COMMAND
   const statusCommand = cliparse.command('status', {
     description: 'See the status of an application',
@@ -880,6 +1263,22 @@ async function run () {
     commands: [tcpRedirsListNamespacesCommand, tcpRedirsAddCommand, tcpRedirsRemoveCommand],
   }, tcpRedirs.list);
 
+  // TOKENS COMMANDS
+  const apiTokenCreateCommand = cliparse.command('create', {
+    description: 'Create an API token',
+    args: [args.apiTokenName],
+    options: [opts.apiTokenExpiration, opts.humanJsonOutputFormat],
+  }, tokens.create);
+  const apiTokenRevokeCommand = cliparse.command('revoke', {
+    description: 'Revoke an API token',
+    args: [args.apiTokenId],
+  }, tokens.revoke);
+  const tokensCommands = cliparse.command('tokens', {
+    description: `Manage API tokens to query Clever Cloud API from ${conf.AUTH_BRIDGE_HOST}`,
+    commands: [apiTokenCreateCommand, apiTokenRevokeCommand],
+    privateOptions: [opts.humanJsonOutputFormat],
+  }, tokens.list);
+
   // UNLINK COMMAND
   const appUnlinkCommand = cliparse.command('unlink', {
     description: 'Unlink this repo from an existing application',
@@ -953,6 +1352,7 @@ async function run () {
     domainCommands,
     drainCommands,
     emailNotificationsCommand,
+    emailsCommands,
     envCommands,
     featuresCommands,
     cliparseCommands.helpCommand,
@@ -968,9 +1368,11 @@ async function run () {
     scaleCommand,
     serviceCommands,
     sshCommand,
+    sshKeysCommands,
     statusCommand,
     stopCommand,
     tcpRedirsCommands,
+    tokensCommands,
     versionCommand,
     webhooksCommand,
   ];
@@ -978,10 +1380,21 @@ async function run () {
   // Add experimental features only if they are enabled through the configuration file
   const featuresFromConf = await getFeatures();
 
+  if (featuresFromConf.operators) {
+    commands.push(colorizeExperimentalCommand(keycloakCommand, 'operators'));
+    commands.push(colorizeExperimentalCommand(matomoCommand, 'operators'));
+    commands.push(colorizeExperimentalCommand(metabaseCommand, 'operators'));
+    commands.push(colorizeExperimentalCommand(otoroshiCommand, 'operators'));
+  }
+
   if (featuresFromConf.kv) {
     commands.push(colorizeExperimentalCommand(kvRawCommand, 'kv'));
   }
 
+  if (featuresFromConf.ng) {
+    commands.push(colorizeExperimentalCommand(networkGroupsCommand, 'ng'));
+  }
+
   // CLI PARSER
   const cliParser = cliparse.cli({
     name: 'clever',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clever-tools",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "description": "Command Line Interface for Clever Cloud.",
   "main": "bin/clever.js",
   "type": "module",
@@ -26,12 +26,13 @@
     "scripts/*.sh"
   ],
   "dependencies": {
-    "@clevercloud/client": "9.1.0",
+    "@clevercloud/client": "9.2.0",
+    "@inquirer/prompts": "7.3.2",
     "cliparse": "0.5.0",
     "colors": "1.4.0",
     "common-env": "6.4.0",
     "curlconverter": "3.21.0",
-    "duration-js": "4.0.0",
+    "dedent": "1.5.3",
     "eventsource": "1.1.0",
     "ioredis": "5.4.1",
     "iso8601-duration": "2.1.2",

package/src/clever-client/auth-bridge.js

@@ -0,0 +1,61 @@
+export function createApiToken ({ email, password, mfaCode, name, description = '', expirationDate }) {
+  return Promise.resolve({
+    method: 'post',
+    url: '/api-tokens',
+    headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+    body: { email, password, mfaCode, name, description, expirationDate },
+  });
+}
+
+export function listApiTokens () {
+  return Promise.resolve({
+    method: 'get',
+    url: '/api-tokens',
+    headers: { Accept: 'application/json' },
+  });
+}
+
+export function updateApiToken (apiTokenId, { name, description }) {
+  return Promise.resolve({
+    method: 'put',
+    url: `/api-tokens/${apiTokenId}`,
+    headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+    body: { name, description },
+  });
+}
+
+export function deleteApiToken (apiTokenId) {
+  return Promise.resolve({
+    method: 'delete',
+    url: `/api-tokens/${apiTokenId}`,
+    headers: { Accept: 'application/json' },
+  });
+}
+
+export function addOauthHeaderPlaintext (tokens) {
+
+  return async function (requestParams) {
+
+    const authorizationHeader = (
+      'OAuth '
+      + [
+        `oauth_consumer_key="${tokens.OAUTH_CONSUMER_KEY}"`,
+        `oauth_token="${tokens.API_OAUTH_TOKEN}"`,
+        // %26 is URL escaped character "&"
+        `oauth_signature="${tokens.OAUTH_CONSUMER_SECRET}%26${tokens.API_OAUTH_TOKEN_SECRET}"`,
+        // oauth_nonce is not mandatory
+        // oauth_signature_method is not mandatory, it defaults to PLAINTEXT
+        // oauth_timestamp is not mandatory
+        // oauth_version is not mandatory, it defaults to 1.0
+      ].join(', ')
+    );
+
+    return {
+      ...requestParams,
+      headers: {
+        authorization: authorizationHeader,
+        ...requestParams.headers,
+      },
+    };
+  };
+}

package/src/clever-client/ng.js

@@ -0,0 +1,18 @@
+// TODO: Move this to the Clever Cloud JS Client
+
+/**
+ * GET /networkgroups/organisations/{ownerId}/networkgroups/search?query
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.query
+ */
+export function searchNetworkGroupOrResource (params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/networkgroups/organisations/${params.ownerId}/networkgroups/search`,
+    headers: { Accept: 'application/json' },
+    queryParams: { query: params.query },
+    // no body
+  });
+}