clever-tools 3.12.0 → 3.13.0

package/src/commands/config.js

@@ -1,22 +1,21 @@
-import { update as updateApplication } from '@clevercloud/client/esm/api/v2/application.js';
-
 import * as Application from '../models/application.js';
 import * as ApplicationConfiguration from '../models/application_configuration.js';
+import { Logger } from '../logger.js';
+import colors from 'colors/safe.js';
 
-import { sendToApi } from '../models/send-to-api.js';
+export async function list (params) {
+  const { alias, app: appIdOrName } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+  const app = await Application.get(ownerId, appId);
+  ApplicationConfiguration.printAllValues(app);
+}
 
 export async function get (params) {
   const [configurationName] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const app = await Application.get(ownerId, appId);
-
-  if (configurationName == null) {
-    ApplicationConfiguration.print(app);
-  }
-  else {
-    ApplicationConfiguration.printById(app, configurationName);
-  }
+  ApplicationConfiguration.printValue(app, configurationName);
 }
 
 export async function set (params) {
@@ -24,12 +23,11 @@ export async function set (params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const config = ApplicationConfiguration.getById(configurationName);
-
-  if (config != null) {
-    const app = await updateApplication({ id: ownerId, appId }, { [config.name]: ApplicationConfiguration.parse(config, configurationValue) }).then(sendToApi);
-
-    ApplicationConfiguration.printById(app, configurationName);
-  }
+  const options = {
+    [config.name]: ApplicationConfiguration.parse(config, configurationValue),
+  };
+  const app = await Application.updateOptions(ownerId, appId, options);
+  Logger.printSuccess(`Config ${colors.green(config.id)} successfully updated to ${colors.green(ApplicationConfiguration.formatValue(config, app[config.name]))}!`);
 }
 
 export async function update (params) {
@@ -41,9 +39,7 @@ export async function update (params) {
     throw new Error('No configuration to update');
   }
 
-  const app = await updateApplication({ id: ownerId, appId }, options).then(sendToApi);
+  const app = await Application.updateOptions(ownerId, appId, options);
 
-  for (const configName of Object.keys(options)) {
-    ApplicationConfiguration.printByName(app, configName);
-  }
+  ApplicationConfiguration.printAllValues(app);
 }

package/src/commands/console.js

@@ -1,8 +1,6 @@
 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';
+import { openBrowser } from '../models/utils.js';
 
 export async function openConsole (params) {
   const { alias, app: appIdOrName } = params.options;
@@ -10,17 +8,13 @@ export async function openConsole (params) {
   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(conf.CONSOLE_URL, { wait: false });
+    await openBrowser('/', 'Opening the Console in your browser');
     return;
   }
 
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const prefixPath = (ownerId.startsWith('user_')) ? 'users/me' : `organisations/${ownerId}`;
-  const url = `${conf.CONSOLE_URL}/${prefixPath}/applications/${appId}`;
+  const consolePath = `/${prefixPath}/applications/${appId}`;
 
-  Logger.debug(`URL: ${url}`);
-  Logger.println(`Opening the Console in your browser for application ${appId}`);
-
-  await openPage(url, { wait: false });
+  await openBrowser(consolePath, `Opening the Console in your browser for application ${appId}`);
 }

package/src/commands/create.js

@@ -1,7 +1,10 @@
 import path from 'node:path';
+import colors from 'colors/safe.js';
 import * as Application from '../models/application.js';
 import * as AppConfig from '../models/app_configuration.js';
 import { Logger } from '../logger.js';
+import { isGitWorkingDirectoryClean, isInsideGitRepo } from '../models/git.js';
+import { conf } from '../models/configuration.js';
 
 export async function create (params) {
   const { type: typeName } = params.options;
@@ -37,15 +40,7 @@ export async function create (params) {
 
     case 'human':
     default:
-      if (isTask) {
-        Logger.println('Your application has been successfully created as a task!');
-        Logger.println(`The "CC_RUN_COMMAND" environment variable has been set to "${taskCommand}"`);
-      }
-      else {
-        Logger.println('Your application has been successfully created!');
-      }
-      Logger.println(`ID: ${app.id}`);
-      Logger.println(`Name: ${name}`);
+      await displayAppCreation(app, alias, github, taskCommand);
   }
 };
 
@@ -59,3 +54,75 @@ function getGithubDetails (githubOwnerRepo) {
 function getCurrentDirectoryName () {
   return path.basename(process.cwd());
 }
+
+/**
+ * Display the application creation message in a human-readable format
+ * @param {Object} app - The application object
+ * @param {string} alias - The alias of the application
+ * @param {Object} github - The GitHub details
+ * @param {string} taskCommand - The task command
+ */
+async function displayAppCreation (app, alias, github, taskCommand) {
+
+  Logger.printSuccess(`Application ${colors.green(app.name)} successfully created!`);
+
+  const hasDistinctAlias = alias != null && alias !== app.name;
+  const isTask = app.instance.lifetime === 'TASK';
+
+  Logger.println();
+  printFieldsAsTable(2, {
+    Type: colors.blue(`⬢ ${app.instance.variant.name}`),
+    ID: app.id,
+    'Org ID': app.ownerId,
+    Name: app.name,
+    GitHub: github != null && `${github.owner}/${github.name}`,
+    Alias: hasDistinctAlias && alias,
+    Zone: app.zone,
+    Task: isTask && `"${taskCommand}"`,
+  });
+
+  Logger.println();
+  Logger.println('  ' + colors.bold('Next steps:'));
+
+  if (!github) {
+    const isInsideGit = await isInsideGitRepo();
+    if (!isInsideGit) {
+      Logger.println(`  ${colors.yellow('!')} Initialize a git repository first, for example:`);
+      Logger.println(`    ${shellCommand('git init')}`);
+      Logger.println(`    ${shellCommand('git add .')}`);
+      Logger.println(`    ${shellCommand('git commit -m "Initial commit"')}`);
+      Logger.println();
+    }
+    else {
+      const isClean = await isGitWorkingDirectoryClean();
+      if (!isClean) {
+        Logger.println(`  ${colors.yellow('!')} Commit your changes first:`);
+        Logger.println(`    ${shellCommand('git add .')}`);
+        Logger.println(`    ${shellCommand('git commit -m "My changes"')}`);
+        Logger.println();
+      }
+    }
+  }
+
+  if (github) {
+    Logger.println(`  ${colors.blue('→')} Push changes to ${colors.blue(`${github.owner}/${github.name}`)} GitHub repository to trigger a deployment, or ${colors.blue('clever restart')} the latest pushed commit`);
+  }
+  else {
+    Logger.println(`  ${colors.blue('→')} Run ${colors.blue('clever deploy')} ${isTask ? 'to execute your task' : 'to deploy your application'}`);
+  }
+
+  Logger.println(`  ${colors.blue('→')} Manage your application at: ${colors.underline(`${conf.GOTO_URL}/${app.id}`)}`);
+  Logger.println('');
+}
+
+function shellCommand (command) {
+  return `${colors.grey('$')} ${colors.yellow(command)}`;
+}
+
+function printFieldsAsTable (indent, fields) {
+  const fieldsWithValues = Object.fromEntries(Object.entries(fields).filter(([_, value]) => typeof value === 'string'));
+  const labelMaxWidth = Math.max(...Object.keys(fieldsWithValues).map((label) => label.length));
+  return Object.entries(fieldsWithValues).forEach(([label, value]) => {
+    Logger.println(`${' '.repeat(indent)}${label.padEnd(labelMaxWidth, ' ')}  ${colors.grey(value)}`);
+  });
+}

package/src/commands/delete.js

@@ -1,6 +1,7 @@
 import * as AppConfig from '../models/app_configuration.js';
 import * as Application from '../models/application.js';
 import { Logger } from '../logger.js';
+import colors from 'colors/safe.js';
 
 export async function deleteApp (params) {
   const { alias, app: appIdOrName, yes: skipConfirmation } = params.options;
@@ -8,16 +9,16 @@ export async function deleteApp (params) {
 
   const app = await Application.get(ownerId, appId);
   if (app == null) {
-    Logger.println('The application doesn\'t exist');
+    throw new Error('The application doesn\'t exist');
   }
-  else {
-    // delete app
-    await Application.deleteApp(app, skipConfirmation);
-    Logger.println('The application has been deleted');
-    // unlink app
-    const wasUnlinked = await AppConfig.removeLinkedApplication({ appId, alias });
-    if (wasUnlinked) {
-      Logger.println('The application has been unlinked');
-    }
+
+  // delete app
+  await Application.deleteApp(app, skipConfirmation);
+  Logger.printSuccess(`Application ${colors.green(colors.bold(`${app.name}`))} successfully deleted!`);
+  Logger.println(`  ${colors.grey('•')} Application ID: ${colors.grey(app.id)}`);
+
+  const wasUnlinked = await AppConfig.removeLinkedApplication({ appId, alias });
+  if (wasUnlinked) {
+    Logger.println(`  ${colors.blue('→')} Local alias ${colors.blue(alias || app.name)} unlinked`);
   }
 };

package/src/commands/deploy.js

@@ -1,4 +1,5 @@
 import colors from 'colors/safe.js';
+import dedent from 'dedent';
 
 import * as AppConfig from '../models/app_configuration.js';
 import * as Application from '../models/application.js';
@@ -27,14 +28,10 @@ export async function deploy (params) {
 
   await git.addRemote(appData.alias, appData.deployUrl);
 
-  Logger.println(colors.bold.blue(`Remote application is app_id=${appId}, alias=${appData.alias}, name=${appData.name}`));
-
-  Logger.println(colors.bold.blue(`Remote application belongs to ${ownerId}`));
-
   if (commitIdToPush === remoteHeadCommitId) {
     switch (sameCommitPolicy) {
       case 'ignore':
-        Logger.println(`The clever-cloud application is up-to-date (${colors.green(remoteHeadCommitId)})`);
+        Logger.printSuccess(`The application is up-to-date (${colors.grey(remoteHeadCommitId)})`);
         return;
       case 'restart':
         return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, false, exitStrategy);
@@ -42,31 +39,44 @@ export async function deploy (params) {
         return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, true, exitStrategy);
       case 'error':
       default: {
-        const upToDateMessage = `The clever-cloud application is up-to-date (${colors.green(remoteHeadCommitId)}).\nYou can set a policy with 'same-commit-policy' to handle differently when remote HEAD has the same commit as the one to push.\nOr try this command to restart the application:`;
-        if (commitIdToPush !== deployedCommitId) {
-          const restartWithId = `clever restart --commit ${commitIdToPush}`;
-          throw new Error(`${upToDateMessage}\n${colors.yellow(restartWithId)}`);
-        }
-        throw new Error(`${upToDateMessage}\n${colors.yellow('clever restart')}`);
+        const restartCommand = commitIdToPush !== deployedCommitId ? `clever restart --commit ${commitIdToPush}` : 'clever restart';
+        throw new Error(dedent`
+          Remote HEAD has the same commit as the one to push ${colors.grey(`(${remoteHeadCommitId})`)}, your application is up-to-date.
+          Create a new commit, use ${colors.blue(restartCommand)} or the ${colors.blue('--same-commit-policy')} option.
+        `);
       }
     }
   }
 
+  // It's sometimes tricky to figure out the deployment ID for the current git push.
+  // We on have the commit ID but there in a situation where the last deployment was cancelled, it may have the same commit ID.
+  // So before pushing, we get the last deployments so we can after the push figure out which deployment is new…
+  const knownDeployments = await getAllDeployments({ id: ownerId, appId, limit: 5 }).then(sendToApi);
+
+  Logger.println(dedent`
+    ${colors.bold(`🚀 Deploying ${colors.green(appData.name)}`)}
+       Application ID  ${colors.grey(`${appId}`)}
+       Org ID          ${colors.grey(`${ownerId}`)}
+  `);
+
+  Logger.println();
+
+  Logger.println(colors.bold('🔀 Git information'));
   if (remoteHeadCommitId == null || deployedCommitId == null) {
-    Logger.println('App is brand new, no commits on remote yet');
+    Logger.println(`   ${colors.yellow('!')} App is brand new, no commits on remote yet`);
   }
   else {
-    Logger.println(`Remote git head commit   is ${colors.green(remoteHeadCommitId)}`);
-    Logger.println(`Current deployed commit  is ${colors.green(deployedCommitId)}`);
+    Logger.println(`   Remote head     ${colors.yellow(remoteHeadCommitId)} (${branchRefspec})`);
+    Logger.println(`   Deployed commit ${colors.yellow(deployedCommitId)}`);
   }
-  Logger.println(`New local commit to push is ${colors.green(commitIdToPush)} (from ${colors.green(branchRefspec)})`);
+  Logger.println(`   Local commit    ${colors.yellow(commitIdToPush)} ${colors.blue('[will be deployed]')}`);
 
-  // It's sometimes tricky to figure out the deployment ID for the current git push.
-  // We on have the commit ID but there in a situation where the last deployment was cancelled, it may have the same commit ID.
-  // So before pushing, we get the last deployments so we can after the push figure out which deployment is new…
-  const knownDeployments = await getAllDeployments({ id: ownerId, appId, limit: 5 }).then(sendToApi);
+  Logger.println();
 
-  Logger.println('Pushing source code to Clever Cloud…');
+  Logger.println(dedent`
+    ${colors.bold('🔄 Deployment progress')}
+       ${colors.blue('→ Pushing source code to Clever Cloud…')}
+  `);
 
   await git.push(appData.deployUrl, commitIdToPush, force)
     .catch(async (e) => {
@@ -78,12 +88,16 @@ export async function deploy (params) {
         throw e;
       }
     });
-  Logger.println(colors.bold.green('Your source code has been pushed to Clever Cloud.'));
+
+  await Logger.println(`   ${colors.green('✓ Code pushed to Clever Cloud')}`);
 
   return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, commitId: commitIdToPush, knownDeployments, quiet, exitStrategy });
 }
 
 async function restartOnSameCommit (ownerId, appId, commitIdToPush, quiet, withoutCache, exitStrategy) {
+  const cacheSuffix = withoutCache ? ' without using cache' : '';
+  Logger.println(`🔄 Restarting ${colors.bold(appId)}${cacheSuffix} ${colors.grey(`(${commitIdToPush})`)}`);
+
   const restart = await Application.redeploy(ownerId, appId, commitIdToPush, withoutCache);
   return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, deploymentId: restart.deploymentId, quiet, exitStrategy });
 }

