clever-tools 4.5.1 → 4.6.0

package/README.md

@@ -154,6 +154,16 @@ clever <command> --help        # Get specific help
 clever --format json <command> # JSON output for scripting
 ```
 
+## AI Agent Integration
+
+Clever Tools can be used with AI coding assistants (Claude Code, Cursor, Codex, GitHub Copilot, etc.):
+
+```bash
+npx add-skill CleverCloud/clever-tools
+```
+
+This installs the Clever Tools skill, giving your AI assistant knowledge of all commands and Clever Cloud concepts.
+
 ## Support & Contributing
 
 - **Issues & Questions**: [GitHub Issues](https://github.com/CleverCloud/clever-tools/issues)

package/bin/clever.js

@@ -14,11 +14,10 @@ import {
   verboseOption,
   versionOption,
 } from '../src/commands/global.options.js';
-import { EXPERIMENTAL_FEATURES } from '../src/experimental-features.js';
+import { EXPERIMENTAL_FEATURES, getFeatures } from '../src/config/features.js';
 import { cliparse } from '../src/lib/cliparse-patched.js';
 import { styleText } from '../src/lib/style-text.js';
 import { getDefault, isBoolean, isRequired } from '../src/lib/zod-utils.js';
-import { getFeatures } from '../src/models/configuration.js';
 
 /**
  * @typedef {import('../src/lib/define-command.types.js').CommandDefinition} CommandDefinition
@@ -150,25 +149,25 @@ function buildCommand(name, commandEntry, featuresFromConf) {
  * @returns {Object} cliparse command
  */
 function convertCommand(name, commandDef, subcommands = []) {
-  const config = {
+  const cliparseConfig = {
     description: commandDef.description,
   };
 
   if (commandDef.options != null) {
-    config.privateOptions = Object.values(commandDef.options).map(convertOption);
+    cliparseConfig.privateOptions = Object.values(commandDef.options).map(convertOption);
   }
 
   // Convert arguments
   if (commandDef.args != null && commandDef.args.length > 0) {
-    config.args = commandDef.args.map(convertArgument);
+    cliparseConfig.args = commandDef.args.map(convertArgument);
   }
 
   // Add subcommands
   if (subcommands.length > 0) {
-    config.commands = subcommands;
+    cliparseConfig.commands = subcommands;
   }
 
-  const command = cliparse.command(name, config, commandDef.handler);
+  const command = cliparse.command(name, cliparseConfig, commandDef.handler);
 
   // Attach the original definition so cliparse-patched.js can use it for --help display
   command._definition = commandDef;
@@ -182,26 +181,28 @@ function convertCommand(name, commandDef, subcommands = []) {
  * @returns {Object} cliparse option
  */
 function convertOption(option) {
-  const config = {
+  const cliparseConfig = {
     description: option.description,
   };
 
   if (option.aliases != null) {
-    config.aliases = option.aliases;
+    cliparseConfig.aliases = option.aliases;
   }
   const optionDefault = getDefault(option.schema);
   if (optionDefault != null) {
-    config.default = optionDefault;
+    // Parse the default value through the schema to apply transforms
+    const parsed = option.schema.safeParse(optionDefault);
+    cliparseConfig.default = parsed.success ? parsed.data : optionDefault;
   }
   if (option.placeholder != null) {
-    config.metavar = option.placeholder;
+    cliparseConfig.metavar = option.placeholder;
   }
   if (option.complete != null) {
-    config.complete = option.complete;
+    cliparseConfig.complete = option.complete;
   }
 
   // Use Zod's safeParse for validation (handles coercion, enums, refinements, etc.)
-  config.parser = (value) => {
+  cliparseConfig.parser = (value) => {
     // Log deprecation warning if option is deprecated
     if (option.deprecated) {
       const message = typeof option.deprecated === 'string' ? `, ${option.deprecated}.` : '';
@@ -217,16 +218,16 @@ function convertOption(option) {
 
   // Mark as required if schema has no default and is not optional
   if (isRequired(option.schema)) {
-    config.required = true;
+    cliparseConfig.required = true;
   }
 
   // Boolean schemas: use cliparse.option with expects_value: false (like cliparse.flag does)
   if (isBoolean(option.schema)) {
     // eslint-disable-next-line camelcase -- cliparse API uses snake_case
-    config.expects_value = false;
+    cliparseConfig.expects_value = false;
   }
 
-  return cliparse.option(option.name, config);
+  return cliparse.option(option.name, cliparseConfig);
 }
 
 /**
@@ -235,16 +236,16 @@ function convertOption(option) {
  * @returns {Object} cliparse argument
  */
 function convertArgument(arg) {
-  const config = {
+  const cliparseConfig = {
     description: arg.description,
   };
 
   if (arg.complete) {
-    config.complete = arg.complete;
+    cliparseConfig.complete = arg.complete;
   }
 
   // Use Zod's safeParse for validation (handles coercion, enums, refinements, etc.)
-  config.parser = (value) => {
+  cliparseConfig.parser = (value) => {
     const result = arg.schema.safeParse(value);
     if (!result.success) {
       throw new Error(result.error.issues.map((i) => i.message).join(', '));
@@ -254,10 +255,12 @@ function convertArgument(arg) {
 
   const argDefault = getDefault(arg.schema);
   if (argDefault != null) {
-    config.default = argDefault;
+    // Parse the default value through the schema to apply transforms
+    const parsed = arg.schema.safeParse(argDefault);
+    cliparseConfig.default = parsed.success ? parsed.data : argDefault;
   } else if (!isRequired(arg.schema)) {
-    config.default = '';
+    cliparseConfig.default = '';
   }
 
-  return cliparse.argument(arg.placeholder, config);
+  return cliparse.argument(arg.placeholder, cliparseConfig);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clever-tools",
-  "version": "4.5.1",
+  "version": "4.6.0",
   "description": "Command Line Interface for Clever Cloud.",
   "keywords": [
     "cli",
@@ -63,6 +63,7 @@
     "lodash": "4.17.21",
     "open": "10.2.0",
     "semver": "7.7.3",
+    "simple-git": "3.30.0",
     "slugify": "1.6.6",
     "tldts": "7.0.19",
     "update-notifier": "7.3.1",
@@ -89,7 +90,6 @@
     "remark-parse": "11.0.0",
     "remark-stringify": "11.0.0",
     "rollup": "4.53.3",
-    "simple-git": "3.30.0",
     "tinyglobby": "0.2.15",
     "typescript": "5.9.3",
     "unified": "11.0.5"

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

@@ -22,28 +22,3 @@ export function deleteApiToken(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/commands/README.md

@@ -22,6 +22,7 @@ These options are available for all commands:
 |[`clever applications`](./applications/applications.docs.md)|List linked applications|
 |[`clever cancel-deploy`](./cancel-deploy/cancel-deploy.docs.md)|Cancel an ongoing deployment|
 |[`clever config`](./config/config.docs.md)|Display or edit the configuration of your application|
+|[`clever config-provider`](./config-provider/config-provider.docs.md)|Manage configuration providers|
 |[`clever console`](./console/console.docs.md)|Open an application in the Console|
 |[`clever create`](./create/create.docs.md)|Create an application|
 |[`clever curl`](./curl/curl.docs.md)|Query Clever Cloud's API using Clever Tools credentials|

package/src/commands/accesslogs/accesslogs.command.js

@@ -145,7 +145,10 @@ export const accesslogsCommand = defineCommand({
       });
 
     // Properly close the stream
-    process.once('SIGINT', (signal) => stream.close(signal));
+    process.once('SIGINT', (signal) => {
+      stream.close(signal);
+      process.kill(process.pid, 'SIGINT');
+    });
 
     const closeReason = await stream.start();
 

package/src/commands/accesslogs/accesslogs.docs.md

@@ -12,7 +12,7 @@ clever accesslogs [options]
 
 |Name|Description|
 |---|---|
-|`--addon` `<addon-id>`|Add-on ID|
+|`--addon` `<addon-id>`|Add-on ID or real ID|
 |`--after`, `--since` `<after>`|Fetch logs after this date/time (ISO8601 date, positive number in seconds or duration, e.g.: 1h)|
 |`-a`, `--alias` `<alias>`|Short name for the application|
 |`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|

