clever-tools 3.12.0 → 3.13.0

package/src/experimental-features.js

@@ -1,5 +1,4 @@
 import dedent from 'dedent';
-import { conf } from './models/configuration.js';
 
 export const EXPERIMENTAL_FEATURES = {
   kv: {
@@ -17,19 +16,6 @@ export const EXPERIMENTAL_FEATURES = {
       Learn more about Materia KV: https://www.clever-cloud.com/developers/doc/addons/materia-kv/
     `,
   },
-  tokens: {
-    status: 'beta',
-    description: `Manage API tokens to query Clever Cloud API from ${conf.AUTH_BRIDGE_HOST}`,
-    instructions: dedent`
-      Create, list or revoke API tokens from a single command:
-
-          clever tokens create myTokenName
-          clever tokens --format json
-          clever tokens revoke myTokenId
-
-      Learn more about Clever Cloud API: https://www.clever-cloud.com/developers/api
-    `,
-  },
   ng: {
     status: 'beta',
     description: 'Manage Network Groups to manage applications, add-ons, external peers through a Wireguard network',
@@ -55,7 +41,22 @@ export const EXPERIMENTAL_FEATURES = {
       - Search Network Groups, members or peers:
           clever ng search myQuery
 
-      Learn more about Network Groups: https://github.com/CleverCloud/clever-tools/blob/master/docs/ng.md
+      Learn more about Network Groups: https://www.clever-cloud.com/developers/doc/develop/network-groups/
+    `,
+  },
+  operators: {
+    status: 'beta',
+    description: 'Manage operators and their features such as Keycloak, Matomo, Metabase, Otoroshi',
+    instructions: dedent`
+      clever keycloak
+      clever keycloak get keycloak_xxx
+      clever keycloak ng enable myKeycloak
+      
+      clever metabase version check myMetabase
+      clever metabase version update myMetabase 0.53
+      
+      clever matomo open myMatomo
+      clever otoroshi open logs myOtoroshi
     `,
   },
 };

package/src/lib/operator-commands.js

@@ -0,0 +1,281 @@
+import colors from 'colors/safe.js';
+import _ from 'lodash';
+import dedent from 'dedent';
+
+import * as Operator from '../models/operator.js';
+
+import { Logger } from '../logger.js';
+import { sendToApi } from '../models/send-to-api.js';
+import {
+  ngDisableOperator,
+  ngEnableOperator,
+  rebootOperator,
+  rebuildOperator,
+  versionCheck,
+  versionUpdate,
+} from '../clever-client/operators.js';
+import { findAddonsByAddonProvider } from '../models/ids-resolver.js';
+import { openBrowser } from '../models/utils.js';
+import { confirm, selectAnswer } from './prompts.js';
+import { conf } from '../models/configuration.js';
+
+/**
+ * Check the version of an operator
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @param {string} params.options.format The output format
+ * @returns {Promise<void>}
+ */
+export async function operatorCheckVersion (provider, addonIdOrName, format) {
+
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  const name = getDisplayName(addonIdOrName);
+  const versions = await versionCheck({ provider, realId }).then(sendToApi);
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(versions);
+      break;
+    case 'human':
+    default:
+      if (!versions.needUpdate || (provider === 'metabase' && versions.installed === 'community-latest')) {
+        Logger.printSuccess(`${colors.green(name)} is up-to-date (${colors.green(versions.installed)})`);
+      }
+      else {
+        Logger.println(dedent`
+          🔄 ${colors.red(name)} is outdated
+             • Installed version: ${colors.red(versions.installed)}
+             • Latest version: ${colors.green(versions.latest)}
+        `);
+        Logger.println();
+
+        await confirm(
+          `Do you want to update it to ${colors.green(versions.latest)} now?`,
+          'No confirmation, aborting version update',
+        );
+
+        await versionUpdate({ provider, realId }, { targetVersion: versions.latest }).then(sendToApi);
+        Logger.printSuccess(`${colors.green(name)} is up-to-date and being rebuilt…`);
+      }
+      break;
+  }
+}
+
+/**
+ * Update the version of an operator
+ * @param {string} provider The operator's provider
+ * @param {string} askedVersion The version to update to
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorUpdateVersion (provider, askedVersion, addonIdOrName) {
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  const name = getDisplayName(addonIdOrName);
+
+  const versions = await versionCheck({ provider, realId }).then(sendToApi);
+
+  const targetVersion = askedVersion ?? await selectAnswer(
+    `Which version do you want to update ${colors.blue(name)} to, current is ${colors.blue(versions.installed)}?`,
+    versions.available.reverse(),
+  );
+
+  if (!versions.available.includes(targetVersion)) {
+    throw new Error(`Version ${colors.red(targetVersion)} is not available`);
+  }
+
+  if (versions.installed === targetVersion) {
+    Logger.printSuccess(`${colors.green(name)} is already at version ${colors.green(targetVersion)}`);
+    return;
+  }
+
+  await versionUpdate({ provider, realId }, { targetVersion }).then(sendToApi);
+  Logger.printSuccess(`${colors.green(name)} updated to ${colors.green(targetVersion)} and being rebuilt…`);
+}
+
+/**
+ * Unlink an operator from a Network Group
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ * @throws {Error} If the Network Group feature is already disabled
+ */
+export async function operatorNgDisable (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  if (!operator.features.networkGroup?.id) {
+    throw new Error(`Network Group is already disabled on ${colors.red(name)}`);
+  }
+
+  await ngDisableOperator({ provider, realId: operator.resourceId }).then(sendToApi);
+  Logger.println(`Disabling Network Group on ${colors.blue(name)}…`);
+
+  await operatorPrint(provider, addonIdOrName);
+}
+
+/**
+ * Link an operator to a Network Group
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ * @throws {Error} If the Network Group feature is already enabled
+ */
+export async function operatorNgEnable (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+
+  if (operator.features.networkGroup?.id) {
+    throw new Error(`Network Group is already enabled on ${colors.red(name)}`);
+  }
+
+  await ngEnableOperator({ provider, realId: operator.resourceId }).then(sendToApi);
+  Logger.println(`Enabling Network Group on ${colors.blue(name)}…`);
+
+  await operatorPrint(provider, addonIdOrName);
+}
+
+/**
+ * List all operators for a given provider
+ * @param {string} provider The operator's provider
+ * @param {string} format The output format
+ * @returns {Promise<void>}
+ */
+export async function operatorList (provider, format) {
+  const deployed = await findAddonsByAddonProvider(provider);
+  const providerName = _.capitalize(provider.replace('addon-', ''));
+  const operatorsPerOwner = _.groupBy(deployed, 'ownerId');
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(operatorsPerOwner);
+      break;
+    case 'human':
+    default:
+
+      if (deployed.length === 0) {
+        Logger.println(`🔎 No ${providerName} found, create one with ${colors.blue(`clever addon create ${providerName.toLocaleLowerCase()}`)} command`);
+        return;
+      }
+
+      Logger.println(`🔎 Found ${deployed.length} ${providerName} operator${deployed.length > 1 ? 's' : ''}:`);
+      Logger.println();
+
+      Object.values(operatorsPerOwner).forEach((operators) => {
+        Logger.println(`• ${colors.bold(`${(operators[0].ownerId)} (${(operators[0].ownerName)})`)}`);
+        operators.forEach((operator) => {
+          Logger.println(`  • ${operator.name} ${colors.grey(`(${operator.realId})`)}`);
+        });
+        Logger.println();
+      });
+      break;
+  }
+}
+
+/**
+ * Open an operator dashboard in the Clever Cloud Console in the browser
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorOpen (provider, addonIdOrName) {
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  await openBrowser(`${conf.GOTO_URL}/${operator.addonId}`, `🌐 Opening ${colors.blue(operator.addonId)} in the browser…`);
+}
+
+/**
+ * Open the Logs section of an operator application in the Clever Cloud Console
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorOpenLogs (provider, addonIdOrName) {
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  await openBrowser(
+    `/organisations/${operator.ownerId}/applications/${operator.resources.entrypoint}/logs`,
+    `🌐 Opening ${colors.blue(operator.addonId)} logs in the Clever Cloud Console…`,
+  );
+}
+
+/**
+ * Open an operator Web UI in the browser
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorOpenWebUi (provider, addonIdOrName) {
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+  await openBrowser(operator.accessUrl, `🌐 Opening ${colors.blue(operator.addonId)} Management interface in the browser…`);
+}
+
+/**
+ * Reboot an operator
+ * @param {object} params The command's parameters
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorReboot (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  await rebootOperator({ provider, realId }).then(sendToApi);
+  Logger.println(`🔄 Restarting ${colors.blue(name)}…`);
+}
+
+/**
+ * Rebuild an operator
+ * @param {object} params The command's parameters
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function operatorRebuild (provider, addonIdOrName) {
+  const name = getDisplayName(addonIdOrName);
+  const realId = await Operator.getSingleRealId(addonIdOrName);
+  await rebuildOperator({ provider, realId }).then(sendToApi);
+  Logger.println(`🔄 Rebuilding ${colors.blue(name)}…`);
+}
+
+/**
+ * Print the details of an operator
+ * @param {string} provider The operator's provider
+ * @param {{ addon_name?: string, operator_id?: string, addon_id?: string }} addonIdOrName The operator's name or ID
+ * @param {string} format The output format
+ * @returns {void}
+ */
+export async function operatorPrint (provider, addonIdOrName, format = 'human') {
+
+  const operator = await Operator.getDetails(provider, addonIdOrName);
+
+  const dataToPrint = {
+    Name: operator.name,
+    ID: operator.resourceId,
+    Owner: operator.ownerId,
+  };
+
+  dataToPrint.Version = provider === 'matomo'
+    ? `${operator.version} (PHP ${operator.phpVersion})`
+    : `${operator.version} (Java ${operator.javaVersion})`;
+
+  dataToPrint['Access URL'] = operator.accessUrl;
+
+  if (provider === 'otoroshi') {
+    dataToPrint['API URL'] = operator.api.url;
+  }
+
+  if (['otoroshi', 'keycloak'].includes(provider)) {
+    dataToPrint['Network Group'] = operator.features.networkGroup?.id ?? false;
+  }
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(operator);
+      break;
+    case 'human':
+    default:
+      console.table(dataToPrint);
+      break;
+  }
+}
+
+function getDisplayName (addonIdOrName) {
+  return addonIdOrName.addon_name ?? addonIdOrName.operator_id ?? addonIdOrName.addon_id;
+}

