clever-tools 3.10.1 → 3.12.0

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,49 @@ 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',
+  AUTH_BRIDGE_HOST: 'https://api-bridge.clever-cloud.com',
+  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/namespaces.js

@@ -1,9 +1,10 @@
 import * as Application from './application.js';
-import * as organisation from '@clevercloud/client/esm/api/v2/organisation.js';
+import { getNamespaces as getTcpRedirNamespaces } from '@clevercloud/client/esm/api/v2/organisation.js';
 import { sendToApi } from './send-to-api.js';
 import cliparse from 'cliparse';
+
 export async function getNamespaces (ownerId) {
-  return organisation.getNamespaces({ id: ownerId }).then(sendToApi);
+  return getTcpRedirNamespaces({ id: ownerId }).then(sendToApi);
 }
 
 export async function completeNamespaces () {

package/src/models/ng-resources.js

@@ -0,0 +1,270 @@
+import colors from 'colors/safe.js';
+import * as networkGroup from './ng.js';
+import * as networkGroupApi from '@clevercloud/client/esm/api/v4/network-group.js';
+
+import crypto from 'node:crypto';
+import { setTimeout } from 'node:timers/promises';
+import { Logger } from '../logger.js';
+import { sendToApi } from './send-to-api.js';
+import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+
+/**
+ * Create an external peer and link its parent member to the Network Group
+ * @param {object} ngIdOrLabel The Network Group ID or Label
+ * @param {string} peerLabel External peer label
+ * @param {string} publicKey External peer public key
+ * @param {object} org Organisation ID or name
+ * @throws {Error} If a valid peer label is not provided
+ * @throws {Error} If the Network Group is not found
+ * @throws {Error} If the parent member is not linked to the Network Group
+ * @throws {Error} If the external peer is not linked to the Network Group
+ */
+export async function createExternalPeerWithParent (ngIdOrLabel, peerLabel, publicKey, org) {
+
+  if (!peerLabel) {
+    throw new Error('A valid peer label is required');
+  }
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngResourceLabel)} not found`);
+  }
+
+  // We define a parent member for the external peer
+  const id = `external_${crypto.randomUUID()}`;
+  const parentMember = {
+    id,
+    label: `Parent of ${peerLabel}`,
+    domainName: `${id}.m.${ng.id}.${networkGroup.DOMAIN}`,
+    kind: 'EXTERNAL',
+  };
+
+  Logger.info(`Creating a parent member ${parentMember.id} linked to Network Group ${ng.id}`);
+  await linkMember({ ngId: ng.id }, parentMember.id, org, parentMember.label);
+
+  const checkParentMember = await checkResource(ng.id, org, parentMember.id, true);
+  if (!checkParentMember) {
+    throw new Error(`Parent member ${colors.red(parentMember.id)} not linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Parent member ${parentMember.id} created and linked to Network Group ${ng.id}`);
+
+  // We define the external peer, for now we only support client role
+  const body = {
+    peerRole: 'CLIENT',
+    publicKey,
+    label: peerLabel,
+    parentMember: parentMember.id,
+  };
+
+  Logger.info(`Adding external peer to Member ${parentMember.id} of Network Group ${ng.id}`);
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  await networkGroupApi.createNetworkGroupExternalPeer({ ownerId: ng.ownerId, networkGroupId: ng.id }, body).then(sendToApi);
+
+  const checkExternalPeer = await checkResource(ng.id, org, peerLabel, true, 'peer', 'label');
+  if (!checkExternalPeer) {
+    throw new Error(`External peer ${colors.red(peerLabel)} not linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`External peer ${peerLabel} added to Member ${parentMember.id} of Network Group ${ng.id}`);
+}
+
+/**
+ * Delete an external peer and its parent member from a Network Group
+ * @param {object} ngIdOrLabel Network Group ID or label
+ * @param {string} peerIdOrLabel External peer ID or label
+ * @param {object} org Organisation ID or name
+ * @throws {Error} If the Network Group is not found
+ * @throws {Error} If the External Peer is not found
+ * @throws {Error} If the External Peer is still linked to the Network Group
+ * @throws {Error} If the Parent Member is still linked to the Network Group
+ */
+export async function deleteExternalPeerWithParent (ngIdOrLabel, peerIdOrLabel, org) {
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngResourceLabel)} not found`);
+  }
+
+  const externalPeer = ng.peers.find((p) => {
+    return p.id === peerIdOrLabel || p.label === peerIdOrLabel;
+  });
+
+  if (!externalPeer) {
+    throw new Error(`External peer ${colors.red(peerIdOrLabel)} not found`);
+  }
+
+  Logger.info(`Deleting external peer ${externalPeer.id} from Network Group ${ng.id}`);
+  await networkGroupApi.deleteNetworkGroupExternalPeer({ ownerId: ng.ownerId, networkGroupId: ng.id, peerId: externalPeer.id }).then(sendToApi);
+
+  const checkPeer = await checkResource(ng.id, org, externalPeer.id, false, 'peer');
+  if (!checkPeer) {
+    throw new Error(`External peer ${colors.red(externalPeer.id)} still linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`External peer ${externalPeer.id} deleted from Network Group ${ng.id}`);
+  Logger.info(`Unlinking parent member ${externalPeer.parentMember} from Network Group ${ng.id}`);
+
+  await unlinkMember(ngIdOrLabel, externalPeer.parentMember, org);
+
+  const checkParentMember = await checkResource(ng.id, org, externalPeer.parentMember, false);
+  if (!checkParentMember) {
+    throw new Error(`Parent member ${colors.red(externalPeer.parentMember)} still linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Parent member ${externalPeer.parentMember} unlinked from Network Group ${ng.id}`);
+}
+
+/**
+ * Link a Member to a Network Group
+ * @param {object} ngIdOrLabel The Network group ID or Label
+ * @param {string} memberId ID of the Member to link
+ * @param {object} org Organisation ID or name
+ * @param {string} label Label of the Member
+ */
+export async function linkMember (ngIdOrLabel, memberId, org, label) {
+  if (!memberId) {
+    throw new Error('A valid member ID is required (addon_xxx, app_xxx, external_xxx)');
+  }
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngResourceLabel)} not found`);
+  }
+
+  await checkMembersToLink([memberId], ng.ownerId);
+
+  const alreadyMember = ng.members.find((m) => m.id === memberId);
+  if (alreadyMember) {
+    throw new Error(`Member ${colors.red(memberId)} is already linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  const [member] = networkGroup.constructMembers(ng.id, [memberId]);
+
+  const body = {
+    id: member.id,
+    label: label || member.label,
+    domainName: member.domainName,
+    kind: member.kind,
+  };
+
+  Logger.info(`Linking member ${member.id} to Network Group ${ng.id}`);
+  Logger.debug('Sending body: ' + JSON.stringify(body, null, 2));
+  await networkGroupApi.createNetworkGroupMember({ ownerId: ng.ownerId, networkGroupId: ng.id }, body).then(sendToApi);
+
+  const check = await checkResource(ng.id, org, member.id, true);
+  if (!check) {
+    throw new Error(`Member ${colors.red(member.id)} not linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Member ${member.id} linked to Network Group ${ng.id}`);
+}
+
+/**
+ * Unlink a Member from a Network Group
+ * @param {object} ngIdOrLabel The Network Group ID or Label
+ * @param {string} memberId The Member ID
+ * @param {object} org Organisation ID or name
+ * @throws {Error} If a valid member ID is not provided
+ * @throws {Error} If the Network Group is not found
+ * @throws {Error} If the Member is not found in the Network Group
+ * @throws {Error} If the Member is still linked to the Network Group
+ */
+export async function unlinkMember (ngIdOrLabel, memberId, org) {
+  if (!memberId) {
+    throw new Error('A valid member ID is required (addon_xxx, app_xxx, external_xxx)');
+  }
+
+  const [ng] = await networkGroup.searchNgOrResource(ngIdOrLabel, org, 'NetworkGroup');
+
+  if (!ng) {
+    throw new Error(`Network Group ${colors.red(ngIdOrLabel.ngId || ngIdOrLabel.ngLabel)} not found`);
+  }
+
+  const member = ng.members.find((m) => m.id === memberId);
+  if (!member) {
+    throw new Error(`Member ${colors.red(memberId)} not found in Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Unlinking member ${memberId} from Network Group ${ng.id}`);
+  await networkGroupApi.deleteNetworkGroupMember({ ownerId: ng.ownerId, networkGroupId: ng.id, memberId }).then(sendToApi);
+
+  const check = await checkResource(ng.id, org, memberId, false);
+  if (!check) {
+    throw new Error(`Member ${colors.red(memberId)} still linked to Network Group ${colors.red(ng.id)}`);
+  }
+
+  Logger.info(`Member ${memberId} unlinked from Network Group ${ng.id}`);
+}
+
+/**
+ * Check if members can be linked to a Network Group
+ * @param {Array<string>} members Members to check
+ * @throws {Error} If members can't be linked to a Network Group
+ */
+export async function checkMembersToLink (members, ownerId) {
+  const VALID_ADDON_PROVIDERS = [
+    'es-addon',
+    'mongodb-addon',
+    'mysql-addon',
+    'postgresql-addon',
+    'redis-addon',
+  ];
+
+  const summary = await getSummary().then(sendToApi);
+
+  let data = summary.user;
+  if (summary.user.id !== ownerId) {
+    data = summary.organisations.find((o) => o.id === ownerId);
+  }
+
+  const membersNotOK = [];
+  let source = data.applications;
+
+  for (const memberId of members) {
+    if (memberId.startsWith('addon_')) source = data.addons;
+
+    const foundRessource = source.find((r) => r.id === memberId);
+
+    if (foundRessource && memberId.startsWith('addon_') && !VALID_ADDON_PROVIDERS.includes(foundRessource.providerId)) {
+      membersNotOK.push(memberId);
+    }
+    else if (!foundRessource && !memberId.startsWith('external_')) {
+      membersNotOK.push(memberId);
+    }
+  }
+
+  if (membersNotOK.length > 0) {
+    throw new Error(`Member(s) ${colors.red(membersNotOK.join(', '))} can't be linked to the Network Group, check Organisation ID or name`);
+  }
+}
+
+/**
+ * Check if a resource is present in a Network Group by ID or label
+ * @param {string} ngId Network Group ID
+ * @param {object} org Organisation ID or name
+ * @param {string} resource Resource ID or label
+ * @param {boolean} shouldBePresent Expected presence of the resource
+ * @param {string} [resourceType] Resource type (member or peer), default is member
+ * @param {string} [searchBy] Search by 'id' or 'label', default is 'id'
+ * @returns {Promise<boolean>} True if the resource is present, false otherwise
+ */
+async function checkResource (ngId, org, resource, shouldBePresent, resourceType = 'member', searchBy = 'id') {
+  const endTime = Date.now() + networkGroup.POLLING_TIMEOUT_MS;
+
+  while (Date.now() < endTime) {
+    const ng = await networkGroup.getNG(ngId, org);
+    const items = resourceType === 'member' ? ng.members : ng.peers;
+    const isPresent = items.some((item) => item[searchBy] === resource);
+
+    if (isPresent === shouldBePresent) {
+      return true;
+    }
+
+    await setTimeout(networkGroup.POLLING_INTERVAL_MS);
+  }
+  return false;
+}