clever-tools 3.12.0 → 3.13.0

package/bin/clever.js

@@ -36,24 +36,30 @@ 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';
@@ -129,6 +135,12 @@ async function run () {
       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,
@@ -172,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());
       },
@@ -182,6 +194,10 @@ 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',
@@ -508,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', {
@@ -632,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', {
@@ -728,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>',
@@ -774,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',
@@ -811,6 +918,88 @@ 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',
@@ -884,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',
@@ -962,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',
@@ -1084,6 +1352,7 @@ async function run () {
     domainCommands,
     drainCommands,
     emailNotificationsCommand,
+    emailsCommands,
     envCommands,
     featuresCommands,
     cliparseCommands.helpCommand,
@@ -1099,9 +1368,11 @@ async function run () {
     scaleCommand,
     serviceCommands,
     sshCommand,
+    sshKeysCommands,
     statusCommand,
     stopCommand,
     tcpRedirsCommands,
+    tokensCommands,
     versionCommand,
     webhooksCommand,
   ];
@@ -1109,12 +1380,15 @@ async function run () {
   // Add experimental features only if they are enabled through the configuration file
   const featuresFromConf = await getFeatures();
 
-  if (featuresFromConf.kv) {
-    commands.push(colorizeExperimentalCommand(kvRawCommand, 'kv'));
+  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.tokens) {
-    commands.push(colorizeExperimentalCommand(tokensCommands, 'tokens'));
+  if (featuresFromConf.kv) {
+    commands.push(colorizeExperimentalCommand(kvRawCommand, 'kv'));
   }
 
   if (featuresFromConf.ng) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clever-tools",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "description": "Command Line Interface for Clever Cloud.",
   "main": "bin/clever.js",
   "type": "module",

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

@@ -1,4 +1,4 @@
-export function createApiToken ({ email, password, mfaCode, name, description, expirationDate }) {
+export function createApiToken ({ email, password, mfaCode, name, description = '', expirationDate }) {
   return Promise.resolve({
     method: 'post',
     url: '/api-tokens',

package/src/clever-client/operators.js

@@ -0,0 +1,121 @@
+// TODO: Move this to the Clever Cloud JS Client
+
+/**
+ * GET /v4/addon-providers/addon-{provider}/addons/{realId}
+ * @param {Object} params
+ * @param {String} params.provider
+ * @param {String} params.realId
+ */
+export function getOperator (params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/addon-providers/addon-${params.provider}/addons/${params.realId}`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/addon-providers/addon-{provider}/addons/{realId}/reboot
+ * @param {Object} params
+ * @param {String} params.provider
+ * @param {String} params.realId
+ */
+export function rebootOperator (params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/addon-providers/addon-${params.provider}/addons/${params.realId}/reboot`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/addon-providers/addon-{provider}/addons/{realId}/rebuild
+ * @param {Object} params
+ * @param {String} params.provider
+ * @param {String} params.realId
+ */
+export function rebuildOperator (params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/addon-providers/addon-${params.provider}/addons/${params.realId}/rebuild`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/addon-providers/addon-{provider}/addons/{realId}/networkgroup
+ * @param {Object} params
+ * @param {String} params.provider
+ * @param {String} params.realId
+ */
+export function ngEnableOperator (params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/addon-providers/addon-${params.provider}/addons/${params.realId}/networkgroup`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/addon-providers/addon-{provider}/addons/{realId}/networkgroup
+ * @param {Object} params
+ * @param {String} params.provider
+ * @param {String} params.realId
+ */
+export function ngDisableOperator (params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'delete',
+    url: `/v4/addon-providers/addon-${params.provider}/addons/${params.realId}/networkgroup`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/addon-providers/addon-{provider}/addons/{realId}/version/check
+ * @param {Object} params
+ * @param {String} params.provider
+ * @param {String} params.realId
+ */
+export function versionCheck (params) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/addon-providers/addon-${params.provider}/addons/${params.realId}/version/check`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/addon-providers/addon-{provider}/addons/{realId}/version/update
+ * @param {Object} params
+ * @param {String} params.provider
+ * @param {String} params.realId
+ * @param {Object} body
+ */
+export function versionUpdate (params, body) {
+  // no multipath for /self or /organisations/{id}
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/addon-providers/addon-${params.provider}/addons/${params.realId}/version/update`,
+    headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+    // no queryParams
+    body,
+  });
+}

package/src/commands/addon.js

@@ -124,7 +124,7 @@ function displayAddon (format, addon, providerName, message) {
 
   const WIP_PROVIDERS = {
     keycloak: {
-      status: 'beta',
+      status: '',
       postCreateInstructions: dedent`
         Learn more about Keycloak on Clever Cloud: ${conf.DOC_URL}/addons/keycloak/,
       `,
@@ -139,19 +139,19 @@ function displayAddon (format, addon, providerName, message) {
       `,
     },
     'addon-matomo': {
-      status: 'beta',
+      status: '',
       postCreateInstructions: dedent`
         Learn more about Matomo on Clever Cloud: ${conf.DOC_URL}/addons/matomo/
       `,
     },
     metabase: {
-      status: 'beta',
+      status: '',
       postCreateInstructions: dedent`
         Learn more about Metabase on Clever Cloud: ${conf.DOC_URL}/addons/metabase/
       `,
     },
     otoroshi: {
-      status: 'beta',
+      status: '',
       postCreateInstructions: dedent`
         Learn more about Otoroshi with LLM on Clever Cloud: ${conf.DOC_URL}/addons/otoroshi/
       `,
@@ -166,7 +166,7 @@ function displayAddon (format, addon, providerName, message) {
 
   let providerNameToShow = '';
   let statusMessage = '';
-  if (providerName in WIP_PROVIDERS) {
+  if (providerName in WIP_PROVIDERS && WIP_PROVIDERS[providerName].status !== '') {
 
     providerNameToShow = providerName === 'kv'
       ? 'Materia KV'
@@ -207,11 +207,12 @@ function displayAddon (format, addon, providerName, message) {
         const provider = PROVIDERS_WITH_URL[providerName];
         const urlEnv = addon.env.find((entry) => entry.name === provider.urlEnv);
         const urlToShow = urlEnv.value;
+        const urlToShowWithHttps = urlToShow.startsWith('http') ? urlToShow : `https://${urlToShow}`;
 
         if (urlEnv) {
           Logger.println();
           Logger.println(`Your ${provider.name} is starting:`);
-          Logger.println(` - Access it: ${urlToShow.startsWith('http') ? urlToShow : `https://${urlToShow}`}`);
+          Logger.println(` - Access it: ${urlToShowWithHttps}`);
           Logger.println(` - Manage it: ${conf.GOTO_URL}/${addon.id}`);
         }
 
@@ -233,7 +234,11 @@ function displayAddon (format, addon, providerName, message) {
       if (providerName in WIP_PROVIDERS) {
 
         Logger.println();
-        Logger.println(colors.yellow(`/!\\ ${statusMessage}`));
+
+        if (statusMessage !== '') {
+          Logger.println(colors.yellow(`/!\\ ${statusMessage}`));
+        }
+
         Logger.println(WIP_PROVIDERS[providerName].postCreateInstructions);
       }
   }

package/src/commands/cancel-deploy.js

@@ -2,6 +2,7 @@ import * as Application from '../models/application.js';
 import { Logger } from '../logger.js';
 import { getAllDeployments, cancelDeployment } from '@clevercloud/client/esm/api/v2/application.js';
 import { sendToApi } from '../models/send-to-api.js';
+import colors from 'colors/safe.js';
 
 export async function cancelDeploy (params) {
   const { alias, app: appIdOrName } = params.options;
@@ -13,8 +14,6 @@ export async function cancelDeploy (params) {
     throw new Error('There is no ongoing deployment for this application');
   }
 
-  const deploymentId = deployments[0].id;
-  await cancelDeployment({ id: ownerId, appId, deploymentId }).then(sendToApi);
-
-  Logger.println('Deployment cancelled!');
+  await cancelDeployment({ id: ownerId, appId, deploymentId: deployments[0].id }).then(sendToApi);
+  Logger.printSuccess(`Deployment ${colors.bold.green(deployments[0].uuid)} successfully cancelled!`);
 };