clever-tools 3.11.0 → 3.13.0

package/src/models/application_configuration.js

@@ -1,7 +1,6 @@
 import cliparse from 'cliparse';
-import colors from 'colors/safe.js';
-
 import { Logger } from '../logger.js';
+import dedent from 'dedent';
 
 const CONFIG_KEYS = [
   { id: 'name', name: 'name', displayName: 'Name', kind: 'string' },
@@ -10,31 +9,43 @@ const CONFIG_KEYS = [
   { id: 'sticky-sessions', name: 'stickySessions', displayName: 'Sticky sessions', kind: 'bool' },
   { id: 'cancel-on-push', name: 'cancelOnPush', displayName: 'Cancel current deployment on push', kind: 'bool' },
   { id: 'force-https', name: 'forceHttps', displayName: 'Force redirection of HTTP to HTTPS', kind: 'force-https' },
+  { id: 'task', name: 'instanceLifetime', displayName: 'Deploy an application as a Clever Task', kind: 'task' },
 ];
 
-export function listAvailableIds () {
-  return CONFIG_KEYS.map((config) => config.id);
+export function listAvailableIds (asText = false) {
+  const ids = CONFIG_KEYS.map((config) => config.id);
+  if (asText) {
+    return new Intl
+      .ListFormat('en', { style: 'short', type: 'disjunction' })
+      .format(ids);
+  }
+  return ids;
 }
 
 export function getById (id) {
   const config = CONFIG_KEYS.find((config) => config.id === id);
-  if (config == null) {
-    Logger.error(`Invalid configuration name: ${id}.`);
-    Logger.error(`Available configuration names are: ${listAvailableIds().join(', ')}.`);
+  if (config != null) {
+    return config;
   }
-  return config;
+  throw new Error(dedent`
+    Invalid configuration name: ${id}.
+    Available configuration names: ${listAvailableIds(true)}.
+  `);
 }
 
-function display (config, value) {
+export function formatValue (config, value) {
   switch (config.kind) {
     case 'bool': {
-      return (value) ? 'enabled' : 'disabled';
+      return value;
     }
     case 'inverted-bool': {
-      return (value) ? 'disabled' : 'enabled';
+      return !value;
     }
     case 'force-https': {
-      return value.toLowerCase();
+      return value === 'ENABLED';
+    }
+    case 'task': {
+      return value === 'TASK';
     }
     default: {
       return String(value);
@@ -44,14 +55,26 @@ function display (config, value) {
 
 export function parse (config, value) {
   switch (config.kind) {
-    case 'bool': {
-      return (value !== 'false');
-    }
-    case 'inverted-bool': {
-      return (value === 'false');
-    }
-    case 'force-https': {
-      return (value === 'false') ? 'DISABLED' : 'ENABLED';
+    case 'bool':
+    case 'inverted-bool':
+    case 'force-https':
+    case 'task': {
+      if (value !== 'true' && value !== 'false') {
+        throw new Error('Invalid configuration value, it must be a boolean (true or false)');
+      }
+      if (config.kind === 'bool') {
+        return (value === 'true');
+      }
+      if (config.kind === 'inverted-bool') {
+        return (value === 'false');
+      }
+      if (config.kind === 'force-https') {
+        return (value === 'true') ? 'ENABLED' : 'DISABLED';
+      }
+      if (config.kind === 'task') {
+        return (value === 'false') ? 'REGULAR' : 'TASK';
+      }
+      return;
     }
     default: {
       return value;
@@ -69,7 +92,8 @@ function getConfigOptions (config) {
   switch (config.kind) {
     case 'bool':
     case 'inverted-bool':
-    case 'force-https': {
+    case 'force-https':
+    case 'task': {
       return [
         cliparse.flag(`enable-${config.id}`, { description: `Enable ${config.id}` }),
         cliparse.flag(`disable-${config.id}`, { description: `Disable ${config.id}` }),
@@ -92,69 +116,45 @@ export function parseOptions (options) {
 
 function parseConfigOption (config, options) {
   switch (config.kind) {
-    case 'bool': {
-      const enable = options[`enable-${config.id}`];
-      const disable = options[`disable-${config.id}`];
-      if (enable && disable) {
-        Logger.warn(`${config.id} is both enabled and disabled, ignoring`);
-      }
-      else if (enable || disable) {
-        return [config.name, enable];
-      }
-      return null;
-    }
-    case 'inverted-bool': {
-      const disable = options[`enable-${config.id}`];
-      const enable = options[`disable-${config.id}`];
-      if (enable && disable) {
-        Logger.warn(`${config.id} is both enabled and disabled, ignoring`);
-      }
-      else if (enable || disable) {
-        return [config.name, enable];
-      }
-      return null;
-    }
-    case 'force-https': {
+    case 'bool':
+    case 'inverted-bool':
+    case 'force-https':
+    case 'task': {
       const enable = options[`enable-${config.id}`];
       const disable = options[`disable-${config.id}`];
       if (enable && disable) {
-        Logger.warn(`${config.id} is both enabled and disabled, ignoring`);
+        throw new Error(`You cannot use both --enable-${config.id} and --disable-${config.id} at the same time`);
       }
-      else if (enable || disable) {
-        const value = (enable) ? 'ENABLED' : 'DISABLED';
-        return [config.name, value];
+      if (enable || disable) {
+        if (config.kind === 'bool') {
+          return [config.name, enable];
+        }
+        if (config.kind === 'inverted-bool') {
+          return [config.name, disable];
+        }
+        if (config.kind === 'force-https' || config.kind === 'task') {
+          return [config.name, parse(config, String(enable))];
+        }
       }
-      return null;
+      return;
     }
     default: {
-      if (options[config.id] !== null) {
-        return [config.name, options[config.id]];
-      }
-      return null;
+      return [config.name, options[config.id]];
     }
   }
 }
 
-function printConfig (app, config) {
-  if (app[config.name] != null) {
-    Logger.println(`${config.displayName}: ${colors.bold(display(config, app[config.name]))}`);
-  }
-}
-
-export function printById (app, id) {
+export function printValue (app, id) {
   const config = getById(id);
-  if (config != null) {
-    printConfig(app, config);
-  }
+  Logger.println(formatValue(config, app[config.name]));
 }
 
-export function printByName (app, name) {
-  const config = CONFIG_KEYS.find((config) => config.name === name);
-  printConfig(app, config);
-}
-
-export function print (app) {
-  for (const config of CONFIG_KEYS) {
-    printConfig(app, config);
-  }
+export function printAllValues (app) {
+  console.table(
+    Object.fromEntries(
+      CONFIG_KEYS.map((config) => {
+        return [config.id, formatValue(config, app[config.name])];
+      }),
+    ),
+  );
 }

package/src/models/configuration.js

@@ -123,6 +123,7 @@ export async function setFeature (feature, value) {
 
 export const conf = env.getOrElseAll({
   API_HOST: 'https://api.clever-cloud.com',
+  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.

package/src/models/git.js

@@ -5,7 +5,7 @@ import _ from 'lodash';
 import git from 'isomorphic-git';
 import * as http from './isomorphic-http-with-agent.js';
 import cliparse from 'cliparse';
-import slugify from 'slugify';
+import { slugify } from '../lib/slugify.js';
 import { findPath } from './fs-utils.js';
 import { loadOAuthConf } from './configuration.js';
 
@@ -130,3 +130,31 @@ export async function isShallow () {
     return false;
   }
 }
+
+/**
+ * Check if the current directory is a git repository
+ * @returns {Promise<boolean>}
+ */
+export async function isInsideGitRepo () {
+  return getRepo()
+    .then(() => true)
+    .catch(() => false);
+}
+
+/**
+ * Check if the current git working directory is clean
+ * @returns {Promise<boolean>}
+ */
+export async function isGitWorkingDirectoryClean () {
+  const repo = await getRepo();
+  const status = await git.statusMatrix({ ...repo });
+  const isStatusEmpty = status
+    .filter(([filepath, head, workdir]) => {
+      // WARNING: isomorphic-git does not support global gitignore so we filter hidden files and dirs to reduce the amount of false positives
+      const isHidden = filepath.startsWith('.');
+      const isCleverJson = filepath === '.clever.json';
+      return (!isHidden || isCleverJson) && head !== workdir;
+    })
+    .length === 0;
+  return isStatusEmpty;
+}

package/src/models/ids-resolver.js

@@ -110,7 +110,7 @@ async function getIdsFromSummary () {
  * @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 }
+ * @returns {Object} The name, IDs and owner ID of the add-on { name, addonId, realId, ownerId }
  */
 export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId) {
   const summary = await getSummary().then(sendToApi);
@@ -128,7 +128,9 @@ export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId
       return matchOwner && matchAddon;
     })
     .map(({ addon, owner }) => ({
+      name: addon.name,
       addonId: addon.id,
+      realId: addon.realId,
       ownerId: owner.id,
     }));
 
@@ -139,3 +141,37 @@ export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId
 
   return candidates;
 }
+
+/**
+ * Get the IDs and owners of found add-ons from a name, ID or real ID
+ * @param {string} addonIdOrRealIdOrName
+ * @throws {Error} if no add-on is found
+ * @throws {Error} if several add-ons are found
+ * @returns {Object} The name, IDs and owner ID of the add-on { name, addonId, realId, ownerId }
+ */
+export async function findAddonsByAddonProvider (provider) {
+  const summary = await getSummary().then(sendToApi);
+
+  Logger.debug(`Searching for ${provider} add-ons in ${summary.user.id} and ${summary.organisations.map((org) => org.id).join(', ')}`);
+  const candidates = [summary.user, ...summary.organisations]
+    .flatMap((owner) => {
+      return owner.addons
+        .filter((addon) => addon.providerId === provider)
+        .map((addon) => {
+          return {
+            name: addon.name,
+            addonId: addon.id,
+            realId: addon.realId,
+            ownerId: owner.id,
+            ownerName: owner.name,
+          };
+        });
+    });
+
+  Logger.debug(`Found ${candidates.length} candidate(s) for provider ${provider}:`);
+  for (const candidate of candidates) {
+    Logger.debug(`  - ${candidate.addonId} (${candidate.ownerId})`);
+  }
+
+  return candidates;
+}

package/src/models/interact.js

@@ -1,24 +0,0 @@
-import readline from 'node:readline';
-
-function ask (question) {
-
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-
-export async function confirm (question, rejectionMessage, expectedAnswers = ['yes', 'y']) {
-  const answer = await ask(question);
-  if (!expectedAnswers.includes(answer)) {
-    throw new Error(rejectionMessage);
-  }
-  return true;
-}

package/src/models/log-v4.js

@@ -6,6 +6,8 @@ import { waitForDeploymentEnd, waitForDeploymentStart } from './deployments.js';
 import { ApplicationLogStream } from '@clevercloud/client/esm/streams/application-logs.js';
 import { JsonArray } from './json-array.js';
 import * as ExitStrategy from '../models/exit-strategy-option.js';
+import { getBest } from './domain.js';
+import { conf } from './configuration.js';
 
 // 2000 logs per 100ms maximum
 const THROTTLE_ELEMENTS = 2000;
@@ -98,9 +100,11 @@ export async function watchDeploymentAndDisplayLogs (options) {
 
   ExitStrategy.plotQuietWarning(exitStrategy, quiet);
   // If in quiet mode, we only log start/finished deployment messages
-  !quiet && Logger.println('Waiting for deployment to start…');
+  if (!quiet) {
+    Logger.println(`   ${colors.blue('→ Waiting for deployment to start…')}`);
+  }
   const deployment = await waitForDeploymentStart({ ownerId, appId, deploymentId, commitId, knownDeployments });
-  Logger.println(colors.bold.blue(`Deployment started (${deployment.uuid})`));
+  Logger.println(`   ${colors.green(`✓ Deployment started ${colors.grey(`(${deployment.uuid})`)}`)}`);
 
   if (exitStrategy === 'deploy-start') {
     return;
@@ -119,7 +123,9 @@ export async function watchDeploymentAndDisplayLogs (options) {
     logsStream = await displayLogs({ ownerId, appId, deploymentId: deployment.uuid, since: redeployDate, deferred });
   }
 
-  !quiet && Logger.println('Waiting for application logs…');
+  if (!quiet) {
+    Logger.println(`   ${colors.blue('→ Waiting for application logs…')}`);
+  }
 
   // Wait for deployment end (or an error thrown by logs with the deferred)
   const deploymentEnded = await Promise.race([
@@ -132,7 +138,10 @@ export async function watchDeploymentAndDisplayLogs (options) {
   }
 
   if (deploymentEnded.state === 'OK') {
-    Logger.println(colors.bold.green('Deployment successful'));
+    const favouriteDomain = await getBest(appId, ownerId);
+    Logger.println('');
+    Logger.println(`${colors.bold.green('✓ Access your application:')} ${colors.underline.bold(`https://${favouriteDomain.fqdn}`)}`);
+    Logger.println(`${colors.bold.blue('→ Manage your application:')} ${colors.underline.bold(`${conf.GOTO_URL}/${appId}`)}`);
   }
   else if (deploymentEnded.state === 'CANCELLED') {
     throw new Error('Deployment was cancelled. Please check the activity');

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;
+}