clever-tools 3.11.0 → 3.13.0

package/src/commands/ssh-keys.js

@@ -0,0 +1,159 @@
+import { confirm } from '../lib/prompts.js';
+import colors from 'colors/safe.js';
+import { Logger } from '../logger.js';
+import fs from 'node:fs';
+import { sendToApi } from '../models/send-to-api.js';
+import { openBrowser } from '../models/utils.js';
+import dedent from 'dedent';
+import {
+  todo_addSshKey as addSshKey,
+  todo_getSshKeys as getSshKeys,
+  todo_removeSshKey as removeSshKey,
+} from '@clevercloud/client/esm/api/v2/user.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`
+          ${colors.blue('🔐 No SSH keys')}
+          
+          To list the SSH keys on your local system, use the following command:
+          ${colors.grey('ssh-add -l -E sha256')}
+          
+          To create a new key pair, use the following command:
+          ${colors.grey('ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_clever -C "An optional comment"')}
+          
+          Then add the public key to your Clever Cloud account:
+          ${colors.grey('clever ssh-keys add myNewKey ~/.ssh/id_ed25519_clever.pub')}
+        `);
+        return;
+      }
+
+      Logger.println(`🔐 ${keys.length} SSH key(s):`);
+      keys.forEach((key) => {
+        Logger.println(` • ${colors.blue(key.name)}`, colors.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 ${colors.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');
+}
+
+/**
+ * @return {Promise<Array<{ name: string, key: string, fingerprint: string }>>}
+ */
+async function getUserSshKeys () {
+  const rawKeys = await getSshKeys().then(sendToApi);
+  return rawKeys.sort((a, b) => a.name.localeCompare(b.name));
+}

package/src/commands/stop.js

@@ -1,12 +1,12 @@
 import * as Application from '../models/application.js';
-import * as application from '@clevercloud/client/esm/api/v2/application.js';
 import { Logger } from '../logger.js';
 import { sendToApi } from '../models/send-to-api.js';
+import { undeploy as stopApplication } from '@clevercloud/client/esm/api/v2/application.js';
 
 export async function stop (params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
-  await application.undeploy({ id: ownerId, appId }).then(sendToApi);
-  Logger.println('App successfully stopped!');
+  await stopApplication({ id: ownerId, appId }).then(sendToApi);
+  Logger.printSuccess('Application successfully stopped!');
 }

package/src/commands/tcp-redirs.js

@@ -2,10 +2,10 @@ import colors from 'colors/safe.js';
 
 import * as Namespaces from '../models/namespaces.js';
 import { sendToApi } from '../models/send-to-api.js';
-import * as Interact from '../models/interact.js';
+import { confirm } from '../lib/prompts.js';
 import { Logger } from '../logger.js';
-import * as application from '@clevercloud/client/esm/api/v2/application.js';
 import * as Application from '../models/application.js';
+import { addTcpRedir, getTcpRedirs, removeTcpRedir } from '@clevercloud/client/esm/api/v2/application.js';
 
 export async function listNamespaces (params) {
   const { alias, app: appIdOrName, format } = params.options;
@@ -44,7 +44,7 @@ export async function list (params) {
   const { alias, app: appIdOrName, format } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
-  const redirs = await application.getTcpRedirs({ id: ownerId, appId }).then(sendToApi);
+  const redirs = await getTcpRedirs({ id: ownerId, appId }).then(sendToApi);
 
   switch (format) {
     case 'json': {
@@ -72,8 +72,8 @@ async function acceptPayment (result, skipConfirmation) {
     Logger.println(`Total (without taxes): ${result.totalHT}€`);
     Logger.println(colors.bold(`Total (with taxes): ${result.totalTTC}€`));
 
-    await Interact.confirm(
-      `You're about to pay ${result.totalTTC}€, confirm? (yes or no) `,
+    await confirm(
+      `You're about to pay ${result.totalTTC}€, confirm?`,
       'No confirmation, aborting TCP redirection creation',
     );
   }
