clever-tools 4.2.0 → 4.4.0

package/src/commands/drain.js

@@ -1,108 +1,164 @@
-import { createDrain, deleteDrain, getDrains, updateDrainState } from '@clevercloud/client/esm/api/v2/log.js';
+import { createDrain, deleteDrain, disableDrain, enableDrain, getDrain, getDrains } from '../clever-client/drains.js';
+import { styleText } from '../lib/style-text.js';
 import { Logger } from '../logger.js';
 import * as Application from '../models/application.js';
-import { createDrainBody } from '../models/drain.js';
+import { DRAIN_TYPE_CLI_CODES, DRAIN_TYPES, formatDrain } from '../models/drain.js';
 import { sendToApi } from '../models/send-to-api.js';
 
-// TODO: This could be useful in other commands
-async function getAppOrAddonId({ alias, appIdOrName, addonId }) {
-  return addonId != null ? addonId : await Application.resolveId(appIdOrName, alias).then(({ appId }) => appId);
-}
-
 export async function list(params) {
-  const { alias, app: appIdOrName, addon: addonId, format } = params.options;
+  const { alias, app: appIdOrName, format } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  const drains = await getDrains({ appId: appIdOrAddonId }).then(sendToApi);
+  const drains = await getDrains({ ownerId, applicationId }).then(sendToApi);
 
   switch (format) {
     case 'json': {
-      const formattedDrains = drains.map((drain) => ({
-        id: drain.id,
-        target: drain.target,
-        state: drain.state,
-      }));
-
-      Logger.printJson(formattedDrains);
+      Logger.printJson(drains);
       break;
     }
     case 'human':
     default: {
       if (drains.length === 0) {
-        Logger.println(`There are no drains for ${appIdOrAddonId}`);
+        Logger.println(`There are no drains for ${applicationId}`);
+        return;
+      }
+
+      if (drains.length === 1) {
+        const formattedDrain = formatDrain(drains[0]);
+        console.table(formattedDrain);
+        return;
       }
 
-      drains.forEach((drain) => {
-        const { id, state, target } = drain;
-        const { url, drainType, indexPrefix, structuredDataParameters } = target;
-
-        let drainView = `${id} -> ${state} for ${url} as ${drainType}`;
-        if (indexPrefix != null) {
-          drainView += `, custom index: '${indexPrefix}-YYYY-MM-DD'`;
-        }
-        if (structuredDataParameters != null) {
-          drainView += `, sd-params: '${structuredDataParameters}'`;
-        }
-        Logger.println(drainView);
+      const formattedDrains = drains.map((drain) => {
+        return {
+          ID: drain.id,
+          Status: drain.status.status,
+          'Execution status': drain.execution.status,
+          URL: drain.recipient.url,
+        };
       });
+
+      console.table(formattedDrains);
     }
   }
 }
 
 export async function create(params) {
-  const [drainTargetType, drainTargetURL] = params.args;
+  const { alias, app: appIdOrName } = params.options;
   const {
-    alias,
-    app: appIdOrName,
-    addon: addonId,
     username,
     password,
     'api-key': apiKey,
     'index-prefix': indexPrefix,
-    'sd-params': structuredDataParameters,
+    'sd-params': rfc5424StructuredDataParameters,
   } = params.options;
-  const drainTargetCredentials = { username, password };
-  const drainTargetConfig = { apiKey, indexPrefix, structuredDataParameters };
-
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  const body = createDrainBody(
-    appIdOrAddonId,
-    drainTargetURL,
-    drainTargetType,
-    drainTargetCredentials,
-    drainTargetConfig,
-  );
-  await createDrain({ appId: appIdOrAddonId }, body).then(sendToApi);
-
-  Logger.println('Your drain has been successfully saved');
+  const [drainTypeCliCode, url] = params.args;
+
+  const drainType = Object.values(DRAIN_TYPES).find((drainType) => drainType.cliCode === drainTypeCliCode);
+  if (!drainType) {
+    throw new Error(`Invalid drain type. Supported types are: ${DRAIN_TYPE_CLI_CODES.join(', ')}`);
+  }
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+  const body = {
+    kind: 'LOG',
+    recipient: {
+      type: drainType.apiCode,
+      url,
+    },
+  };
+
+  if (drainTypeCliCode === DRAIN_TYPES.ELASTICSEARCH.cliCode) {
+    if (!indexPrefix) {
+      throw new Error(`${DRAIN_TYPES.ELASTICSEARCH.cliCode} drains require an index prefix (--index-prefix) to be set`);
+    }
+    if (!url.endsWith('/_bulk')) {
+      throw new Error(`${DRAIN_TYPES.ELASTICSEARCH.cliCode} drain URL must end with '/_bulk'`);
+    }
+    body.recipient.index = indexPrefix;
+  }
+
+  if (drainTypeCliCode === DRAIN_TYPES.ELASTICSEARCH.cliCode || drainTypeCliCode === DRAIN_TYPES.RAW_HTTP.cliCode) {
+    if (username) {
+      body.recipient.username = username;
+    }
+    if (password) {
+      body.recipient.password = password;
+    }
+  }
+
+  if (drainTypeCliCode === DRAIN_TYPES.NEWRELIC.cliCode) {
+    if (!apiKey) {
+      throw new Error(`${DRAIN_TYPES.NEWRELIC.cliCode} drains require an API key (--api-key) to be set`);
+    }
+    body.recipient.apiKey = apiKey;
+  }
+
+  if (
+    drainTypeCliCode === DRAIN_TYPES.OVH_TCP.cliCode ||
+    drainTypeCliCode === DRAIN_TYPES.SYSLOG_TCP.cliCode ||
+    drainTypeCliCode === DRAIN_TYPES.SYSLOG_UDP.cliCode
+  ) {
+    if (rfc5424StructuredDataParameters) {
+      body.recipient.rfc5424StructuredDataParameters = rfc5424StructuredDataParameters;
+    }
+  }
+
+  const drain = await createDrain({ ownerId, applicationId, body }).then(sendToApi);
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drain.id)} has been successfully created and enabled!`);
 }
 
-export async function rm(params) {
+export async function get(params) {
   const [drainId] = params.args;
-  const { alias, app: appIdOrName, addon: addonId } = params.options;
+  const { alias, app: appIdOrName, format } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  await deleteDrain({ appId: appIdOrAddonId, drainId }).then(sendToApi);
+  const drain = await getDrain({ ownerId, applicationId, drainId }).then(sendToApi);
 
-  Logger.println('Your drain has been successfully removed');
+  switch (format) {
+    case 'json': {
+      Logger.printJson(drain);
+      break;
+    }
+    case 'human':
+    default: {
+      const formattedDrain = formatDrain(drain);
+      console.table(formattedDrain);
+    }
+  }
+}
+
+export async function remove(params) {
+  const [drainId] = params.args;
+  const { alias, app: appIdOrName } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
+
+  await deleteDrain({ ownerId, applicationId, drainId }).then(sendToApi);
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully removed!`);
 }
 
 export async function enable(params) {
   const [drainId] = params.args;
-  const { alias, app: appIdOrName, addon: addonId } = params.options;
+  const { alias, app: appIdOrName } = params.options;
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  await updateDrainState({ appId: appIdOrAddonId, drainId }, { state: 'ENABLED' }).then(sendToApi);
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  Logger.println('Your drain has been enabled');
+  await enableDrain({ ownerId, applicationId, drainId }).then(sendToApi);
+
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully enabled!`);
 }
 
 export async function disable(params) {
   const [drainId] = params.args;
-  const { alias, app: appIdOrName, addon: addonId } = params.options;
+  const { alias, app: appIdOrName } = params.options;
+
+  const { ownerId, appId: applicationId } = await Application.resolveId(appIdOrName, alias);
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  await updateDrainState({ appId: appIdOrAddonId, drainId }, { state: 'DISABLED' }).then(sendToApi);
+  await disableDrain({ ownerId, applicationId, drainId }).then(sendToApi);
 
-  Logger.println('Your drain has been disabled');
+  Logger.printSuccess(`Drain ${styleText(['bold', 'green'], drainId)} has been successfully disabled!`);
 }

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/commands/otoroshi.js

@@ -50,6 +50,18 @@ export async function get(params) {
   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;
+  const { format } = params.options;
+  await operatorPrint('otoroshi', addonIdOrName, 'otoroshictl');
+}
+
 /**
  * List all Otoroshi operators
  * @returns {Promise<void>}

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/operator-commands.js

@@ -1,6 +1,7 @@
 import dedent from 'dedent';
 import _ from 'lodash';
 import {
+  getOtoroshiConfig,
   ngDisableOperator,
   ngEnableOperator,
   rebootOperator,
@@ -249,6 +250,13 @@ export async function operatorRebuild(provider, addonIdOrName) {
 export async function operatorPrint(provider, addonIdOrName, format = 'human') {
   const operator = await Operator.getDetails(provider, addonIdOrName);
 
+  if (provider === 'otoroshi' && format === 'otoroshictl') {
+    const config = await getOtoroshiConfig({ realId: operator.resourceId }).then(sendToApi);
+
+    Logger.println(config);
+    return;
+  }
+
   const dataToPrint = {
     Name: operator.name,
     ID: operator.resourceId,

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) {