package/src/commands/addon/addon.create.command.js

@@ -1,6 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { getOperator } from '../../clever-client/operators.js';
+import { config } from '../../config/config.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { defineOption } from '../../lib/define-option.js';
 import { styleText } from '../../lib/style-text.js';
@@ -9,7 +10,6 @@ import * as Addon from '../../models/addon.js';
 import { completePlan, completeRegion, parseAddonOptions } from '../../models/addon.js';
 import * as AppConfig from '../../models/app_configuration.js';
 import { listAvailableAliases } from '../../models/application.js';
-import { conf } from '../../models/configuration.js';
 import * as Organisation from '../../models/organisation.js';
 import { sendToApi } from '../../models/send-to-api.js';
 import * as User from '../../models/user.js';
@@ -20,39 +20,37 @@ import { addonNameArg, addonProviderArg } from './addon.args.js';
 const ADDON_PROVIDERS = {
   keycloak: {
     name: 'Keycloak',
-    isOperator: true,
-    postCreateInstructions: `Learn more about Keycloak on Clever Cloud: ${conf.DOC_URL}/addons/keycloak/`,
+    operatorProvider: 'keycloak',
+    postCreateInstructions: `Learn more about Keycloak on Clever Cloud: ${config.DOC_URL}/addons/keycloak/`,
   },
   kv: {
     name: 'Materia KV',
-    isOperator: false,
     status: 'beta',
     postCreateInstructions: (addonId) => dedent`
       ${styleText('yellow', "You can easily use Materia KV with 'redis-cli', with such commands:")}
       ${styleText('blue', `source <(clever addon env ${addonId} -F shell)`)}
       ${styleText('blue', 'redis-cli -h $KV_HOST -p $KV_PORT --tls')}
-      Learn more about Materia KV on Clever Cloud: ${conf.DOC_URL}/addons/materia-kv/
+      Learn more about Materia KV on Clever Cloud: ${config.DOC_URL}/addons/materia-kv/
     `,
   },
   'addon-matomo': {
     name: 'Matomo',
-    isOperator: true,
-    postCreateInstructions: `Learn more about Matomo on Clever Cloud: ${conf.DOC_URL}/addons/matomo/`,
+    operatorProvider: 'matomo',
+    postCreateInstructions: `Learn more about Matomo on Clever Cloud: ${config.DOC_URL}/addons/matomo/`,
   },
   metabase: {
     name: 'Metabase',
-    isOperator: true,
-    postCreateInstructions: `Learn more about Metabase on Clever Cloud: ${conf.DOC_URL}/addons/metabase/`,
+    operatorProvider: 'metabase',
+    postCreateInstructions: `Learn more about Metabase on Clever Cloud: ${config.DOC_URL}/addons/metabase/`,
   },
   otoroshi: {
     name: 'Otoroshi with LLM',
-    isOperator: true,
-    postCreateInstructions: `Learn more about Otoroshi with LLM on Clever Cloud: ${conf.DOC_URL}/addons/otoroshi/`,
+    operatorProvider: 'otoroshi',
+    postCreateInstructions: `Learn more about Otoroshi with LLM on Clever Cloud: ${config.DOC_URL}/addons/otoroshi/`,
   },
   'addon-pulsar': {
     name: 'Pulsar',
-    isOperator: false,
-    postCreateInstructions: `Learn more about Pulsar on Clever Cloud: ${conf.DOC_URL}/addons/pulsar/`,
+    postCreateInstructions: `Learn more about Pulsar on Clever Cloud: ${config.DOC_URL}/addons/pulsar/`,
   },
 };
 
