clever-tools 4.4.1 → 4.5.0

package/src/commands/otoroshi.js

@@ -1,149 +0,0 @@
-import {
-  operatorCheckVersion,
-  operatorList,
-  operatorNgDisable,
-  operatorNgEnable,
-  operatorOpen,
-  operatorOpenLogs,
-  operatorOpenWebUi,
-  operatorPrint,
-  operatorReboot,
-  operatorRebuild,
-  operatorUpdateVersion,
-} from '../lib/operator-commands.js';
-
-/**
- * Check the version of an Otoroshi 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('otoroshi', addonIdOrName, format);
-}
-
-/**
- * Update the version of an Otoroshi 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('otoroshi', target, addonIdOrName);
-}
-
-/**
- * Get the details of an Otoroshi 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('otoroshi', addonIdOrName, format);
-}
-
-/**
- * Print the configuration of an Otoroshi operator in otoroshictl format
- * @param {object} params The command's parameters
- * @param {string} params.args[0] The operator's name or ID
- * @returns {Promise<void>}
- */
-export async function getConfig(params) {
-  const [addonIdOrName] = params.args;
-  await operatorPrint('otoroshi', addonIdOrName, 'otoroshictl');
-}
-
-/**
- * List all Otoroshi operators
- * @returns {Promise<void>}
- */
-export async function list(params) {
-  await operatorList('otoroshi', params.options.format);
-}
-
-/**
- * Unlink a 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('otoroshi', addonIdOrName);
-}
-
-/**
- * Link a 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('otoroshi', addonIdOrName);
-}
-
-/**
- * Open an Otoroshi 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('otoroshi', addonIdOrName);
-}
-
-/**
- * Open the Logs section of an Otoroshi 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('otoroshi', addonIdOrName);
-}
-
-/**
- * Open the Web UI of an Otoroshi 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('otoroshi', addonIdOrName);
-}
-
-/**
- * Reboot an Otoroshi 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('otoroshi', addonIdOrName);
-}
-
-/**
- * Rebuild an Otoroshi 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('otoroshi', addonIdOrName);
-}

package/src/commands/profile.js

@@ -1,55 +0,0 @@
-import dedent from 'dedent';
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import * as User from '../models/user.js';
-import { openBrowser } from '../models/utils.js';
-
-export async function profile(params) {
-  const { format } = params.options;
-
-  const user = await User.getCurrent();
-  const currentToken = await User.getCurrentToken();
-  const tokenExpiration = new Date(currentToken.expirationDate).toLocaleString('en-US', {
-    year: 'numeric',
-    month: 'short',
-    day: 'numeric',
-    hour: 'numeric',
-    minute: 'numeric',
-    hour12: false,
-    timeZone: 'UTC',
-    timeZoneName: 'short',
-  });
-
-  const formattedUser = {
-    id: user.id,
-    email: user.email,
-    name: user.name,
-    avatar: user.avatar,
-    creationDate: new Date(user.creationDate),
-    tokenExpiration: new Date(currentToken.expirationDate).toISOString(),
-    lang: user.lang,
-    has2FA: user.preferredMFA != null && user.preferredMFA !== 'NONE',
-  };
-
-  switch (format) {
-    case 'json': {
-      Logger.printJson(formattedUser);
-      break;
-    }
-    case 'human':
-    default: {
-      Logger.println(dedent`
-        You're currently logged in as:
-        User id           ${formattedUser.id}
-        Name              ${formattedUser.name ?? styleText(['red', 'bold'], '[not specified]')}
-        Email             ${formattedUser.email}
-        Token expiration  ${tokenExpiration}
-        Two factor auth   ${formattedUser.has2FA ? 'yes' : 'no'}
-      `);
-    }
-  }
-}
-
-export async function openProfile() {
-  await openBrowser('/users/me/information', 'Opening the profile page in your browser');
-}

package/src/commands/published-config.js

@@ -1,70 +0,0 @@
-import { getAllExposedEnvVars, updateAllExposedEnvVars } from '@clevercloud/client/esm/api/v2/application.js';
-import { toNameEqualsValueString, validateName } from '@clevercloud/client/esm/utils/env-vars.js';
-import { Logger } from '../logger.js';
-import * as Application from '../models/application.js';
-import { sendToApi } from '../models/send-to-api.js';
-import * as variables from '../models/variables.js';
-
-export async function list(params) {
-  const { alias, app: appIdOrName, format } = params.options;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  const publishedConfigs = await getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
-  const pairs = Object.entries(publishedConfigs).map(([name, value]) => ({ name, value }));
-
-  switch (format) {
-    case 'json': {
-      Logger.printJson(pairs);
-      break;
-    }
-    case 'shell':
-      Logger.println(toNameEqualsValueString(pairs, { addExports: true }));
-      break;
-    case 'human':
-    default: {
-      Logger.println('# Published configs');
-      Logger.println(toNameEqualsValueString(pairs, { addExports: false }));
-    }
-  }
-}
-
-export async function set(params) {
-  const [varName, varValue] = params.args;
-  const { alias, app: appIdOrName } = params.options;
-
-  const nameIsValid = validateName(varName);
-  if (!nameIsValid) {
-    throw new Error(`Published config name ${varName} is invalid`);
-  }
-
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  const publishedConfigs = await getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
-  publishedConfigs[varName] = varValue;
-  await updateAllExposedEnvVars({ id: ownerId, appId }, publishedConfigs).then(sendToApi);
-
-  Logger.println('Your published config item has been successfully saved');
-}
-
-export async function rm(params) {
-  const [varName] = params.args;
-  const { alias, app: appIdOrName } = params.options;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  const publishedConfigs = await getAllExposedEnvVars({ id: ownerId, appId }).then(sendToApi);
-  delete publishedConfigs[varName];
-  await updateAllExposedEnvVars({ id: ownerId, appId }, publishedConfigs).then(sendToApi);
-
-  Logger.println('Your published config item has been successfully removed');
-}
-
-export async function importEnv(params) {
-  const { alias, app: appIdOrName, json } = params.options;
-  const format = json ? 'json' : 'name-equals-value';
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  const publishedConfigs = await variables.readVariablesFromStdin(format);
-  await updateAllExposedEnvVars({ id: ownerId, appId }, publishedConfigs).then(sendToApi);
-
-  Logger.println('Your published configs have been set');
-}

package/src/commands/restart.js

@@ -1,52 +0,0 @@
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import * as Application from '../models/application.js';
-import * as ExitStrategy from '../models/exit-strategy-option.js';
-import * as git from '../models/git.js';
-import * as Log from '../models/log-v4.js';
-
-// Once the API call to redeploy() has been triggerred successfully,
-// the rest (waiting for deployment state to evolve and displaying logs) is done with auto retry (resilient to network pb)
-export async function restart(params) {
-  const {
-    alias,
-    app: appIdOrName,
-    quiet,
-    commit,
-    'without-cache': withoutCache,
-    follow,
-    'exit-on': exitOnDeploy,
-  } = params.options;
-
-  const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
-
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-  const fullCommitId = await git.resolveFullCommitId(commit);
-  const app = await Application.get(ownerId, appId);
-
-  if (app == null) {
-    throw new Error("The application doesn't exist");
-  }
-
-  const remoteCommitId = app.commitId;
-
-  const commitId = fullCommitId || remoteCommitId;
-  if (commitId != null) {
-    const cacheSuffix = withoutCache ? ' without using cache' : '';
-    Logger.println(`🔄 Restarting ${styleText('bold', app.name)}${cacheSuffix} ${styleText('grey', `(${commitId})`)}`);
-  }
-
-  // This should be handled by the API when a deployment ID is set but we'll do this for now
-  const redeployDate = new Date();
-
-  const redeploy = await Application.redeploy(ownerId, appId, fullCommitId, withoutCache);
-
-  return Log.watchDeploymentAndDisplayLogs({
-    ownerId,
-    appId,
-    deploymentId: redeploy.deploymentId,
-    quiet,
-    redeployDate,
-    exitStrategy,
-  });
-}

package/src/commands/scale.js

@@ -1,66 +0,0 @@
-import { Logger } from '../logger.js';
-import * as Application from '../models/application.js';
-
-function validateOptions(options) {
-  let { flavor, 'min-flavor': minFlavor, 'max-flavor': maxFlavor } = options;
-  let {
-    instances,
-    'min-instances': minInstances,
-    'max-instances': maxInstances,
-    'build-flavor': buildFlavor,
-  } = options;
-
-  if ([flavor, minFlavor, maxFlavor, instances, minInstances, maxInstances, buildFlavor].every((v) => v == null)) {
-    throw new Error('You should provide at least 1 option');
-  }
-
-  if (flavor != null) {
-    if (minFlavor != null || maxFlavor != null) {
-      throw new Error("You can't use --flavor and --min-flavor or --max-flavor at the same time");
-    }
-    minFlavor = flavor;
-    maxFlavor = flavor;
-  }
-
-  if (instances != null) {
-    if (minInstances != null || maxInstances != null) {
-      throw new Error("You can't use --instances and --min-instances or --max-instances at the same time");
-    }
-    minInstances = instances;
-    maxInstances = instances;
-  }
-
-  if (minInstances != null && maxInstances != null && minInstances > maxInstances) {
-    throw new Error("min-instances can't be greater than max-instances");
-  }
-
-  if (minFlavor != null && maxFlavor != null) {
-    const minFlavorIndex = Application.listAvailableFlavors().indexOf(minFlavor);
-    const maxFlavorIndex = Application.listAvailableFlavors().indexOf(maxFlavor);
-    if (minFlavorIndex > maxFlavorIndex) {
-      throw new Error("min-flavor can't be a greater flavor than max-flavor");
-    }
-  }
-
-  return { minFlavor, maxFlavor, minInstances, maxInstances, buildFlavor };
-}
-
-export async function scale(params) {
-  const { alias, app: appIdOrName } = params.options;
-  const { minFlavor, maxFlavor, minInstances, maxInstances, buildFlavor } = validateOptions(params.options);
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  await Application.setScalability(
-    appId,
-    ownerId,
-    {
-      minFlavor,
-      maxFlavor,
-      minInstances,
-      maxInstances,
-    },
-    buildFlavor,
-  );
-
-  Logger.println('App rescaled successfully');
-}

package/src/commands/service.js

@@ -1,105 +0,0 @@
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import * as Addon from '../models/addon.js';
-import * as Application from '../models/application.js';
-
-export async function list(params) {
-  const {
-    alias,
-    app: appIdOrName,
-    'show-all': showAll,
-    'only-apps': onlyApps,
-    'only-addons': onlyAddons,
-    format,
-  } = params.options;
-  if (onlyApps && onlyAddons) {
-    throw new Error('--only-apps and --only-addons are mutually exclusive');
-  }
-
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  const formattedServices = {};
-
-  if (!onlyAddons) {
-    const apps = await Application.listDependencies(ownerId, appId, showAll);
-    formattedServices.applications = apps.map((app) => ({
-      id: app.id,
-      name: app.name,
-      isLinked: app.isLinked,
-    }));
-  }
-
-  if (!onlyApps) {
-    const addons = await Addon.list(ownerId, appId, showAll);
-    formattedServices.addons = addons.map((addon) => ({
-      id: addon.id,
-      realId: addon.realId,
-      name: addon.name,
-      isLinked: addon.isLinked,
-    }));
-  }
-
-  switch (format) {
-    case 'json': {
-      Logger.printJson(formattedServices);
-      break;
-    }
-    case 'human':
-    default: {
-      const { applications = [], addons = [] } = formattedServices;
-
-      if (applications.length === 0 && addons.length === 0) {
-        Logger.printInfo(
-          `No linked services found, use ${styleText('blue', 'clever service link-app')} or ${styleText('blue', 'clever service link-addon')} to link services to an application`,
-        );
-        return;
-      }
-
-      if (applications.length > 0) {
-        Logger.println('Applications:');
-        applications.forEach(({ isLinked, name }) => Logger.println(`${isLinked ? '*' : ' '} ${name}`));
-      }
-
-      if (addons.length > 0) {
-        Logger.println('Addons:');
-        addons.forEach(({ isLinked, name, realId }) => Logger.println(`${isLinked ? '*' : ' '} ${name} (${realId})`));
-      }
-    }
-  }
-}
-
-export async function linkApp(params) {
-  const { alias, app: appIdOrName } = params.options;
-  const [dependency] = params.args;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  await Application.link(ownerId, appId, dependency);
-  Logger.println(`App ${dependency.app_id || dependency.app_name} successfully linked`);
-}
-
-export async function unlinkApp(params) {
-  const { alias, app: appIdOrName } = params.options;
-  const [dependency] = params.args;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  await Application.unlink(ownerId, appId, dependency);
-  Logger.println(`App ${dependency.app_id || dependency.app_name} successfully unlinked`);
-}
-
-export async function linkAddon(params) {
-  const { alias, app: appIdOrName } = params.options;
-  const [addon] = params.args;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  await Addon.link(ownerId, appId, addon);
-  Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully linked`);
-}
-
-export async function unlinkAddon(params) {
-  const { alias, app: appIdOrName } = params.options;
-  const [addon] = params.args;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  await Addon.unlink(ownerId, appId, addon);
-  Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully unlinked`);
-}

package/src/commands/ssh-keys.js

@@ -1,144 +0,0 @@
-import { todo_addSshKey as addSshKey, todo_removeSshKey as removeSshKey } from '@clevercloud/client/esm/api/v2/user.js';
-import dedent from 'dedent';
-import fs from 'node:fs';
-import { confirm } from '../lib/prompts.js';
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import { sendToApi } from '../models/send-to-api.js';
-import { getUserSshKeys } from '../models/ssh-keys.js';
-import { openBrowser } from '../models/utils.js';
-
-/**
- * List SSH keys 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 keys = await getUserSshKeys();
-
-  switch (format) {
-    case 'json': {
-      Logger.printJson(keys);
-      break;
-    }
-    case 'human':
-    default: {
-      if (keys.length === 0) {
-        Logger.println(dedent`
-          ${styleText('blue', '🔐 No SSH keys')}
-          
-          To list the SSH keys on your local system, use the following command:
-          ${styleText('grey', 'ssh-add -l -E sha256')}
-          
-          To create a new key pair, use the following command:
-          ${styleText('grey', 'ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_clever -C "An optional comment"')}
-          
-          Then add the public key to your Clever Cloud account:
-          ${styleText('grey', 'clever ssh-keys add myNewKey ~/.ssh/id_ed25519_clever.pub')}
-        `);
-        return;
-      }
-
-      Logger.println(`🔐 ${keys.length} SSH key(s):`);
-      keys.forEach((key) => {
-        Logger.println(` • ${styleText('blue', key.name)}`, styleText('grey', `(${key.fingerprint})`));
-      });
-    }
-  }
-}
-
-/**
- * Add a SSH key to the current user
- * @param {object} params The command parameters
- * @param {Array<string>} params.args
- */
-export async function add(params) {
-  const [keyName, filePath] = params.args;
-
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`File ${filePath} does not exist`);
-  }
-
-  const pubKeyContent = fs.readFileSync(filePath, 'utf8').trim();
-  Logger.debug(`SSH key file content: ${pubKeyContent}`);
-
-  try {
-    await addSshKey({ key: encodeURIComponent(keyName) }, JSON.stringify(pubKeyContent)).then(sendToApi);
-  } catch (e) {
-    console.log(e?.responseBody?.id);
-    if (e?.responseBody?.id === 505) {
-      throw new Error("This SSH key is not valid, please make sure you're pointing to the public key file");
-    }
-  }
-
-  Logger.printSuccess(`SSH key ${keyName} added successfully`);
-}
-
-/**
- * Remove a SSH key from the current user
- * @param {object} params The command parameters
- * @param {Array<string>} params.args
- */
-export async function remove(params) {
-  const [keyName] = params.args;
-
-  const keys = await getUserSshKeys();
-
-  if (keys.find((key) => key.name === keyName) == null) {
-    throw new Error(`SSH key ${styleText('red', keyName)} not found`);
-  }
-
-  const keyNameEncoded = encodeURIComponent(keyName);
-  await removeSshKey({ key: keyNameEncoded }).then(sendToApi);
-
-  Logger.printSuccess(`SSH key ${keyName} removed successfully`);
-}
-
-/**
- * Remove all SSH keys 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 removeAll(params) {
-  if (!params.options.yes) {
-    await confirm('Are you sure you want to remove all your SSH keys?', 'No SSH keys removed');
-  }
-
-  const keys = await getUserSshKeys();
-
-  if (keys.length === 0) {
-    Logger.println('No SSH keys to remove');
-    return;
-  }
-
-  const results = await Promise.all(
-    keys.map((key) => {
-      const keyNameEncoded = encodeURIComponent(key.name);
-      return removeSshKey({ key: keyNameEncoded })
-        .then(sendToApi)
-        .then(() => [true, key.name])
-        .catch(() => [false, key.name]);
-    }),
-  );
-
-  if (results.every(([isRemoved]) => isRemoved)) {
-    Logger.printSuccess('All SSH keys were removed successfully');
-  } else {
-    const keyNamesWithErrors = results
-      .filter(([isRemoved]) => !isRemoved)
-      .map(([_, keyName]) => keyName)
-      .join(', ');
-    throw new Error(`Some errors occured while removing these SSH keys: ${keyNamesWithErrors}`);
-  }
-}
-
-/**
- * Open the SSH keys 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/ssh-keys', 'Opening the SSH keys management page of the Console in your browser');
-}

package/src/commands/ssh.js

@@ -1,20 +0,0 @@
-import { spawn } from 'node:child_process';
-import * as Application from '../models/application.js';
-import { conf } from '../models/configuration.js';
-
-export async function ssh(params) {
-  const { alias, app: appIdOrName, 'identity-file': identityFile } = params.options;
-
-  const { appId } = await Application.resolveId(appIdOrName, alias);
-  const sshParams = ['-t', conf.SSH_GATEWAY, appId];
-  if (identityFile != null) {
-    sshParams.push('-i', identityFile);
-  }
-
-  await new Promise((resolve, reject) => {
-    // TODO: we should catch errors
-    const sshProcess = spawn('ssh', sshParams, { stdio: 'inherit' });
-    sshProcess.on('exit', resolve);
-    sshProcess.on('error', reject);
-  });
-}