package/src/commands/emails.js

@@ -0,0 +1,174 @@
+import colors from 'colors/safe.js';
+import * as User from '../models/user.js';
+import { Logger } from '../logger.js';
+import { openBrowser } from '../models/utils.js';
+import { sendToApi } from '../models/send-to-api.js';
+import { confirm } from '../lib/prompts.js';
+import {
+  todo_addEmailAddress as addEmailAddress,
+  todo_getEmailAddresses as getEmailAddresses,
+  todo_removeEmailAddress as removeEmailAddress,
+} from '@clevercloud/client/esm/api/v2/user.js';
+
+/**
+ * Show primary and secondary email addresses of the current user
+ * @param {object} params The command parameters
+ * @param {string} params.options.format The output format
+ */
+export async function list (params) {
+  const { format } = params.options;
+  const addresses = await getUserEmailAddresses();
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(addresses);
+      break;
+    }
+    case 'human':
+    default: {
+      Logger.println('✉️  Primary email address:');
+      Logger.println(` • ${colors.green(addresses.primary)}`);
+      if (addresses.secondary.length > 0) {
+        Logger.println();
+        Logger.println(`✉️  ${addresses.secondary.length} secondary email address(es):`);
+        addresses.secondary.forEach((address) =>
+          Logger.println(` • ${colors.blue(address)}`),
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Add a secondary email address to the current user
+ * @param {object} params The command parameters
+ * @param {Array<string>} params.args
+ */
+export async function addSecondary (params) {
+  const [secondaryAddress] = params.args;
+
+  const secondaryAddressEncoded = encodeURIComponent(secondaryAddress);
+  try {
+    await addEmailAddress({ email: secondaryAddressEncoded }).then(sendToApi);
+    Logger.printSuccess(`The server sent a confirmation email to ${secondaryAddress} to validate your secondary address`);
+  }
+  catch (e) {
+    switch (e?.responseBody?.id) {
+      case 101:
+        throw new Error('This address already belongs to your account');
+      case 550:
+        throw new Error('The format of this address is invalid');
+      case 1004:
+        throw new Error('This address belongs to another account');
+      default:
+        throw e;
+    }
+  }
+}
+
+/**
+ * Set the primary email address of the current user
+ * @param {object} params The command parameters
+ * @param {Array<string>} params.args
+ */
+export async function setPrimary (params) {
+  const [newPrimaryAddress] = params.args;
+
+  const addresses = await getUserEmailAddresses();
+
+  if (addresses.primary === newPrimaryAddress) {
+    throw new Error('This address is already the primary one');
+  }
+
+  if (!addresses.secondary.includes(newPrimaryAddress)) {
+    throw new Error('This address must be added as a secondary address before marking it as primary');
+  }
+
+  const newPrimaryEmailEncoded = encodeURIComponent(newPrimaryAddress);
+  await addEmailAddress({ email: newPrimaryEmailEncoded }, { make_primary: true }).then(sendToApi);
+
+  Logger.printSuccess(`Primary address updated to ${newPrimaryAddress} successfully`);
+}
+
+/**
+ * Remove a secondary email address from the current user
+ * @param {object} params The command parameters
+ * @param {Array<string>} params.args
+ */
+export async function removeSecondary (params) {
+  const [addressToRemove] = params.args;
+
+  const addresses = await getUserEmailAddresses();
+
+  if (!addresses.secondary.includes(addressToRemove)) {
+    throw new Error('This address is not part of the secondary addresses of the current user, it can\'t be removed');
+  }
+
+  const addressToRemoveEncoded = encodeURIComponent(addressToRemove);
+  await removeEmailAddress({ email: addressToRemoveEncoded }).then(sendToApi);
+
+  Logger.printSuccess(`Secondary address ${addressToRemove} removed successfully`);
+}
+
+/**
+ * Remove all secondary email addresses from the current user
+ * @param {object} params The command parameters
+ * @param {object} params.options The command options
+ * @param {boolean} params.options.yes The user confirmation
+ */
+export async function removeAllSecondary (params) {
+  if (!params.options.yes) {
+    await confirm(
+      'Are you sure you want to remove all your secondary addresses?',
+      'No secondary addresses removed',
+    );
+  }
+
+  const addresses = await getUserEmailAddresses();
+
+  if (addresses.secondary.length === 0) {
+    Logger.println('No secondary address to remove');
+    return;
+  }
+
+  const results = await Promise.all(
+    addresses.secondary.map((addressToRemove) => {
+      const addressToRemoveEncoded = encodeURIComponent(addressToRemove);
+      return removeEmailAddress({ email: addressToRemoveEncoded }).then(sendToApi)
+        .then(() => [true, addressToRemove])
+        .catch(() => [false, addressToRemove]);
+    }),
+  );
+
+  if (results.every(([isRemoved]) => isRemoved)) {
+    Logger.printSuccess('All secondary addresses were removed successfully');
+  }
+  else {
+    const addressesWithErrors = results
+      .filter(([isRemoved]) => !isRemoved)
+      .map(([_, address]) => address)
+      .join(', ');
+    throw new Error(`Some errors occured while removing these addresses: ${addressesWithErrors}`);
+  }
+}
+
+/**
+ * Open the email addresses management page of the Console in your browser
+ * @returns {Promise<void>} A promise that resolves when the page is opened
+ */
+export function openConsole () {
+  return openBrowser('/users/me/emails', 'Opening the email addresses management page of the Console in your browser');
+}
+
+/**
+ * Get the primary and secondary email addresses of the current user
+ * @returns {Promise<{ primary: string, secondary: string[] }>} The primary and secondary email addresses of the current user
+ */
+async function getUserEmailAddresses () {
+  const currentUser = await User.getCurrent();
+  const secondaryAddresses = await getEmailAddresses().then(sendToApi);
+  return {
+    primary: currentUser.email,
+    secondary: secondaryAddresses.sort(),
+  };
+}

package/src/commands/keycloak.js

@@ -0,0 +1,138 @@
+import {
+  operatorCheckVersion,
+  operatorList,
+  operatorNgDisable,
+  operatorNgEnable,
+  operatorOpen,
+  operatorOpenLogs,
+  operatorOpenWebUi,
+  operatorPrint,
+  operatorReboot,
+  operatorRebuild,
+  operatorUpdateVersion,
+} from '../lib/operator-commands.js';
+
+/**
+ * Check the version of a Keycloak operator
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @param {string} params.options.format The output format
+ * @returns {Promise<void>}
+ */
+export async function checkVersion (params) {
+  const [addonIdOrName] = params.args;
+  const { format } = params.options;
+  await operatorCheckVersion('keycloak', addonIdOrName, format);
+}
+
+/**
+ * Update the version of a Keycloak operator
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function updateVersion (params) {
+  const [addonIdOrName] = params.args;
+  const { target } = params.options;
+  await operatorUpdateVersion('keycloak', target, addonIdOrName);
+}
+
+/**
+ * Get the details of a Keycloak operator
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @param {string} params.options.format The output format
+ * @returns {Promise<void>}
+ */
+export async function get (params) {
+  const [addonIdOrName] = params.args;
+  const { format } = params.options;
+  await operatorPrint('keycloak', addonIdOrName, format);
+}
+
+/**
+ * List all Keycloak operators
+ * @returns {Promise<void>}
+ */
+export async function list (params) {
+  await operatorList('keycloak', params.options.format);
+}
+
+/**
+ * Unlink a Keycloak operator from a Network Group
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ * @throws {Error} If the Network Group feature is already disabled
+ */
+export async function ngDisable (params) {
+  const [addonIdOrName] = params.args;
+  await operatorNgDisable('keycloak', addonIdOrName);
+}
+
+/**
+ * Link a Keycloak operator to a Network Group
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ * @throws {Error} If the Network Group feature is already enabled
+ */
+export async function ngEnable (params) {
+  const [addonIdOrName] = params.args;
+  await operatorNgEnable('keycloak', addonIdOrName);
+}
+
+/**
+ * Open a Keycloak operator dashboard in the Clever Cloud Console
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function open (params) {
+  const [addonIdOrName] = params.args;
+  await operatorOpen('keycloak', addonIdOrName);
+}
+
+/**
+ * Open the Logs section of a Keycloak Operator application in the Clever Cloud Console
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function openLogs (params) {
+  const [addonIdOrName] = params.args;
+  await operatorOpenLogs('keycloak', addonIdOrName);
+}
+
+/**
+ * Open the Web UI of a Keycloak Operator application in the Clever Cloud Console
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function openWebUi (params) {
+  const [addonIdOrName] = params.args;
+  await operatorOpenWebUi('keycloak', addonIdOrName);
+}
+
+/**
+ * Restart a Keycloak operator
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function reboot (params) {
+  const [addonIdOrName] = params.args;
+  await operatorReboot('keycloak', addonIdOrName);
+}
+
+/**
+ * Rebuild a Keycloak operator
+ * @param {object} params The command's parameters
+ * @param {string} params.args[0] The operator's name or ID
+ * @returns {Promise<void>}
+ */
+export async function rebuild (params) {
+  const [addonIdOrName] = params.args;
+  await operatorRebuild('keycloak', addonIdOrName);
+}

package/src/commands/link.js

@@ -1,5 +1,6 @@
 import * as Application from '../models/application.js';
 import { Logger } from '../logger.js';
+import colors from 'colors/safe.js';
 
 export async function link (params) {
   const [app] = params.args;
@@ -13,5 +14,6 @@ export async function link (params) {
     await Application.linkRepo(app, orgaIdOrName, alias);
   }
 
-  Logger.println('Your application has been successfully linked!');
+  const linkedMessage = alias ? ` to local alias ${colors.green(alias)}` : '';
+  Logger.printSuccess(`Application ${colors.green(app.app_name || app.app_id)} has been successfully linked${linkedMessage}!`);
 }

package/src/commands/makeDefault.js

@@ -1,10 +1,11 @@
 import * as AppConfig from '../models/app_configuration.js';
 import { Logger } from '../logger.js';
+import colors from 'colors/safe.js';
 
 export async function makeDefault (params) {
   const [alias] = params.args;
 
   await AppConfig.setDefault(alias);
 
-  Logger.println(`The application ${alias} has been set as default`);
+  Logger.printSuccess(`The application ${colors.green(alias)} has been set as default`);
 };