clever-tools 3.10.0 → 3.11.0

package/README.md

@@ -56,7 +56,7 @@ Discover how to use Clever Tools through [our documentation](docs/).
 
 ## Examples
 
-Discover how to deploy many applications on Clever Cloud within [our guides](https://developers.clever-cloud.com/guides/).
+Discover how to deploy many applications on Clever Cloud within [our guides](https://www.clever-cloud.com/developers/guides/).
 
 ## How to send feedback?
 

package/bin/clever.js

@@ -4,6 +4,7 @@
 import '../src/initial-setup.js';
 
 import cliparse from 'cliparse';
+import colors from 'colors/safe.js';
 import cliparseCommands from 'cliparse/src/command.js';
 import _sortBy from 'lodash/sortBy.js';
 
@@ -13,7 +14,9 @@ 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 { EXPERIMENTAL_FEATURES } from '../src/experimental-features.js';
 import { getExitOnOption, getOutputFormatOption, getSameCommitPolicyOption } from '../src/command-options.js';
+import { getFeatures } from '../src/models/configuration.js';
 
 import * as Addon from '../src/models/addon.js';
 import * as ApplicationConfiguration from '../src/models/application_configuration.js';
@@ -34,6 +37,8 @@ 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 features from '../src/commands/features.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';
@@ -74,10 +79,21 @@ cliparse.command = function (name, options, commandFunction) {
   });
 };
 