@@ -90,7 +88,7 @@ export const addonCreateCommand = defineCommand({
       placeholder: 'region',
       complete: completeRegion,
     }),
-    version: defineOption({
+    addonVersion: defineOption({
       name: 'addon-version',
       schema: z.string().optional(),
       description: 'The version to use for the add-on',
@@ -98,7 +96,10 @@ export const addonCreateCommand = defineCommand({
     }),
     option: defineOption({
       name: 'option',
-      schema: z.string().transform(addonOptions).optional(),
+      schema: z
+        .union([z.string(), z.array(z.string())])
+        .transform(addonOptions)
+        .optional(),
       description:
         'Option to enable for the add-on. Multiple --option argument can be passed to enable multiple options',
       placeholder: 'option',
@@ -115,7 +116,7 @@ export const addonCreateCommand = defineCommand({
       yes: skipConfirmation,
       org: orgaIdOrName,
       format,
-      version,
+      addonVersion,
       option: addonOptions,
     } = options;
 
@@ -125,7 +126,7 @@ export const addonCreateCommand = defineCommand({
       planName,
       region,
       skipConfirmation,
-      version: version,
+      version: addonVersion,
       addonOptions: parseAddonOptions(addonOptions),
     };
 
@@ -187,16 +188,18 @@ export const addonCreateCommand = defineCommand({
     Logger.println(`Real ID: ${newAddon.realId}`);
     Logger.println(`Name: ${newAddon.name}`);
 
-    const operator = ADDON_PROVIDERS[providerName]?.isOperator
-      ? await getOperator({ provider: providerName, realId: newAddon.realId }).then(sendToApi)
-      : null;
+    const operatorProvider = ADDON_PROVIDERS[providerName]?.operatorProvider;
+    const operator =
+      operatorProvider != null
+        ? await getOperator({ provider: operatorProvider, realId: newAddon.realId }).then(sendToApi)
+        : null;
 
-    if (operator) {
-      if (operator.accessUrl) {
+    if (operator != null) {
+      if (operator.accessUrl != null) {
         Logger.println();
         Logger.println(`Your ${ADDON_PROVIDERS[providerName].name} is starting:`);
         Logger.println(` - Access it: ${operator.accessUrl}`);
-        Logger.println(` - Manage it: ${conf.GOTO_URL}/${newAddon.id}`);
+        Logger.println(` - Manage it: ${config.GOTO_URL}/${newAddon.id}`);
       }
 
       if (operator.initialCredentials) {

package/src/commands/config/config.set.command.js

@@ -26,13 +26,13 @@ export const configSetCommand = defineCommand({
   async handler(options, configurationName, configurationValue) {
     const { alias, app: appIdOrName } = options;
     const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-    const config = ApplicationConfiguration.getById(configurationName);
+    const appConfig = ApplicationConfiguration.getById(configurationName);
     const newOptions = {
-      [config.name]: ApplicationConfiguration.parse(config, configurationValue),
+      [appConfig.name]: ApplicationConfiguration.parse(appConfig, configurationValue),
     };
     const app = await Application.updateOptions(ownerId, appId, newOptions);
     Logger.printSuccess(
-      `Config ${styleText('green', config.id)} successfully updated to ${styleText('green', ApplicationConfiguration.formatValue(config, app[config.name]).toString())}!`,
+      `Config ${styleText('green', appConfig.id)} successfully updated to ${styleText('green', ApplicationConfiguration.formatValue(appConfig, app[appConfig.name]).toString())}!`,
     );
   },
 });

package/src/commands/config-provider/config-provider.args.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+
+export const configProviderIdOrNameArg = defineArgument({
+  schema: z.string(),
+  description: 'Add-on ID, real ID (config_xxx) or name (if unambiguous)',
+  placeholder: 'addon-id|config-provider-id|addon-name',
+});

package/src/commands/config-provider/config-provider.command.js

@@ -0,0 +1,10 @@
+import { defineCommand } from '../../lib/define-command.js';
+
+export const configProviderCommand = defineCommand({
+  description: 'Manage configuration providers',
+  since: '4.6.0',
+  options: {},
+  args: [],
+  // Parent command - no handler, only contains subcommands
+  handler: null,
+});

package/src/commands/config-provider/config-provider.docs.md

@@ -0,0 +1,109 @@
+# 📖 `clever config-provider` command reference
+
+## ➡️ `clever config-provider` <kbd>Since 4.6.0</kbd>
+
+Manage configuration providers
+
+```bash
+clever config-provider
+```
+
+## ➡️ `clever config-provider get` <kbd>Since 4.6.0</kbd>
+
+List environment variables of a configuration provider
+
+```bash
+clever config-provider get <addon-id|config-provider-id|addon-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`addon-id|config-provider-id|addon-name`|Add-on ID, real ID (config_xxx) or name (if unambiguous)|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Output format (human, json, shell) (default: human)|
+
+## ➡️ `clever config-provider import` <kbd>Since 4.6.0</kbd>
+
+Load environment variables from STDIN
+(WARNING: this deletes all current variables and replaces them with the new list loaded from STDIN)
+
+```bash
+clever config-provider import <addon-id|config-provider-id|addon-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`addon-id|config-provider-id|addon-name`|Add-on ID, real ID (config_xxx) or name (if unambiguous)|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Input format (name-equals-value, json) (default: name-equals-value)|
+
+## ➡️ `clever config-provider list` <kbd>Since 4.6.0</kbd>
+
+List configuration providers
+
+```bash
+clever config-provider list [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+
+## ➡️ `clever config-provider open` <kbd>Since 4.6.0</kbd>
+
+Open the configuration provider in Clever Cloud Console
+
+```bash
+clever config-provider open <addon-id|config-provider-id|addon-name>
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`addon-id|config-provider-id|addon-name`|Add-on ID, real ID (config_xxx) or name (if unambiguous)|
+
+## ➡️ `clever config-provider rm` <kbd>Since 4.6.0</kbd>
+
+Remove an environment variable from a configuration provider
+
+```bash
+clever config-provider rm <addon-id|config-provider-id|addon-name> <variable-name>
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`addon-id|config-provider-id|addon-name`|Add-on ID, real ID (config_xxx) or name (if unambiguous)|
+|`variable-name`|Name of the environment variable|
+
+## ➡️ `clever config-provider set` <kbd>Since 4.6.0</kbd>
+
+Add or update an environment variable named <variable-name> with the value <variable-value>
+
+```bash
+clever config-provider set <addon-id|config-provider-id|addon-name> <variable-name> <variable-value>
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`addon-id|config-provider-id|addon-name`|Add-on ID, real ID (config_xxx) or name (if unambiguous)|
+|`variable-name`|Name of the environment variable|
+|`variable-value`|Value of the environment variable|

package/src/commands/config-provider/config-provider.get.command.js

@@ -0,0 +1,36 @@
+import { getConfigProviderEnv } from '@clevercloud/client/esm/api/v4/addon.js';
+import { toNameEqualsValueString } from '@clevercloud/client/esm/utils/env-vars.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import { resolveConfigProviderId } from '../../models/config-provider.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { envFormatOption } from '../global.options.js';
+import { configProviderIdOrNameArg } from './config-provider.args.js';
+
+export const configProviderGetCommand = defineCommand({
+  description: 'List environment variables of a configuration provider',
+  since: '4.6.0',
+  options: {
+    format: envFormatOption,
+  },
+  args: [configProviderIdOrNameArg],
+  async handler(options, addonIdOrRealIdOrName) {
+    const { format } = options;
+    const { realId } = await resolveConfigProviderId(addonIdOrRealIdOrName);
+
+    // API returns an array of { name, value } objects
+    const envVars = await getConfigProviderEnv({ configurationProviderId: realId }).then(sendToApi);
+
+    switch (format) {
+      case 'json':
+        Logger.printJson(envVars);
+        break;
+      case 'shell':
+        Logger.println(toNameEqualsValueString(envVars, { addExports: true }));
+        break;
+      case 'human':
+      default:
+        Logger.println(toNameEqualsValueString(envVars, { addExports: false }));
+    }
+  },
+});

package/src/commands/config-provider/config-provider.import.command.js

@@ -0,0 +1,40 @@
+import { updateConfigProviderEnv } from '@clevercloud/client/esm/api/v4/addon.js';
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { Logger } from '../../logger.js';
+import { resolveConfigProviderId } from '../../models/config-provider.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import * as variables from '../../models/variables.js';
+import { configProviderIdOrNameArg } from './config-provider.args.js';
+
+const importFormatOption = defineOption({
+  name: 'format',
+  schema: z.enum(['name-equals-value', 'json']).default('name-equals-value'),
+  description: 'Input format (name-equals-value, json)',
+  aliases: ['F'],
+  placeholder: 'format',
+});
+
+export const configProviderImportCommand = defineCommand({
+  description:
+    'Load environment variables from STDIN\n(WARNING: this deletes all current variables and replaces them with the new list loaded from STDIN)',
+  since: '4.6.0',
+  options: {
+    format: importFormatOption,
+  },
+  args: [configProviderIdOrNameArg],
+  async handler(options, addonIdOrRealIdOrName) {
+    const { format } = options;
+    const { realId } = await resolveConfigProviderId(addonIdOrRealIdOrName);
+
+    // readVariablesFromStdin returns { NAME: "value" } format
+    // but the API expects [{ name, value }] format
+    const envVarsObject = await variables.readVariablesFromStdin(format);
+    const envVarsArray = Object.entries(envVarsObject).map(([name, value]) => ({ name, value }));
+
+    await updateConfigProviderEnv({ configurationProviderId: realId }, envVarsArray).then(sendToApi);
+
+    Logger.println('Environment variables have been set');
+  },
+});

package/src/commands/config-provider/config-provider.list.command.js

@@ -0,0 +1,45 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { findAddonsByAddonProvider } from '../../models/ids-resolver.js';
+import { humanJsonOutputFormatOption } from '../global.options.js';
+
+export const configProviderListCommand = defineCommand({
+  description: 'List configuration providers',
+  since: '4.6.0',
+  options: {
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { format } = options;
+    const deployed = await findAddonsByAddonProvider('config-provider');
+    const providersPerOwner = Object.groupBy(deployed, (provider) => provider.ownerId);
+
+    switch (format) {
+      case 'json':
+        Logger.printJson(providersPerOwner);
+        break;
+      case 'human':
+      default:
+        if (deployed.length === 0) {
+          Logger.println(
+            `No configuration provider found, create one with ${styleText('blue', 'clever addon create config-provider')} command`,
+          );
+          return;
+        }
+
+        Logger.println(`Found ${deployed.length} configuration provider${deployed.length > 1 ? 's' : ''}:`);
+        Logger.println();
+
+        Object.values(providersPerOwner).forEach((providers) => {
+          Logger.println(`${styleText('bold', `${providers[0].ownerId} (${providers[0].ownerName})`)}`);
+          providers.forEach((provider) => {
+            Logger.println(`  ${provider.name} ${styleText('grey', `(${provider.realId})`)}`);
+          });
+          Logger.println();
+        });
+        break;
+    }
+  },
+});

package/src/commands/config-provider/config-provider.open.command.js

@@ -0,0 +1,17 @@
+import { config } from '../../config/config.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { resolveConfigProviderId } from '../../models/config-provider.js';
+import { openBrowser } from '../../models/utils.js';
+import { configProviderIdOrNameArg } from './config-provider.args.js';
+
+export const configProviderOpenCommand = defineCommand({
+  description: 'Open the configuration provider in Clever Cloud Console',
+  since: '4.6.0',
+  options: {},
+  args: [configProviderIdOrNameArg],
+  async handler(_options, addonIdOrRealIdOrName) {
+    const { addonId } = await resolveConfigProviderId(addonIdOrRealIdOrName);
+    await openBrowser(`${config.GOTO_URL}/${addonId}`, `Opening ${styleText('blue', addonId)} in the browser...`);
+  },
+});