package/src/lib/prompts.js

@@ -0,0 +1,30 @@
+import { confirm as confirmPrompt, input, password, select } from '@inquirer/prompts';
+
+export function promptSecret (message) {
+  return password({ message, mask: true }).catch(exitOnPromptError);
+}
+
+export async function confirm (message, rejectionMessage) {
+  const answer = await confirmPrompt({ message }).catch(exitOnPromptError);
+  if (!answer) {
+    throw new Error(rejectionMessage);
+  }
+}
+
+export async function confirmAnswer (message, rejectionMessage, expectedAnswer) {
+  const answer = await input({ message }).catch(exitOnPromptError);
+  if (answer !== expectedAnswer) {
+    throw new Error(rejectionMessage);
+  }
+}
+
+export function selectAnswer (message, choices) {
+  return select({ message, choices }).catch(exitOnPromptError);
+}
+
+function exitOnPromptError (error) {
+  if (error instanceof Error && error.name === 'ExitPromptError') {
+    process.exit(1);
+  }
+  throw error;
+}

package/src/lib/slugify.js

@@ -0,0 +1,10 @@
+import slugifyRaw from 'slugify';
+
+/**
+ * Converts a string to a slug using strict mode
+ * @param {string} string - The string to be converted to a slug
+ * @returns {string} The slugified string
+ */
+export function slugify (string) {
+  return slugifyRaw(string, { strict: true });
+}

