clever-tools 4.2.0 → 4.3.0

package/bin/clever.js

@@ -28,6 +28,7 @@ import * as drain from '../src/commands/drain.js';
 import * as emails from '../src/commands/emails.js';
 import * as env from '../src/commands/env.js';
 import * as features from '../src/commands/features.js';
+import * as k8s from '../src/commands/k8s.js';
 import * as keycloak from '../src/commands/keycloak.js';
 import * as kv from '../src/commands/kv.js';
 import * as link from '../src/commands/link.js';
@@ -99,6 +100,11 @@ function colorizeExperimentalCommand(command, id) {
 async function run() {
   // ARGUMENTS
   const args = {
+    k8sClusterName: cliparse.argument('cluster-name', { description: 'Kubernetes cluster name' }),
+    k8sIdOrName: cliparse.argument('id-or-name', {
+      description: 'Kubernetes cluster ID or name',
+      parser: Parsers.addonIdOrName,
+    }),
     kvRawCommand: cliparse.argument('command', {
       description: 'The raw command to send to the Materia KV or Redis® add-on',
     }),
@@ -196,6 +202,13 @@ async function run() {
 
   // OPTIONS
   const opts = {
+    k8sDeployWatch: cliparse.flag('watch', {
+      aliases: ['w'],
+      description: 'Watch the deployment until the cluster is deployed',
+    }),
+    kubeConfigForceDownload: cliparse.flag('force', {
+      description: 'Force the download of the kubeconfig file, even if it already exists',
+    }),
     targetVersion: cliparse.option('target', {
       metavar: 'version',
       description: 'Target version to upgrade to (e.g.: 24, 2.4, 2.4.1)',
@@ -1043,6 +1056,73 @@ async function run() {
     features.list,
   );
 
+  // K8S COMMAND
+  const k8sListCommand = cliparse.command(
+    'list',
+    {
+      description: 'List Kubernetes clusters',
+      options: [opts.orgaIdOrName, opts.humanJsonOutputFormat],
+    },
+    k8s.list,
+  );
+  const k8sCreateCommand = cliparse.command(
+    'create',
+    {
+      description: 'Create a Kubernetes cluster',
+      args: [args.k8sClusterName],
+      options: [opts.orgaIdOrName, opts.k8sDeployWatch],
+    },
+    k8s.create,
+  );
+  const k8sDeleteCommand = cliparse.command(
+    'delete',
+    {
+      description: 'Delete a Kubernetes cluster',
+      options: [opts.orgaIdOrName, opts.confirmAddonDeletion],
+      args: [args.k8sIdOrName],
+    },
+    k8s.del,
+  );
+  const k8sGetCommand = cliparse.command(
+    'get',
+    {
+      description: 'Get information about a Kubernetes cluster',
+      args: [args.k8sIdOrName],
+      options: [opts.orgaIdOrName, opts.humanJsonOutputFormat],
+    },
+    k8s.get,
+  );
+  const k8sGetConfigCommand = cliparse.command(
+    'get-kubeconfig',
+    {
+      description: 'Get configuration of a Kubernetes cluster',
+      args: [args.k8sIdOrName],
+      options: [opts.orgaIdOrName],
+    },
+    k8s.getConfig,
+  );
+  const k8sAddPersistentStorageCommand = cliparse.command(
+    'add-persistent-storage',
+    {
+      description: 'Activate persistent storage to a deployed Kubernetes cluster',
+      args: [args.k8sIdOrName],
+      options: [opts.orgaIdOrName],
+    },
+    k8s.addPersistentStorage,
+  );
+
+  const k8sCommand = cliparse.command('k8s', {
+    description: 'Manage Kubernetes clusters',
+    commands: [
+      k8sListCommand,
+      k8sCreateCommand,
+      k8sAddPersistentStorageCommand,
+      k8sDeleteCommand,
+      k8sGetCommand,
+      k8sGetConfigCommand,
+    ],
+  });
+
   // KEYCLOAK COMMAND
   const keycloakGetCommand = cliparse.command(
     'get',
@@ -2048,6 +2128,10 @@ async function run() {
     commands.push(colorizeExperimentalCommand(otoroshiCommand, 'operators'));
   }
 
+  if (featuresFromConf.k8s) {
+    commands.push(colorizeExperimentalCommand(k8sCommand, 'k8s'));
+  }
+
   if (featuresFromConf.kv) {
     commands.push(colorizeExperimentalCommand(kvRawCommand, 'kv'));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clever-tools",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Command Line Interface for Clever Cloud.",
   "keywords": [
     "cli",

package/src/clever-client/k8s.js

@@ -0,0 +1,96 @@
+// TODO: Move this to the Clever Cloud JS Client
+
+/**
+ * POST /v4/kubernetes/organisations/{ownerId}/clusters
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {Object} body
+ */
+export function createK8sCluster(params, body) {
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters`,
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    // no queryParams
+    body,
+  });
+}
+
+/**
+ * DELETE /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ */
+export function deleteK8sCluster(params) {
+  return Promise.resolve({
+    method: 'delete',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/clusters
+ * @param {Object} params
+ * @param {String} params.ownerId
+ */
+export function listK8sClusters(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ */
+export function getK8sAddon(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/kubeconfig.yaml
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ */
+export function getK8sConfig(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/kubeconfig.yaml`,
+    // headers: { Accept: 'application/x-yaml' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/kubernetes/organisations/ownerId}/clusters/{clusterId}/csi/ceph
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ */
+export function addK8sPersistentStorage(params) {
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/csi/ceph`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}

package/src/commands/k8s.js

@@ -0,0 +1,193 @@
+import { typewriterLogo } from '../lib/ascii.js';
+import {
+  getK8sCluster,
+  isK8sClusterActive,
+  k8sAddPersistentStorage,
+  k8sCreate,
+  k8sDelete,
+  k8sGetConfig,
+  k8sList,
+} from '../lib/k8s.js';
+import { confirm } from '../lib/prompts.js';
+import { styleText } from '../lib/style-text.js';
+import { Logger } from '../logger.js';
+
+const DEPLOY_POLL_DELAY_MS = 10000;
+
+export async function create(params) {
+  const clusterName = params.args[0];
+  const orgIdOrName = params.options.org;
+
+  try {
+    const cluster = await k8sCreate(clusterName, orgIdOrName);
+
+    if (params.options.watch) {
+      await typewriterLogo();
+
+      let deployedCluster = cluster;
+      while (deployedCluster.status !== 'ACTIVE' && deployedCluster.status !== 'FAILED') {
+        Logger.println(
+          `⏳ Cluster status: ${styleText('yellow', deployedCluster.status)}. Waiting for ${DEPLOY_POLL_DELAY_MS / 1000}s before checking again...`,
+        );
+        await new Promise((resolve) => setTimeout(resolve, DEPLOY_POLL_DELAY_MS));
+
+        deployedCluster = await getK8sCluster(orgIdOrName, cluster.id);
+      }
+
+      Logger.println('');
+      switch (deployedCluster.status) {
+        case 'ACTIVE':
+          Logger.printSuccess(
+            `Cluster ${styleText('green', `${deployedCluster.name} (${deployedCluster.id})`)} deployed successfully`,
+          );
+          break;
+        case 'FAILED':
+          throw new Error(
+            `Cluster ${styleText('red', `${deployedCluster.name} (${deployedCluster.id})`)} deployment failed`,
+          );
+        default:
+          throw new Error(`Unexpected cluster status: ${deployedCluster.status}`);
+      }
+    } else {
+      Logger.println(`🚀 Cluster ${styleText('white', `${cluster.name} (${cluster.id})`)} is being deployed`);
+    }
+
+    const orgMessageComplement = orgIdOrName ? `--org "${orgIdOrName.orga_id || orgIdOrName.orga_name}"` : '';
+
+    Logger.println('');
+    Logger.println(
+      `You can get its information with ${styleText('blue', `clever k8s get ${cluster.id} ${orgMessageComplement}`)}`,
+    );
+  } catch (error) {
+    if (error.responseBody?.code === 'clever.core.quota-exceeded') {
+      throw new Error(
+        'Failed to create Kubernetes cluster: your quota exceeded, contact support to increase your quota',
+      );
+    } else {
+      throw new Error(error.message);
+    }
+  }
+}
+
+export async function del(params) {
+  const [clusterIdOrName] = params.args;
+  const { org: orgIdOrName, yes: confirmDeletion } = params.options;
+
+  let proceedDeletion = false;
+  if (confirmDeletion) {
+    proceedDeletion = true;
+  } else {
+    proceedDeletion = await confirm(
+      `Are you sure you want to delete the Kubernetes cluster ${styleText(
+        'blue',
+        clusterIdOrName.addon_name || clusterIdOrName.operator_id,
+      )}?`,
+      'Kubernetes cluster deletion cancelled.',
+    );
+  }
+
+  if (proceedDeletion) {
+    await k8sDelete(orgIdOrName, clusterIdOrName);
+    Logger.printSuccess(
+      `Kubernetes cluster ${styleText('green', clusterIdOrName.addon_name || clusterIdOrName.operator_id)} successfully deleted`,
+    );
+  }
+}
+
+export async function list(params) {
+  const { format, org: orgIdOrName } = params.options;
+  const clusters = await k8sList(orgIdOrName, format);
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(clusters);
+      break;
+    case 'human':
+    default:
+      if (clusters.length === 0) {
+        Logger.println(`🔎 No cluster found, create one with ${styleText('blue', `clever k8s create`)} command`);
+        return;
+      }
+
+      Logger.println(`🔎 Found ${clusters.length} cluster${clusters.length > 1 ? 's' : ''}:`);
+
+      Object.values(clusters).forEach((c) => {
+        Logger.println(`  • ${styleText('white', `${c.name} (${c.id})`)} - ${c.status}`);
+      });
+      break;
+  }
+}
+
+export async function get(params) {
+  const [clusterIdOrName] = params.args;
+  const { format, org: orgIdOrName } = params.options;
+
+  const k8sInfo = await getK8sCluster(orgIdOrName, clusterIdOrName);
+
+  switch (format) {
+    case 'json':
+      Logger.printJson(k8sInfo);
+      break;
+    case 'human':
+    default:
+      console.table({
+        Name: k8sInfo.name,
+        ID: k8sInfo.id,
+        Version: k8sInfo.version,
+        Status: k8sInfo.status,
+      });
+
+      Logger.println('');
+      const orgMessageComplement = orgIdOrName ? `--org "${orgIdOrName.orga_id || orgIdOrName.orga_name}"` : '';
+
+      Logger.println(
+        `Once ACTIVE, get the kubeconfig with ${styleText('blue', `clever k8s get-kubeconfig ${k8sInfo.id} ${orgMessageComplement}`)}`,
+      );
+      break;
+  }
+}
+
+export async function addPersistentStorage(params) {
+  const [clusterIdOrName] = params.args;
+  const orgIdOrName = params.options.org;
+
+  if ((await isK8sClusterActive(orgIdOrName, clusterIdOrName)) === false) {
+    Logger.printInfo(
+      'Persistent storage can only be added to deployed clusters, wait for the deployment to finish and try again',
+    );
+
+    const orgMessageComplement = orgIdOrName ? `--org "${orgIdOrName.orga_id || orgIdOrName.orga_name}"` : '';
+    Logger.println(
+      `Check with ${styleText('blue', `clever k8s get ${clusterIdOrName.addon_name || clusterIdOrName.operator_id} ${orgMessageComplement}`)}`,
+    );
+    return;
+  }
+
+  try {
+    await k8sAddPersistentStorage(orgIdOrName, clusterIdOrName);
+    Logger.printSuccess(
+      `Persistent storage successfully activated on cluster ${styleText('green', clusterIdOrName.addon_name || clusterIdOrName.operator_id)}`,
+    );
+  } catch (error) {
+    Logger.error("Failed to add persistent storage, check if it's not already activated");
+  }
+}
+
+export async function getConfig(params) {
+  const [clusterIdOrName] = params.args;
+  const orgIdOrName = params.options.org;
+
+  if ((await isK8sClusterActive(orgIdOrName, clusterIdOrName)) !== true) {
+    Logger.printInfo(
+      'Kubeconfig can only be retrieved from deployed clusters, wait for the deployment to finish and try again',
+    );
+
+    const orgMessageComplement = orgIdOrName ? `--org "${orgIdOrName.orga_id || orgIdOrName.orga_name}"` : '';
+    Logger.println(
+      `Check with ${styleText('blue', `clever k8s get ${clusterIdOrName.addon_name || clusterIdOrName.operator_id} ${orgMessageComplement}`)}`,
+    );
+    return;
+  }
+
+  console.log(await k8sGetConfig(orgIdOrName, clusterIdOrName));
+}

package/src/experimental-features.js

@@ -2,6 +2,33 @@ import dedent from 'dedent';
 import { conf } from './models/configuration.js';
 
 export const EXPERIMENTAL_FEATURES = {
+  k8s: {
+    status: 'beta',
+    description: 'Deploy and manage Kubernetes clusters on Clever Cloud',
+    instructions: dedent`
+      - Create a Kubernetes cluster:
+          clever k8s create my-cluster
+          clever k8s create my-cluster --org myOrg
+
+      - List Kubernetes clusters:
+          clever k8s list
+
+      - Get details about a Kubernetes cluster:
+          clever k8s get my-cluster
+
+      - Get kubeconfig file for a Kubernetes cluster:
+          clever k8s get-kubeconfig my-cluster
+          clever k8s get-kubeconfig my-cluster > ~/.kube/config
+
+      - Activate persistent storage on a Kubernetes cluster:
+          clever k8s add-persistent-storage my-cluster
+
+      - Delete a Kubernetes cluster:
+          clever k8s delete my-cluster
+
+      Learn more about Clever Kubernetes: ${conf.DOC_URL}/kubernetes/
+    `,
+  },
   kv: {
     status: 'beta',
     description:

package/src/lib/ascii.js

@@ -0,0 +1,48 @@
+import { styleText } from './style-text.js';
+
+const LOGO = styleText(
+  'green',
+  `
+ ██████╗██╗     ███████╗██╗   ██╗███████╗██████╗     ██╗  ██╗ █████╗ ███████╗
+██╔════╝██║     ██╔════╝██║   ██║██╔════╝██╔══██╗    ██║ ██╔╝██╔══██╗██╔════╝
+██║     ██║     █████╗  ██║   ██║█████╗  ██████╔╝    █████╔╝ ╚█████╔╝███████╗
+██║     ██║     ██╔══╝  ╚██╗ ██╔╝██╔══╝  ██╔══██╗    ██╔═██╗ ██╔══██╗╚════██║
+╚██████╗███████╗███████╗ ╚████╔╝ ███████╗██║  ██║    ██║  ██╗╚█████╔╝███████║
+ ╚═════╝╚══════╝╚══════╝  ╚═══╝  ╚══════╝╚═╝  ╚═╝    ╚═╝  ╚═╝ ╚════╝ ╚══════╝
+
+ Your Clever Cloud Kubernetes cluster has been successfully created, it's now starting up!
+
+ It will take about 1 minute. To manage it, use the following commands:
+   - clever k8s list                                  List your Kubernetes clusters
+   - clever k8s get <cluster-id-or-name>              Get information about a specific cluster
+   - clever k8s get-kubeconfig <cluster-id-or-name>   Get the kubeconfig file for your cluster
+   - clever k8s delete <cluster-id-or-name>           Delete a specific cluster
+
+ Learn more about commands with 'clever k8s --help'
+
+ For more information, read the documentation https://www.clever.cloud/developers/doc/kubernetes/
+
+ Enjoy!
+`,
+);
+
+// const clearScreen = () => process.stdout.write('\x1B[2J\x1B[0f');
+const hideCursor = () => process.stdout.write('\x1B[?25l');
+const showCursor = () => process.stdout.write('\x1B[?25h');
+const sleep = (ms = 42) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export async function typewriterLogo() {
+  hideCursor();
+
+  const lines = LOGO.split('\n');
+
+  for (const line of lines) {
+    for (const char of line) {
+      process.stdout.write(char);
+      await sleep();
+    }
+    console.log();
+  }
+
+  showCursor();
+}

package/src/lib/k8s.js

@@ -0,0 +1,126 @@
+import { styleText } from './style-text.js';
+
+import {
+  addK8sPersistentStorage,
+  createK8sCluster,
+  deleteK8sCluster,
+  getK8sAddon,
+  getK8sConfig,
+  listK8sClusters,
+} from '../clever-client/k8s.js';
+import { getOwnerIdFromOrgIdOrName } from '../models/ids-resolver.js';
+import { sendToApi } from '../models/send-to-api.js';
+
+/**
+ * Check if a Kubernetes cluster status is ACTIVE
+ * @param {string} orgIdOrName The organisation ID or name
+ * @param {string} clusterIdOrName The cluster ID or name
+ * @returns {Promise<boolean>} True if the cluster is deployed, false otherwise
+ */
+export async function isK8sClusterActive(orgIdOrName, clusterIdOrName) {
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgIdOrName);
+  const clusterId = await getClusterIdFromAddonIdOrName(clusterIdOrName, ownerId);
+  const cluster = await getK8sAddon({ ownerId, clusterId }).then(sendToApi);
+
+  return cluster.status === 'ACTIVE';
+}
+
+/**
+ * Create a kubernetes cluster
+ * @param {string} name The name of the cluster
+ * @param {string} ownerId The owner ID
+ * @returns {Promise<void>}
+ */
+export async function k8sCreate(name, ownerId) {
+  ownerId = await getOwnerIdFromOrgIdOrName(ownerId);
+
+  return createK8sCluster({ ownerId }, { name }).then(sendToApi);
+}
+
+/**
+ * List all kubernetes addons
+ * @param {string} format The output format
+ * @returns {Promise<void>}
+ */
+export async function k8sList(orgIdOrName, format) {
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgIdOrName);
+  const deployed = await listK8sClusters({ ownerId }).then(sendToApi);
+
+  return deployed.filter((op) => op.status != 'DELETED');
+}
+
+/**
+ * Get information about a kubernetes cluster
+ * @param {string} orgIdOrName The organisation ID or name
+ * @param {string} clusterIdOrName The cluster ID or name
+ * @returns {Promise<object>} The kubernetes cluster information
+ */
+export async function getK8sCluster(orgIdOrName, clusterIdOrName) {
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgIdOrName);
+  const clusterId = await getClusterIdFromAddonIdOrName(clusterIdOrName, ownerId);
+
+  return getK8sAddon({ ownerId, clusterId }).then(sendToApi);
+}
+
+/**
+ * Get Kubernetes cluster configuration
+ * @param {string} orgIdOrName The organisation ID or name
+ * @param {string} clusterIdOrName The cluster ID or name
+ * @returns {Promise<string>} The kubeconfig.yaml content
+ */
+export async function k8sGetConfig(orgIdOrName, clusterIdOrName) {
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgIdOrName);
+  const clusterId = await getClusterIdFromAddonIdOrName(clusterIdOrName, ownerId);
+
+  return getK8sConfig({ ownerId, clusterId }).then(sendToApi);
+}
+
+/**
+ * Delete a kubernetes cluster
+ * @param {string} orgIdOrName The organisation ID or name
+ * @param {string} clusterIdOrName The cluster ID or name
+ * @returns {Promise<void>}
+ */
+export async function k8sDelete(orgIdOrName, clusterIdOrName) {
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgIdOrName);
+  const clusterId = await getClusterIdFromAddonIdOrName(clusterIdOrName, ownerId);
+
+  return deleteK8sCluster({ ownerId, clusterId }).then(sendToApi);
+}
+
+/**
+ * Get Kubernetes cluster ID from an addon ID or name
+ * @param {string|object} addonIdOrName The addon ID or name
+ * @param {string} ownerId The owner ID
+ * @returns {Promise<string>} The Kubernetes cluster ID
+ */
+export async function getClusterIdFromAddonIdOrName(addonIdOrName, ownerId) {
+  if (typeof addonIdOrName === 'string') {
+    return addonIdOrName;
+  } else if (typeof addonIdOrName === 'object' && addonIdOrName.operator_id) {
+    return addonIdOrName.operator_id;
+  } else if (typeof addonIdOrName === 'object' && addonIdOrName.addon_name) {
+    const clusters = await listK8sClusters({ ownerId }).then(sendToApi);
+    const matchingCluster = clusters.find((cluster) => cluster.name === addonIdOrName.addon_name);
+    if (matchingCluster) {
+      return matchingCluster.id;
+    } else {
+      throw new Error(`No Kubernetes cluster found with the name ${styleText('red', addonIdOrName.addon_name)}`);
+    }
+  } else {
+    throw new Error('Invalid Kubernetes Cluster identifier provided');
+  }
+}
+
+/**
+ * Add persistent storage to a deployed Kubernetes cluster
+ * @param {string} orgIdOrName The organisation ID or name
+ * @param {string} clusterIdOrName The cluster ID or name
+ * @returns {Promise<void>}
+ */
+export async function k8sAddPersistentStorage(orgIdOrName, clusterIdOrName) {
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgIdOrName);
+  const clusterId = await getClusterIdFromAddonIdOrName(clusterIdOrName, ownerId);
+
+  return addK8sPersistentStorage({ ownerId, clusterId }).then(sendToApi);
+}

package/src/lib/prompts.js

@@ -9,6 +9,8 @@ export async function confirm(message, rejectionMessage) {
   if (!answer) {
     throw new Error(rejectionMessage);
   }
+
+  return answer;
 }
 
 export async function confirmAnswer(message, rejectionMessage, expectedAnswer) {

package/src/models/ids-resolver.js

@@ -1,6 +1,8 @@
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
 import { Logger } from '../logger.js';
+import * as User from '../models/user.js';
 import { loadIdsCache, writeIdsCache } from './configuration.js';
+import * as Organisation from './organisation.js';
 import { sendToApi } from './send-to-api.js';
 
 /*
@@ -171,3 +173,12 @@ export async function findAddonsByAddonProvider(provider) {
 
   return candidates;
 }
+
+/**
+ * Get the owner ID from an Organisation ID or name
+ * @param {object} orgIdOrName The Organisation ID or name
+ * @returns {Promise<string>} The owner ID
+ */
+export async function getOwnerIdFromOrgIdOrName(orgIdOrName) {
+  return orgIdOrName != null ? Organisation.getId(orgIdOrName) : User.getCurrentId();
+}

package/src/models/ng.js

@@ -9,10 +9,9 @@ import crypto from 'node:crypto';
 import { searchNetworkGroupOrResource } from '../clever-client/ng.js';
 import { styleText } from '../lib/style-text.js';
 import { Logger } from '../logger.js';
+import { getOwnerIdFromOrgIdOrName } from './ids-resolver.js';
 import { checkMembersToLink } from './ng-resources.js';
-import * as Organisation from './organisation.js';
 import { sendToApi } from './send-to-api.js';
-import * as User from './user.js';
 
 export const POLLING_TIMEOUT_MS = 30_000;
 export const POLLING_INTERVAL_MS = 1000;
@@ -38,7 +37,7 @@ export const NG_MEMBER_PREFIXES = {
  */
 export async function create(label, description, tags, membersIds, orgaIdOrName) {
   const id = `ng_${crypto.randomUUID()}`;
-  const ownerId = await getOwnerIdFromOrgaIdOrName(orgaIdOrName);
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgaIdOrName);
 
   if (membersIds?.length > 0) {
     checkMembersToLink(membersIds);
@@ -126,7 +125,7 @@ export async function getPeerConfig(peerIdOrLabel, ngIdOrLabel, orgaIdOrName) {
  * @returns {Promise<Array<Object>>} The Network Groups
  */
 export async function getNG(networkGroupId, orgaIdOrName) {
-  const ownerId = await getOwnerIdFromOrgaIdOrName(orgaIdOrName);
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgaIdOrName);
 
   Logger.info(`Get Network Group ${networkGroupId} for owner ${ownerId}`);
   const result = await getNetworkGroup({ networkGroupId, ownerId }).then(sendToApi);
@@ -141,7 +140,7 @@ export async function getNG(networkGroupId, orgaIdOrName) {
  * @returns {Promise<Array<Object>>} The Network Groups
  */
 export async function getAllNGs(orgaIdOrName) {
-  const ownerId = await getOwnerIdFromOrgaIdOrName(orgaIdOrName);
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgaIdOrName);
 
   Logger.info(`Listing Network Groups from owner ${ownerId}`);
   const result = await listNetworkGroups({ ownerId }).then(sendToApi);
@@ -159,7 +158,7 @@ export async function getAllNGs(orgaIdOrName) {
  * @returns {Promise<Object>} Found results
  */
 export async function searchNgOrResource(idOrLabel, orgaIdOrName, type = 'all', exactMatch = true) {
-  const ownerId = await getOwnerIdFromOrgaIdOrName(orgaIdOrName);
+  const ownerId = await getOwnerIdFromOrgIdOrName(orgaIdOrName);
 
   // If idOrLabel is a string we use it, or we look through multiple keys
   const query =
@@ -265,12 +264,3 @@ async function pollNetworkGroup(ownerId, ngId, { waitForMembers = null, waitForD
     pollOnce();
   });
 }
-
-/**
- * Get the owner ID from an Organisation ID or name
- * @param {object} orgaIdOrName The Organisation ID or name
- * @returns {Promise<string>} The owner ID
- */
-async function getOwnerIdFromOrgaIdOrName(orgaIdOrName) {
-  return orgaIdOrName != null ? Organisation.getId(orgaIdOrName) : User.getCurrentId();
-}

package/src/parsers.js

@@ -100,12 +100,13 @@ export function orgaIdOrName(string) {
 const addonIdRegex = /^addon_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const operatorIdRegex =
   /^(keycloak|otoroshi|matomo|metabase)_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ulidRegex = /^(kubernetes)_[0-9A-HJ-NP-TV-Z]{26}$/i;
 
 export function addonIdOrName(string) {
   if (string.match(addonIdRegex)) {
     return cliparse.parsers.success({ addon_id: string });
   }
-  if (string.match(operatorIdRegex)) {
+  if (string.match(operatorIdRegex) || string.match(ulidRegex)) {
     return cliparse.parsers.success({ operator_id: string });
   }
   return cliparse.parsers.success({ addon_name: string });