-function run () {
+// Add a yellow color and status tag to the description of an experimental command
+function colorizeExperimentalCommand (command, id) {
+  const status = EXPERIMENTAL_FEATURES[id].status;
+  command.description = colors.yellow(command.description + ' [' + status.toUpperCase() + ']');
+  return command;
+}
+
+async function run () {
 
   // ARGUMENTS
   const args = {
+    kvRawCommand: cliparse.argument('command', { description: 'The raw command to send to the Materia KV or Redis® add-on' }),
+    kvIdOrName: cliparse.argument('kv-id', {
+      description: 'Add-on/Real ID (or name, if unambiguous) of a Materia KV or Redis® add-on',
+    }),
     addonIdOrName: cliparse.argument('addon-id', {
       description: 'Add-on ID (or name, if unambiguous)',
       parser: Parsers.addonIdOrName,
@@ -102,6 +118,11 @@ function run () {
     }),
     drainUrl: cliparse.argument('drain-url', { description: 'Drain URL' }),
     fqdn: cliparse.argument('fqdn', { description: 'Domain name of the application' }),
+    features: cliparse.argument('features', {
+      description: 'Comma-separated list of experimental features to manage',
+      parser: Parsers.commaSeparated,
+    }),
+    featureId: cliparse.argument('feature', { description: 'Experimental feature to manage' }),
     notificationName: cliparse.argument('name', { description: 'Notification name' }),
     notificationId: cliparse.argument('notification-id', { description: 'Notification ID' }),
     webhookUrl: cliparse.argument('url', { description: 'Webhook URL' }),
@@ -666,6 +687,35 @@ function run () {
     commands: [envSetCommand, envRemoveCommand, envImportCommand, envImportVarsFromLocalEnvCommand],
   }, env.list);
 
+  // EXPERIMENTAL FEATURES COMMAND
+  const listFeaturesCommand = cliparse.command('list', {
+    description: 'List available experimental features',
+    options: [opts.humanJsonOutputFormat],
+  }, features.list);
+  const infoFeaturesCommand = cliparse.command('info', {
+    description: 'Display info about an experimental feature',
+    args: [args.featureId],
+  }, features.info);
+  const enableFeatureCommand = cliparse.command('enable', {
+    description: 'Enable experimental features',
+    args: [args.features],
+  }, features.enable);
+  const disableFeatureCommand = cliparse.command('disable', {
+    description: 'Disable experimental features',
+    args: [args.features],
+  }, features.disable);
+  const featuresCommands = cliparse.command('features', {
+    description: 'Manage Clever Tools experimental features',
+    commands: [enableFeatureCommand, disableFeatureCommand, listFeaturesCommand, infoFeaturesCommand],
+  }, features.list);
+
+  // KV COMMAND
+  const kvRawCommand = cliparse.command('kv', {
+    description: 'Send a raw command to a Materia KV or Redis® add-on',
+    args: [args.kvIdOrName, args.kvRawCommand],
+    options: [opts.orgaIdOrName, opts.humanJsonOutputFormat],
+  }, kv.sendRawCommand);
+
   // LINK COMMAND
   const appLinkCommand = cliparse.command('link', {
     description: 'Link this repo to an existing application',
@@ -715,7 +765,7 @@ function run () {
 
   // OPEN COMMAND
   const openCommand = cliparse.command('open', {
-    description: 'Open an application in your browser',
+    description: 'Open an application in the Console',
     options: [opts.alias, opts.appIdOrName],
   }, open.open);
 
@@ -726,9 +776,13 @@ function run () {
   }, consoleModule.openConsole);
 
   // PROFILE COMMAND
+  const profileOpenCommand = cliparse.command('open', {
+    description: 'Open your profile in the Console',
+  }, profile.openProfile);
   const profileCommand = cliparse.command('profile', {
     description: 'Display the profile of the current user',
     options: [opts.humanJsonOutputFormat],
+    commands: [profileOpenCommand],
   }, profile.profile);
 
   // PUBLISHED CONFIG COMMANDS
@@ -881,7 +935,7 @@ function run () {
   // Patch help command description
   cliparseCommands.helpCommand.description = 'Display help about the Clever Cloud CLI';
 
-  const commands = _sortBy([
+  const commands = [
     accesslogsCommand,
     activityCommand,
     addonCommands,
@@ -900,6 +954,7 @@ function run () {
     drainCommands,
     emailNotificationsCommand,
     envCommands,
+    featuresCommands,
     cliparseCommands.helpCommand,
     loginCommand,
     logoutCommand,
@@ -918,7 +973,14 @@ function run () {
     tcpRedirsCommands,
     versionCommand,
     webhooksCommand,
-  ], 'name');
+  ];
+
+  // Add experimental features only if they are enabled through the configuration file
+  const featuresFromConf = await getFeatures();
+
+  if (featuresFromConf.kv) {
+    commands.push(colorizeExperimentalCommand(kvRawCommand, 'kv'));
+  }
 
   // CLI PARSER
   const cliParser = cliparse.cli({
@@ -927,7 +989,7 @@ function run () {
     version: getPackageJson().version,
     options: [opts.color, opts.updateNotifier, opts.verbose],
     helpCommand: false,
-    commands,
+    commands: _sortBy(commands, 'name'),
   });
 
   // Make sure argv[0] is always "node"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clever-tools",
-  "version": "3.10.0",
+  "version": "3.11.0",
   "description": "Command Line Interface for Clever Cloud.",
   "main": "bin/clever.js",
   "type": "module",
@@ -33,6 +33,7 @@
     "curlconverter": "3.21.0",
     "duration-js": "4.0.0",
     "eventsource": "1.1.0",
+    "ioredis": "5.4.1",
     "iso8601-duration": "2.1.2",
     "isomorphic-git": "1.25.3",
     "linux-release-info": "3.0.0",

package/src/commands/addon.js

@@ -11,6 +11,7 @@ import { getAllEnvVars } from '@clevercloud/client/esm/api/v2/addon.js';
 import { sendToApi } from '../models/send-to-api.js';
 import { toNameEqualsValueString } from '@clevercloud/client/esm/utils/env-vars.js';
 import { resolveAddonId } from '../models/ids-resolver.js';
+import { conf } from '../models/configuration.js';
 
 const formatTable = initFormatTable();
 
@@ -114,13 +115,17 @@ function displayAddon (format, addon, providerName, message) {
       name: 'Metabase',
       urlEnv: 'METABASE_URL',
     },
+    otoroshi: {
+      name: 'Otoroshi with LLM',
+      urlEnv: 'CC_OTOROSHI_URL',
+    },
   };
 
   const WIP_PROVIDERS = {
     keycloak: {
       status: 'beta',
       postCreateInstructions: [
-        'Learn more about Keycloak on Clever Cloud: https://developers.clever-cloud.com/doc/addons/keycloak/',
+        `Learn more about Keycloak on Clever Cloud: ${conf.DOC_URL}/addons/keycloak/`,
       ].join('\n'),
     },
     kv: {
@@ -129,25 +134,31 @@ function displayAddon (format, addon, providerName, message) {
         colors.yellow('You can easily use Materia KV with \'redis-cli\', with such commands:'),
         colors.blue(`source <(clever addon env ${addon.id} -F shell)`),
         colors.blue('redis-cli -h $KV_HOST -p $KV_PORT --tls'),
-        'Learn more about Materia KV on Clever Cloud: https://developers.clever-cloud.com/doc/addons/materia-kv/',
+        `Learn more about Materia KV on Clever Cloud: ${conf.DOC_URL}/addons/materia-kv/`,
       ].join('\n'),
     },
     'addon-matomo': {
       status: 'beta',
       postCreateInstructions: [
-        'Learn more about Matomo on Clever Cloud: https://developers.clever-cloud.com/doc/addons/matomo/',
+        `Learn more about Matomo on Clever Cloud: ${conf.DOC_URL}/addons/matomo/`,
       ].join('\n'),
     },
     metabase: {
       status: 'beta',
       postCreateInstructions: [
-        'Learn more about Metabase on Clever Cloud: https://developers.clever-cloud.com/doc/addons/metabase/',
+        `Learn more about Metabase on Clever Cloud: ${conf.DOC_URL}/addons/metabase/`,
+      ].join('\n'),
+    },
+    otoroshi: {
+      status: 'beta',
+      postCreateInstructions: [
+        `Learn more about Otoroshi with LLM on Clever Cloud: ${conf.DOC_URL}/addons/otoroshi/`,
       ].join('\n'),
     },
     'addon-pulsar': {
       status: 'beta',
       postCreateInstructions: [
-        'Learn more about Pulsar on Clever Cloud: https://developers.clever-cloud.com/doc/addons/pulsar/',
+        `Learn more about Pulsar on Clever Cloud: ${conf.DOC_URL}/addons/pulsar/`,
       ].join('\n'),
     },
   };
@@ -200,7 +211,7 @@ function displayAddon (format, addon, providerName, message) {
           Logger.println();
           Logger.println(`Your ${provider.name} is starting:`);
           Logger.println(` - Access it: ${urlToShow.startsWith('http') ? urlToShow : `https://${urlToShow}`}`);
-          Logger.println(` - Manage it: https://console.clever-cloud.com/goto/${addon.id}`);
+          Logger.println(` - Manage it: ${conf.GOTO_URL}/${addon.id}`);
         }
 
         if (providerName === 'keycloak') {
@@ -209,6 +220,13 @@ function displayAddon (format, addon, providerName, message) {
           Logger.println(` - Admin user name: ${addon.env.find((e) => e.name === 'CC_KEYCLOAK_ADMIN').value}`);
           Logger.println(` - Temporary password: ${addon.env.find((e) => e.name === 'CC_KEYCLOAK_ADMIN_DEFAULT_PASSWORD').value}`);
         }
+
+        if (providerName === 'otoroshi') {
+          Logger.println();
+          Logger.println('An initial account has been created, change the password at first login (Security -> Administrators -> Edit user):');
+          Logger.println(` - Admin user name: ${addon.env.find((e) => e.name === 'CC_OTOROSHI_INITIAL_ADMIN_LOGIN').value}`);
+          Logger.println(` - Initial password: ${addon.env.find((e) => e.name === 'CC_OTOROSHI_INITIAL_ADMIN_PASSWORD').value}`);
+        }
       }
 
       if (providerName in WIP_PROVIDERS) {

package/src/commands/console.js

@@ -2,23 +2,22 @@ import * as Application from '../models/application.js';
 import * as AppConfig from '../models/app_configuration.js';
 import { Logger } from '../logger.js';
 import openPage from 'open';
+import { conf } from '../models/configuration.js';
 
 export async function openConsole (params) {
   const { alias, app: appIdOrName } = params.options;
 
-  const baseUrl = 'https://console.clever-cloud.com';
-
   const { apps } = await AppConfig.loadApplicationConf();
   // If no app is linked or asked, open the Console without any context
   if (apps.length === 0 && !appIdOrName) {
     Logger.println('Opening the Console in your browser');
-    await openPage(baseUrl, { wait: false });
+    await openPage(conf.CONSOLE_URL, { wait: false });
     return;
   }
 
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const prefixPath = (ownerId.startsWith('user_')) ? 'users/me' : `organisations/${ownerId}`;
-  const url = `${baseUrl}/${prefixPath}/applications/${appId}`;
+  const url = `${conf.CONSOLE_URL}/${prefixPath}/applications/${appId}`;
 
   Logger.debug(`URL: ${url}`);
   Logger.println(`Opening the Console in your browser for application ${appId}`);

package/src/commands/curl.js

@@ -16,11 +16,11 @@ async function loadTokens () {
 }
 
 function printCleverCurlHelp () {
-  const apiDocUrlv2 = 'https://developers.clever-cloud.com/api/v2/';
-  const apiDocUrlv4 = 'https://developers.clever-cloud.com/api/v4/';
+  const apiDocUrlv2 = `${conf.API_DOC_URL}/v2/`;
+  const apiDocUrlv4 = `${conf.API_DOC_URL}/v4/`;
 
   Logger.println(`Usage: clever curl
-Query Clever Cloud's API using Clever Tools credentials. For example: 
+Query Clever Cloud's API using Clever Tools credentials. For example:
 
   clever curl ${conf.API_HOST}/v2/self
   clever curl ${conf.API_HOST}/v2/summary
@@ -28,7 +28,7 @@ Query Clever Cloud's API using Clever Tools credentials. For example:
   clever curl ${conf.API_HOST}/v2/organisations/<ORGANISATION_ID>/applications | jq '.[].id'
   clever curl ${conf.API_HOST}/v4/billing/organisations/<ORGANISATION_ID>/<INVOICE_NUMBER>.pdf > invoice.pdf
 
-Our API documentation is available here : 
+Our API documentation is available here :
 
   ${apiDocUrlv2}
   ${apiDocUrlv4}`);

package/src/commands/features.js

@@ -0,0 +1,93 @@
+import { getFeatures, setFeature } from '../models/configuration.js';
+import { EXPERIMENTAL_FEATURES } from '../experimental-features.js';
+import { formatTable as initFormatTable } from '../format-table.js';
+import { Logger } from '../logger.js';
+
+const formatTable = initFormatTable();
+
+export async function list (params) {
+  const { format } = params.options;
+
+  const featuresConf = await getFeatures();
+  // Add status from configuration file and remove instructions
+  const features = Object.entries(EXPERIMENTAL_FEATURES).map(([id, feature]) => {
+    const enabled = featuresConf[id] === true;
+    return {
+      id,
+      status: feature.status,
+      description: feature.description,
+      enabled,
+    };
+  });
+
+  // For each feature, print the object with the id, status, description and enabled
+  switch (format) {
+    case 'json': {
+      Logger.printJson(features);
+      break;
+    }
+    case 'human':
+    default: {
+      const headers = ['ID', 'STATUS', 'DESCRIPTION', 'ENABLED'];
+
+      Logger.println(formatTable([
+        headers,
+        ...features.map((feature) => [
+          feature.id,
+          feature.status,
+          feature.description,
+          feature.enabled,
+        ]),
+      ]));
+    }
+  }
+}
+
+export async function info (params) {
+  const { feature } = params.namedArgs;
+  const availableFeatures = Object.keys(EXPERIMENTAL_FEATURES);
+
+  if (!availableFeatures.includes(feature)) {
+    throw new Error(`Unavailable feature: ${feature}`);
+  }
+
+  Logger.println(EXPERIMENTAL_FEATURES[feature].instructions);
+}
+
+export async function enable (params) {
+  const { features } = params.namedArgs;
+  const availableFeatures = Object.keys(EXPERIMENTAL_FEATURES);
+
+  const unknownFeatures = features.filter((feature) => !availableFeatures.includes(feature));
+  if (unknownFeatures.length > 0) {
+    throw new Error(`Unavailable feature(s): ${unknownFeatures.join(', ')}`);
+  }
+
+  for (const featureName of features) {
+    await setFeature(featureName, true);
+    Logger.println(`Experimental feature '${featureName}' enabled`);
+  }
+
+  if (features.length === 1) {
+    Logger.println(EXPERIMENTAL_FEATURES[features[0]].instructions);
+  }
+  else {
+    Logger.println();
+    Logger.println("To learn more about these experimental features, use 'clever features info FEATURE_NAME'");
+  }
+}
+
+export async function disable (params) {
+  const { features } = params.namedArgs;
+  const availableFeatures = Object.keys(EXPERIMENTAL_FEATURES);
+
+  const unknownFeatures = features.filter((feature) => !availableFeatures.includes(feature));
+  if (unknownFeatures.length > 0) {
+    throw new Error(`Unavailable feature(s): ${unknownFeatures.join(', ')}`);
+  }
+
+  for (const featureName of features) {
+    await setFeature(featureName, false);
+    Logger.println(`Experimental feature '${featureName}' disabled`);
+  }
+}

package/src/commands/kv.js

@@ -0,0 +1,93 @@
+import Redis from 'ioredis';
+import colors from 'colors/safe.js';
+import { Logger } from '../logger.js';
+import { sendToApi } from '../models/send-to-api.js';
+import { getAllEnvVars } from '@clevercloud/client/cjs/api/v2/addon.js';
+import { findAddonsByNameOrId } from '../models/ids-resolver.js';
+
+const URL_ENV_KEY = 'REDIS_URL';
+const MAX_RETRIES_PER_REQUEST = 1;
+
+/**
+ * Send a raw command to a compatible KV database
+ * @param {Object} params
+ * @param {Array<string>} params.args
+ * @param {Object} params.options
+ * @param {string} params.options.format
+ * @returns {Promise<void>}
+ */
+export async function sendRawCommand (params) {
+  const [addonIdOrRealIdOrName] = params.args;
+  const { org, format } = params.options;
+
+  const addons = await findAddonsByNameOrId(addonIdOrRealIdOrName, org);
+
+  if (addons.length === 0) {
+    throw new Error(`Add-on ${addonIdOrRealIdOrName} not found`);
+  }
+
+  if (addons.length > 1) {
+    const formattedAddons = addons
+      .map(({ addonId, ownerId }) => `\n${colors.grey(`- ${addonId} (${ownerId})`)}`)
+      .join('');
+    throw new Error(`Several add-ons found for '${addonIdOrRealIdOrName}', use ID instead:${formattedAddons}`);
+  }
+
+  const { addonId, ownerId } = addons[0];
+
+  const url = await getAddonUrl(ownerId, addonId);
+
+  Logger.debug(`Extracted command: ${params.args.join(' ')}`);
+  const command = params.args.slice(1);
+
+  const result = await sendCommand(url, command);
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(result);
+      break;
+    }
+    case 'human':
+    default: {
+      Logger.println(result);
+    }
+  }
+}
+
+/**
+ * Get the URL of the compatible KV database
+* @param {string} ownerId
+* @param {string} addonId
+ * @returns {Promise<string>} the URL of the compatible KV database
+ */
+async function getAddonUrl (ownerId, addonId) {
+
+  const envVars = await getAllEnvVars({ id: ownerId, addonId }).then(sendToApi);
+  const redisUrl = envVars.find((env) => env.name === URL_ENV_KEY)?.value;
+
+  if (!redisUrl) {
+    throw new Error(`Environment variable ${colors.red(URL_ENV_KEY)} not found, is it a Materia KV or Redis® add-on?`);
+  }
+
+  return redisUrl;
+}
+
+/**
+ * Send a command to a compatible KV database
+ * @param {string} url
+ * @param {Array<string>} command
+ * @returns {Promise<string>} the command result
+ */
+async function sendCommand (url, command) {
+  Logger.debug(`Sending command '${command.join(' ')}' to ${url}`);
+  const client = new Redis(url, { maxRetriesPerRequest: MAX_RETRIES_PER_REQUEST });
+  try {
+    const result = await client.call(...command);
+    Logger.debug(`Command result: ${result}`);
+    return result;
+  }
+  finally {
+    await client.disconnect();
+    Logger.debug('Disconnected from server');
+  }
+}

package/src/commands/profile.js

@@ -1,5 +1,5 @@
 import colors from 'colors/safe.js';
-
+import openPage from 'open';
 import { Logger } from '../logger.js';
 import * as User from '../models/user.js';
 
@@ -46,3 +46,9 @@ export async function profile (params) {
     }
   }
 };
+
+export async function openProfile () {
+  const URL = 'https://console.clever-cloud.com/users/me/information';
+  Logger.debug('Opening the profile page in your browser');
+  await openPage(URL, { wait: false });
+}

package/src/experimental-features.js

@@ -0,0 +1,17 @@
+export const EXPERIMENTAL_FEATURES = {
+  kv: {
+    status: 'alpha',
+    description: 'Send commands to databases such as Materia KV or Redis® directly from Clever Tools, without other dependencies',
+    instructions: `
+      Target any compatible add-on by its name or ID (with an org ID if needed) and send commands to it:
+
+          clever kv myMateriaKV SET myKey myValue
+          clever kv kv_xxxxxxxx GET myKey -F json
+          clever kv addon_xxxxx SET myTempKey myTempValue EX 120
+          clever kv myMateriaKV -o myOrg TTL myTempKey
+          clever kv redis_xxxxx --org org_xxxxx PING
+
+      Learn more about Materia KV: https://www.clever-cloud.com/developers/doc/addons/materia-kv/
+      `,
+  },
+};

package/src/models/configuration.js

@@ -11,13 +11,22 @@ const env = commonEnv(Logger);
 const CONFIG_FILES = {
   MAIN: 'clever-tools.json',
   IDS_CACHE: 'ids-cache.json',
+  EXPERIMENTAL_FEATURES_FILE: 'clever-tools-experimental-features.json',
 };
 
-function getConfigPath (configFile) {
-  const configDir = (process.platform === 'win32')
+function getConfigDir () {
+  return (process.platform === 'win32')
     ? path.resolve(process.env.APPDATA, 'clever-cloud')
     : xdg.basedir.configPath('clever-cloud');
-  return path.resolve(configDir, configFile);
+}
+
+function getConfigPath (configFile) {
+  return path.resolve(getConfigDir(), configFile);
+}
+
+// Every function which need 'clever-cloud' directory, need to call it before
+async function ensureConfigDirExists () {
+  await mkdirp(getConfigDir(), { mode: 0o700 });
 }
 
 export async function loadOAuthConf () {
@@ -49,9 +58,8 @@ export async function loadOAuthConf () {
 
 export async function writeOAuthConf (oauthData) {
   Logger.debug('Write the tokens in the configuration file…');
-  const configDir = path.dirname(conf.CONFIGURATION_FILE);
   try {
-    await mkdirp(configDir, { mode: 0o700 });
+    await ensureConfigDirExists();
     await fs.writeFile(conf.CONFIGURATION_FILE, JSON.stringify(oauthData));
   }
   catch (error) {
@@ -78,6 +86,7 @@ export async function writeIdsCache (ids) {
   const cachePath = getConfigPath(CONFIG_FILES.IDS_CACHE);
   const idsJson = JSON.stringify(ids);
   try {
+    await ensureConfigDirExists();
     await fs.writeFile(cachePath, idsJson);
   }
   catch (error) {
@@ -85,22 +94,48 @@ export async function writeIdsCache (ids) {
   }
 }
 
+export async function getFeatures () {
+  Logger.debug('Get features configuration from ' + conf.EXPERIMENTAL_FEATURES_FILE);
+  try {
+    const rawFile = await fs.readFile(conf.EXPERIMENTAL_FEATURES_FILE);
+    return JSON.parse(rawFile);
+  }
+  catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw new Error(`Cannot get experimental features configuration from ${conf.EXPERIMENTAL_FEATURES_FILE}`);
+    }
+    return {};
+  }
+}
+
+export async function setFeature (feature, value) {
+  const currentFeatures = await getFeatures();
+  const newFeatures = { ...currentFeatures, ...{ [feature]: value } };
+
+  try {
+    await ensureConfigDirExists();
+    await fs.writeFile(conf.EXPERIMENTAL_FEATURES_FILE, JSON.stringify(newFeatures, null, 2));
+  }
+  catch (error) {
+    throw new Error(`Cannot write experimental features configuration to ${conf.EXPERIMENTAL_FEATURES_FILE}`);
+  }
+}
+
 export const conf = env.getOrElseAll({
   API_HOST: 'https://api.clever-cloud.com',
-  // API_HOST: 'https://ccapi-preprod.cleverapps.io',
-  LOG_WS_URL: 'wss://api.clever-cloud.com/v2/logs/logs-socket/<%- appId %>?since=<%- timestamp %>',
-  LOG_HTTP_URL: 'https://api.clever-cloud.com/v2/logs/<%- appId %>',
-  EVENT_URL: 'wss://api.clever-cloud.com/v2/events/event-socket',
-  WARP_10_EXEC_URL: 'https://c1-warp10-clevercloud-customers.services.clever-cloud.com/api/v0/exec',
+  SSH_GATEWAY: 'ssh@sshgateway-clevercloud-customers.services.clever-cloud.com',
+
   // the disclosure of these tokens is not considered as a vulnerability. Do not report this to our security service.
   OAUTH_CONSUMER_KEY: 'T5nFjKeHH4AIlEveuGhB5S3xg8T19e',
   OAUTH_CONSUMER_SECRET: 'MgVMqTr6fWlf2M0tkC2MXOnhfqBWDT',
-  SSH_GATEWAY: 'ssh@sshgateway-clevercloud-customers.services.clever-cloud.com',
 
+  APP_CONFIGURATION_FILE: path.resolve('.', '.clever.json'),
   CONFIGURATION_FILE: getConfigPath(CONFIG_FILES.MAIN),
-  CONSOLE_TOKEN_URL: 'https://console.clever-cloud.com/cli-oauth',
-  // CONSOLE_TOKEN_URL: 'https://next-console.cleverapps.io/cli-oauth',
+  EXPERIMENTAL_FEATURES_FILE: getConfigPath(CONFIG_FILES.EXPERIMENTAL_FEATURES_FILE),
 
-  CLEVER_CONFIGURATION_DIR: path.resolve('.', 'clevercloud'),
-  APP_CONFIGURATION_FILE: path.resolve('.', '.clever.json'),
+  API_DOC_URL: 'https://www.clever-cloud.com/developers/api',
+  DOC_URL: 'https://www.clever-cloud.com/developers/doc',
+  CONSOLE_URL: 'https://console.clever-cloud.com',
+  CONSOLE_TOKEN_URL: 'https://console.clever-cloud.com/cli-oauth',
+  GOTO_URL: 'https://console.clever-cloud.com/goto',
 });

package/src/models/ids-resolver.js

@@ -1,5 +1,6 @@
-import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+import { Logger } from '../logger.js';
 import { sendToApi } from './send-to-api.js';
+import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
 import { loadIdsCache, writeIdsCache } from './configuration.js';
 
 /*
@@ -102,3 +103,39 @@ async function getIdsFromSummary () {
 
   return ids;
 }
+
+/**
+ * Get the IDs and owners of found add-ons from a name, ID or real ID
+ * @param {string} addonIdOrRealIdOrName
+ * @param {{ orga_name?: string, orga_id?: string }} ownerNameOrId
+ * @throws {Error} if no add-on is found
+ * @throws {Error} if several add-ons are found
+ * @returns {Object} The ID and owner ID of the add-on { addonId, ownerId }
+ */
+export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId) {
+  const summary = await getSummary().then(sendToApi);
+
+  Logger.debug(`Searching for add-on '${addonIdOrRealIdOrName}' in ${summary.user.id} and ${summary.organisations.map((org) => org.id).join(', ')}`);
+  const candidates = [summary.user, ...summary.organisations]
+    .flatMap((owner) => owner.addons.map((addon) => ({ addon, owner })))
+    .filter(({ addon, owner }) => {
+      const matchOwner = ownerNameOrId == null
+        || owner.id === ownerNameOrId.orga_id
+        || owner.name === ownerNameOrId.orga_name;
+      const matchAddon = addon.name === addonIdOrRealIdOrName
+        || addon.realId === addonIdOrRealIdOrName
+        || addon.id === addonIdOrRealIdOrName;
+      return matchOwner && matchAddon;
+    })
+    .map(({ addon, owner }) => ({
+      addonId: addon.id,
+      ownerId: owner.id,
+    }));
+
+  Logger.debug(`Found ${candidates.length} candidate(s):`);
+  for (const candidate of candidates) {
+    Logger.debug(`  - ${candidate.addonId} (${candidate.ownerId})`);
+  }
+
+  return candidates;
+}

package/src/models/send-to-api.js

@@ -1,7 +1,6 @@
 import { Logger } from '../logger.js';
 import { addOauthHeader } from '@clevercloud/client/esm/oauth.js';
-import { conf, loadOAuthConf } from '../models/configuration.js';
-import { execWarpscript } from '@clevercloud/client/esm/request-warp10.superagent.js';
+import { conf, loadOAuthConf } from './configuration.js';
 import { prefixUrl } from '@clevercloud/client/esm/prefix-url.js';
 import { request } from '@clevercloud/client/esm/request.fetch.js';
 import { subtle as cryptoSuble } from 'node:crypto';
@@ -47,12 +46,6 @@ export function processError (error) {
   throw error;
 }
 
-export function sendToWarp10 (requestParams) {
-  return Promise.resolve(requestParams)
-    .then(prefixUrl(conf.WARP_10_EXEC_URL))
-    .then((requestParams) => execWarpscript(requestParams, { retry: 1 }));
-}
-
 export async function getHostAndTokens () {
   const tokens = await loadTokens();
   return {

package/src/parsers.js

@@ -4,15 +4,16 @@ import * as Application from './models/application.js';
 import ISO8601 from 'iso8601-duration';
 import Duration from 'duration-js';
 
-const addonOptionsRegex = /^\w+=.+$/;
+const addonOptionsRegex = /^[\w-]+=.+$/;
 
 export function addonOptions (options) {
-  for (const option of options) {
+  const optionsArray = typeof options === 'string' ? [options] : options;
+  for (const option of optionsArray) {
     if (!option.match(addonOptionsRegex)) {
       return cliparse.parsers.error('Invalid option: ' + option);
     }
   }
-  return cliparse.parsers.success(options.join(','));
+  return cliparse.parsers.success(optionsArray.join(','));
 }
 
 export function flavor (flavor) {