package/src/models/addon.js

@@ -5,7 +5,7 @@ import { getAllAddonProviders } from '@clevercloud/client/esm/api/v2/product.js'
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
 import { getAddonProvider } from '@clevercloud/client/esm/api/v4/addon-providers.js';
 
-import * as Interact from './interact.js';
+import { confirm } from '../lib/prompts.js';
 import { Logger } from '../logger.js';
 import { sendToApi } from '../models/send-to-api.js';
 import { resolveOwnerId } from './ids-resolver.js';
@@ -203,7 +203,10 @@ export async function deleteAddon (ownerId, addonIdOrName, skipConfirmation) {
   const addonId = await getId(ownerId, addonIdOrName);
 
   if (!skipConfirmation) {
-    await Interact.confirm('Deleting the addon can\'t be undone, are you sure? ', 'No confirmation, aborting addon deletion');
+    await confirm(
+      'Deleting the add-on can\'t be undone, are you sure?',
+      'No confirmation, aborting add-on deletion',
+    );
   }
 
   return removeAddon({ id: ownerId, addonId }).then(sendToApi);

package/src/models/app_configuration.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
 import _ from 'lodash';
-import slugify from 'slugify';
+import { slugify } from '../lib/slugify.js';
 
 import { Logger } from '../logger.js';
 import * as User from './user.js';
@@ -54,19 +54,22 @@ export async function addLinkedApplication (appData, alias, ignoreParentConfig)
 
 export async function removeLinkedApplication ({ appId, alias }) {
   const currentConfig = await loadApplicationConf();
+  const appToUnlink = currentConfig.apps.find((a) => a.app_id === appId || a.alias === alias);
+  if (appToUnlink == null) {
+    return false;
+  }
   const newConfig = {
     ...currentConfig,
-    apps: currentConfig.apps.filter((appEntry) => {
-      return appEntry.app_id !== appId && appEntry.alias !== alias;
-    }),
+    apps: currentConfig.apps.filter((a) => a !== appToUnlink),
   };
 
-  if (currentConfig.apps.length !== newConfig.apps.length) {
-    await persistConfig(newConfig);
-    return true;
+  const isDefault = currentConfig.default === appToUnlink.app_id;
+  if (isDefault) {
+    delete newConfig.default;
   }
 
-  return false;
+  await persistConfig(newConfig);
+  return true;
 };
 
 export function findApp (config, alias) {
@@ -134,7 +137,7 @@ async function getAppDetailsForId (appId) {
   }
   if (secondAppById != null) {
     throw new Error(`There are several applications matching id '${appId}'.`
-                  + 'This should not happen, your `.clever.json` should be fixed.');
+      + 'This should not happen, your `.clever.json` should be fixed.');
   }
 
   return appById;

package/src/models/application.js

@@ -1,20 +1,21 @@
 import _ from 'lodash';
 import {
+  addDependency,
   create as createApplication,
-  remove as removeApplication,
-  getAll as getAllApplications,
   get as getApplication,
-  redeploy as redeployApplication,
-  update as updateApplication,
+  getAll as getAllApplications,
   getAllDependencies,
-  addDependency,
+  redeploy as redeployApplication,
+  remove as removeApplication,
   removeDependency,
+  update as updateApplication,
 } from '@clevercloud/client/esm/api/v2/application.js';
 import cliparse from 'cliparse';
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+import colors from 'colors/safe.js';
 
 import * as AppConfiguration from './app_configuration.js';
-import * as Interact from './interact.js';
+import { confirmAnswer } from '../lib/prompts.js';
 import { Logger } from '../logger.js';
 import * as Organisation from './organisation.js';
 import * as User from './user.js';
@@ -24,10 +25,10 @@ import { resolveOwnerId } from './ids-resolver.js';
 import { getAvailableInstances } from '@clevercloud/client/esm/api/v2/product.js';
 
 export function listAvailableTypes () {
-  return cliparse.autocomplete.words(['docker', 'elixir', 'go', 'gradle', 'haskell', 'jar', 'maven', 'meteor', 'node', 'php', 'play1', 'play2', 'python', 'ruby', 'rust', 'sbt', 'static-apache', 'war']);
+  return cliparse.autocomplete.words(['docker', 'elixir', 'frankenphp', 'go', 'gradle', 'haskell', 'jar', 'linux', 'maven', 'meteor', 'node', 'php', 'play1', 'play2', 'python', 'ruby', 'rust', 'sbt', 'static', 'static-apache', 'v', 'war']);
 };
 
-export const AVAILABLE_ZONES = ['par', 'grahds', 'rbx', 'rbxhds', 'scw', 'mtl', 'sgp', 'syd', 'wsw'];
+export const AVAILABLE_ZONES = ['par', 'parhds', 'grahds', 'rbx', 'rbxhds', 'scw', 'ldn', 'mtl', 'sgp', 'syd', 'wsw'];
 
 export function listAvailableZones () {
   return cliparse.autocomplete.words(AVAILABLE_ZONES);
@@ -100,10 +101,10 @@ export async function deleteApp (app, skipConfirmation) {
   Logger.debug('Deleting app: ' + app.name + ' (' + app.id + ')');
 
   if (!skipConfirmation) {
-    await Interact.confirm(
-      `Deleting the application ${app.name} can't be undone, please type '${app.name}' to confirm: `,
+    await confirmAnswer(
+      `Deleting an application can't be undone, please type ${colors.green(app.name)} to confirm:`,
       'No confirmation, aborting application deletion',
-      [app.name],
+      app.name,
     );
   }
 
@@ -164,9 +165,20 @@ async function getByName (ownerId, name) {
   return getApplicationByName(apps, name);
 };
 
+function addInstanceLifetime (app) {
+  // Patch to help config commands
+  app.instanceLifetime = app.instance.lifetime;
+  return app;
+}
+
 export function get (ownerId, appId) {
   Logger.debug(`Get information for the app: ${appId}`);
-  return getApplication({ id: ownerId, appId }).then(sendToApi);
+  return getApplication({ id: ownerId, appId }).then(sendToApi).then(addInstanceLifetime);
+};
+
+export function updateOptions (ownerId, appId, options) {
+  Logger.debug(`Update app: ${appId}`);
+  return updateApplication({ id: ownerId, appId }, options).then(sendToApi).then(addInstanceLifetime);
 };
 
 function getFromSelf (appId) {