@@ -83,10 +83,10 @@ export async function add (params) {
   const { alias, app: appIdOrName, namespace, yes: skipConfirmation } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
-  const { port } = await application.addTcpRedir({ id: ownerId, appId }, { namespace }).then(sendToApi).catch((error) => {
+  const { port } = await addTcpRedir({ id: ownerId, appId }, { namespace }).then(sendToApi).catch((error) => {
     if (error.status === 402) {
       return acceptPayment(error.response.body, skipConfirmation).then(() => {
-        return application.addTcpRedir({ id: ownerId, appId, payment: 'accepted' }, { namespace }).then(sendToApi);
+        return addTcpRedir({ id: ownerId, appId, payment: 'accepted' }, { namespace }).then(sendToApi);
       });
     }
     else {
@@ -102,7 +102,7 @@ export async function remove (params) {
   const { alias, app: appIdOrName, namespace } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
-  await application.removeTcpRedir({ id: ownerId, appId, sourcePort: port, namespace }).then(sendToApi);
+  await removeTcpRedir({ id: ownerId, appId, sourcePort: port, namespace }).then(sendToApi);
 
   Logger.println('Successfully removed tcp redirection.');
 };

package/src/commands/tokens.js

@@ -0,0 +1,146 @@
+import colors from 'colors/safe.js';
+import { Logger } from '../logger.js';
+import { createApiToken, deleteApiToken, listApiTokens } from '../clever-client/auth-bridge.js';
+import { sendToAuthBridge } from '../models/send-to-api.js';
+import { getCurrent as getCurrentUser } from '../models/user.js';
+import { conf } from '../models/configuration.js';
+import dedent from 'dedent';
+import { promptSecret } from '../lib/prompts.js';
+
+/**
+ * Create a new API token
+ * @param {Object} params - Function parameters
+ * @param {[string]} params.args - Command line args
+ * @param {Object} params.options - Command line options
+ * @param {'json'|'human'} params.options.format - Output format
+ * @param {number} params.options.expiration - Expiration date as timestamp
+ */
+export async function create (params) {
+  const [apiTokenName] = params.args;
+  const { expiration, format } = params.options;
+  const user = await getCurrentUser();
+
+  if (!user.hasPassword) {
+    const apiTokenListHref = new URL('/users/me/api-tokens', conf.CONSOLE_URL).href;
+    throw new Error(dedent`
+      ${colors.yellow('!')} Your Clever Cloud account is linked via GitHub and has no password. Setting one is required to create API tokens.
+      ${colors.blue('→')} To do so, go to the following URL: ${colors.blue(apiTokenListHref)}
+    `);
+  }
+
+  // Expire in 1 year
+  const dateObject = new Date();
+  dateObject.setFullYear(dateObject.getFullYear() + 1);
+  const maxExpirationDate = dateObject;
+
+  let expirationDate;
+  if (expiration != null) {
+    if (expiration > maxExpirationDate.getTime()) {
+      throw new Error('You cannot set an expiration date greater than 1 year');
+    }
+    expirationDate = new Date(expiration);
+  }
+  else {
+    expirationDate = maxExpirationDate;
+  }
+
+  const password = await promptSecret('Enter your password:');
+
+  let mfaCode;
+  if (user.preferredMFA === 'TOTP') {
+    mfaCode = await promptSecret('Enter your 2FA code:');
+  }
+
+  const tokenData = {
+    email: user.email,
+    password,
+    mfaCode,
+    name: apiTokenName,
+    expirationDate: expirationDate.toISOString(),
+  };
+  const createdToken = await createApiToken(tokenData).then(sendToAuthBridge).catch((error) => {
+    const errorCode = error?.cause?.responseBody?.code;
+    if (errorCode === 'invalid-credential') {
+      throw new Error('Invalid credentials, check your password');
+    }
+    if (errorCode === 'invalid-mfa-code') {
+      throw new Error('Invalid credentials, check your 2FA code');
+    }
+    throw error;
+  });
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(createdToken);
+      break;
+    case 'human':
+    default:
+      Logger.println(dedent`
+        ${colors.green('✔')} API token successfully created! Store it securely, you won't able to print it again.
+
+          - API token ID : ${colors.grey(createdToken.apiTokenId)}
+          - API token    : ${colors.grey(createdToken.apiToken)}
+          - Expiration   : ${colors.grey(formatDate(createdToken.expirationDate))}
+
+        Export this token and use it to make authenticated requests to the Clever Cloud API through the Auth Bridge:
+
+        export CC_API_TOKEN=${createdToken.apiToken}
+        curl -H "Authorization: Bearer $CC_API_TOKEN" ${conf.AUTH_BRIDGE_HOST}/v2/self
+
+        Then, to revoke this token, run:
+        clever tokens revoke ${createdToken.apiTokenId}
+      `);
+  }
+}
+
+/**
+ * Get information about an API token
+ * @param {Object} params - Function parameters
+ * @param {Object} params.options - Command line options
+ * @param {Object} params.options.format - Output format
+ * @returns {Promise<void>}
+ */
+export async function list (params) {
+  const { format } = params.options;
+
+  const tokens = await listApiTokens().then(sendToAuthBridge);
+
+  if (format === 'json') {
+    Logger.printJson(tokens);
+  }
+  else {
+    if (tokens.length === 0) {
+      Logger.println(`ℹ️  No API token found, create one with ${colors.blue('clever tokens create')} command`);
+    }
+    else {
+      console.table(tokens.map((token) => {
+        return {
+          'API token ID': token.apiTokenId,
+          Name: token.name,
+          'Creation IP address': token.ip,
+          Creation: formatDate(token.creationDate),
+          Expiration: formatDate(token.expirationDate),
+          State: token.state,
+        };
+      }));
+    }
+  }
+}
+
+/**
+ * Revoke an API token
+ * @param {Object} params - Function parameters
+ * @param {string[]} params.args - Command line arguments, token ID to revoke is expected as first argument
+ * @returns {Promise<void>}
+ */
+export async function revoke (params) {
+  const [apiTokenId] = params.args;
+
+  await deleteApiToken(apiTokenId).then(sendToAuthBridge);
+
+  Logger.println(colors.green('✔'), 'API token successfully revoked!');
+}
+
+function formatDate (dateInput) {
+  return new Date(dateInput).toISOString().substring(0, 16).replace('T', ' ');
+}

package/src/commands/unlink.js

@@ -1,11 +1,12 @@
 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 unlink (params) {
   const [alias] = params.args;
   const app = await AppConfig.getAppDetails({ alias });
 
   await Application.unlinkRepo(app.alias);
-  Logger.println('Your application has been successfully unlinked!');
+  Logger.printSuccess(`Application ${colors.green(app.appId)} has been successfully unlinked from local alias ${colors.green(app.alias)}!`);
 };

package/src/experimental-features.js

@@ -1,8 +1,10 @@
+import dedent from 'dedent';
+
 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: `
+    instructions: dedent`
       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
@@ -12,6 +14,49 @@ export const EXPERIMENTAL_FEATURES = {
           clever kv redis_xxxxx --org org_xxxxx PING
 
       Learn more about Materia KV: https://www.clever-cloud.com/developers/doc/addons/materia-kv/
-      `,
+    `,
+  },
+  ng: {
+    status: 'beta',
+    description: 'Manage Network Groups to manage applications, add-ons, external peers through a Wireguard network',
+    instructions: dedent`
+      - Create a Network Group:
+          clever ng create myNG
+      - Create a Network Group with members (application, database add-on):
+          clever ng create myNG --link app_xxx,addon_xxx
+      - List Network Groups:
+          clever ng
+      - Delete a Network Group:
+          clever ng delete myNG
+      - (Un)Link an application or a database add-on to an existing Network Group:
+          clever ng link app_xxx myNG
+          clever ng unlink addon_xxx myNG
+      - Get the Wireguard configuration of a peer:
+          clever ng get-config peerIdOrLabel myNG
+      - Get details about a Network Group, a member or a peer:
+          clever ng get myNg
+          clever ng get app_xxx
+          clever ng get peerId
+          clever ng get memberLabel
+      - Search Network Groups, members or peers:
+          clever ng search myQuery
+
+      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/ng-print.js

@@ -0,0 +1,195 @@
+import colors from 'colors/safe.js';
+import * as networkGroup from '../models/ng.js';
+
+import { Logger } from '../logger.js';
+
+/**
+ * Print a Network Group
+ * @param {Object} ng The Network Group to print
+ * @param {string} format Output format
+ * @param {boolean} full If true, get more details about the Network Group (default: false)
+ */
+function printNg (ng, format, full = false) {
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(ng);
+      break;
+    }
+    case 'human':
+    default: {
+      const ngData = {
+        ID: ng.id,
+        Label: ng.label,
+        Description: ng.description,
+        Network: `${ng.networkIp}`,
+        'Members/Peers': `${Object.keys(ng.members)?.length}/${Object.keys(ng.peers)?.length}`,
+      };
+
+      console.table(ngData);
+
+      if (full) {
+        const members = Object.entries(ng.members)
+          .sort((a, b) => a[1].domainName.localeCompare(b[1].domainName))
+          .map(([id, member]) => ({
+            Domain: member.domainName,
+          }));
+        if (members.length > 0) {
+          Logger.println(colors.bold(' • Members:'));
+          console.table(members);
+        }
+
+        const peers = Object.entries(ng.peers)
+          .sort((a, b) => a[1].parentMember.localeCompare(b[1].parentMember))
+          .map(([id, peer]) => formatPeer(peer));
+        if (peers.length > 0) {
+          Logger.println(colors.bold(' • Peers:'));
+          console.table(peers);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Print a Network Group member
+ * @param {Object} member The Network Group member to print
+ * @param {string} format Output format
+ */
+function printMember (member, format) {
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(member);
+      break;
+    }
+    case 'human':
+    default: {
+      console.table({
+        Label: member.label,
+        Domain: member.domainName,
+      });
+    }
+  }
+}
+
+/**
+ * Print a Network Group peer
+ * @param {Object} peer The Network Group peer to print
+ * @param {string} format Output format
+ * @param {boolean} full If true, get more details about the peer (default: false)
+ */
+function printPeer (peer, format, full = false) {
+  switch (format) {
+    case 'json': {
+      Logger.printJson(peer);
+      break;
+    }
+    case 'human':
+    default: {
+      console.table(formatPeer(peer, full));
+    }
+  }
+}
+
+/**
+ * Format a peer to print
+ * @param {Object} peer
+ * @param {boolean} full If true, get more details about the peer (default: false)
+ */
+function formatPeer (peer, full = false) {
+  const peerToPrint = {
+    'Parent Member': peer.parentMember,
+    ID: peer.id,
+    Label: peer.label,
+    Type: peer.type,
+  };
+
+  if (full) {
+    if (peer.endpoint.ngTerm != null) {
+      peerToPrint['Host:IP'] = `${peer.endpoint.ngTerm.host}:${peer.endpoint.ngTerm.port}`;
+    }
+    else {
+      peerToPrint.Host = peer.endpoint.ngIp;
+    }
+    if (peer.endpoint.publicTerm != null) {
+      peerToPrint['Public Term'] = `${peer.endpoint.publicTerm.host}:${peer.endpoint.publicTerm.port}`;
+    }
+    peerToPrint['Public Key'] = peer.publicKey;
+  }
+
+  return peerToPrint;
+}
+
+/** Print the results of a search or get action
+ * @param {object} idOrLabel ID or label of the Network Group, a member or a peer
+ * @param {object} org Organisation ID or name
+ * @param {string} format Output format
+ * @param {string} action Action to perform (search or get)
+ * @param {string} type Type of item to search (NetworkGroup, Member, Peer)
+ */
+export async function printResults (idOrLabel, org, format, action, type) {
+
+  const exactMatch = action === 'get';
+  const toLookFor = type ?? (action === 'search' ? 'all' : 'single');
+
+  const found = await networkGroup.searchNgOrResource(idOrLabel, org, toLookFor, exactMatch);
+
+  if (!found.length) {
+    const searchString = idOrLabel.ngId
+      ?? idOrLabel.memberId
+      ?? idOrLabel.ngResourceLabel;
+    Logger.println(`${colors.blue('!')} No Network Group or resource found for ${colors.blue(searchString)}`);
+    return;
+  }
+
+  if (found.length === 1) {
+    switch (found[0].type) {
+      case 'NetworkGroup':
+        return printNg(found[0], format, true);
+      case 'Member':
+        return printMember(found[0], format);
+      case 'CleverPeer':
+      case 'ExternalPeer':
+        return printPeer(found[0], format, true);
+      default:
+        throw new Error(`Unknown item type: ${found[0].type}`);
+    }
+  }
+
+  if (action === 'search') {
+    // Group found items by type in a new object
+    const grouped = found.reduce((acc, item) => {
+      if (!acc[item.type]) {
+        acc[item.type] = [];
+      }
+      acc[item.type].push(item);
+      return acc;
+    }, {});
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(grouped);
+        break;
+      }
+      case 'human':
+      default: {
+        if (grouped.NetworkGroup) {
+          Logger.println(`${colors.bold(` • Found ${grouped.NetworkGroup.length} Network Group(s):`)}`);
+          grouped.NetworkGroup?.forEach((item) => printNg(item, format));
+        }
+
+        if (grouped.Member) {
+          Logger.println(`${colors.bold(` • Found ${grouped.Member.length} Member(s):`)}`);
+          grouped.Member?.forEach((item) => printMember(item, format));
+        }
+
+        if (grouped.ExternalPeer || grouped.CleverPeer) {
+          Logger.println(`${colors.bold(` • Found ${grouped.ExternalPeer.length + grouped.CleverPeer.length} Peer(s):`)}`);
+          grouped.CleverPeer?.forEach((item) => printPeer(item, format));
+          grouped.ExternalPeer?.forEach((item) => printPeer(item, format));
+        }
+      }
+    }
+  }
+}