clever-tools 4.8.0 → 4.9.0

package/package.json

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

package/src/clever-client/k8s.js

@@ -16,6 +16,23 @@ export function createK8sCluster(params, body) {
   });
 }
 
+/**
+ * PATCH /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ * @param {Object} body
+ */
+export function updateK8sCluster(params, body) {
+  return Promise.resolve({
+    method: 'PATCH',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}`,
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    // no queryParams
+    body,
+  });
+}
+
 /**
  * DELETE /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}
  * @param {Object} params
@@ -94,3 +111,183 @@ export function addK8sPersistentStorage(params) {
     // no body
   });
 }
+
+/**
+ * PATCH /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/node-groups/{nodeGroupId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ * @param {String} params.nodeGroupId
+ * @param {Object} body
+ */
+export function updateK8sNodeGroup(params, body) {
+  return Promise.resolve({
+    method: 'PATCH',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/node-groups/${params.nodeGroupId}`,
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    // no queryParams
+    body,
+  });
+}
+
+/**
+ * DELETE /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/node-groups/{nodeGroupId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ * @param {String} params.nodeGroupId
+ */
+export function deleteK8sNodeGroup(params) {
+  return Promise.resolve({
+    method: 'delete',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/node-groups/${params.nodeGroupId}`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/node-groups
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ * @param {Object} body
+ */
+export function createK8sNodeGroup(params, body) {
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/node-groups`,
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    // no queryParams
+    body,
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/node-groups
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ */
+export function listK8sNodeGroups(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/node-groups`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/node-groups/{nodeGroupId}
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ * @param {String} params.nodeGroupId
+ */
+export function getK8sNodeGroup(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/node-groups/${params.nodeGroupId}`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/deployment-events
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ * @param {Object} [queryParams]
+ * @param {Number} [queryParams.limit]
+ */
+export function listK8sDeploymentEvents(params, queryParams = {}) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/deployment-events`,
+    headers: { Accept: 'application/json' },
+    queryParams,
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes-product
+ */
+export function getK8sProduct() {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes-product`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/version/check
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ */
+export function getK8sVersionCheck(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/version/check`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * POST /v4/kubernetes/organisations/{ownerId}/clusters/{clusterId}/version/update
+ * @param {Object} params
+ * @param {String} params.ownerId
+ * @param {String} params.clusterId
+ * @param {Object} body
+ * @param {String} body.targetVersion
+ */
+export function updateK8sVersion(params, body) {
+  return Promise.resolve({
+    method: 'post',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/clusters/${params.clusterId}/version/update`,
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    // no queryParams
+    body,
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/quota
+ * @param {Object} params
+ * @param {String} params.ownerId
+ */
+export function getK8sQuota(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/quota`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}
+
+/**
+ * GET /v4/kubernetes/organisations/{ownerId}/usage
+ * @param {Object} params
+ * @param {String} params.ownerId
+ */
+export function listK8sUsage(params) {
+  return Promise.resolve({
+    method: 'get',
+    url: `/v4/kubernetes/organisations/${params.ownerId}/usage`,
+    headers: { Accept: 'application/json' },
+    // no queryParams
+    // no body
+  });
+}

package/src/commands/addon/addon.docs.md

@@ -62,7 +62,7 @@ clever addon delete <addon-id|addon-name> [options]
 |Name|Description|
 |---|---|
 |`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|
-|`-y`, `--yes`|Skip confirmation and proceed with deletion directly|
+|`-y`, `--yes`|Skip confirmation prompts|
 
 ## ➡️ `clever addon env` <kbd>Since 2.11.0</kbd>
 

package/src/commands/global.commands.js

@@ -62,6 +62,7 @@ import { featuresEnableCommand } from './features/features.enable.command.js';
 import { featuresInfoCommand } from './features/features.info.command.js';
 import { featuresListCommand } from './features/features.list.command.js';
 import { helpCommand } from './help/help.command.js';
+import { k8sActivityCommand } from './k8s/k8s.activity.command.js';
 import { k8sAddPersistentStorageCommand } from './k8s/k8s.add-persistent-storage.command.js';
 import { k8sCommand } from './k8s/k8s.command.js';
 import { k8sCreateCommand } from './k8s/k8s.create.command.js';
@@ -69,6 +70,17 @@ import { k8sDeleteCommand } from './k8s/k8s.delete.command.js';
 import { k8sGetKubeconfigCommand } from './k8s/k8s.get-kubeconfig.command.js';
 import { k8sGetCommand } from './k8s/k8s.get.command.js';
 import { k8sListCommand } from './k8s/k8s.list.command.js';
+import { k8sNodeGroupCommand } from './k8s/k8s.nodegroups.command.js';
+import { k8sNodeGroupCreateCommand } from './k8s/k8s.nodegroups.create.command.js';
+import { k8sNodeGroupDeleteCommand } from './k8s/k8s.nodegroups.delete.command.js';
+import { k8sNodeGroupGetCommand } from './k8s/k8s.nodegroups.get.command.js';
+import { k8sNodeGroupListCommand } from './k8s/k8s.nodegroups.list.command.js';
+import { k8sNodeGroupUpdateCommand } from './k8s/k8s.nodegroups.update.command.js';
+import { k8sQuotaCommand } from './k8s/k8s.quota.command.js';
+import { k8sUpdateCommand } from './k8s/k8s.update.command.js';
+import { k8sVersionCheckCommand } from './k8s/k8s.version.check.command.js';
+import { k8sVersionCommand } from './k8s/k8s.version.command.js';
+import { k8sVersionUpdateCommand } from './k8s/k8s.version.update.command.js';
 import { keycloakCommand } from './keycloak/keycloak.command.js';
 import { keycloakDisableNgCommand } from './keycloak/keycloak.disable-ng.command.js';
 import { keycloakEnableNgCommand } from './keycloak/keycloak.enable-ng.command.js';
@@ -132,6 +144,7 @@ import { otoroshiGetConfigCommand } from './otoroshi/otoroshi.get-config.command
 import { otoroshiGetCommand } from './otoroshi/otoroshi.get.command.js';
 import { otoroshiOpenCommand } from './otoroshi/otoroshi.open.command.js';
 import { otoroshiOpenLogsCommand } from './otoroshi/otoroshi.open.logs.command.js';
+import { otoroshiOpenSwaggeruiCommand } from './otoroshi/otoroshi.open.swaggerui.command.js';
 import { otoroshiOpenWebuiCommand } from './otoroshi/otoroshi.open.webui.command.js';
 import { otoroshiRebuildCommand } from './otoroshi/otoroshi.rebuild.command.js';
 import { otoroshiRestartCommand } from './otoroshi/otoroshi.restart.command.js';
@@ -294,12 +307,32 @@ export const globalCommands = {
   k8s: [
     k8sCommand,
     {
+      activity: k8sActivityCommand,
       'add-persistent-storage': k8sAddPersistentStorageCommand,
       create: k8sCreateCommand,
       delete: k8sDeleteCommand,
       get: k8sGetCommand,
       'get-kubeconfig': k8sGetKubeconfigCommand,
       list: k8sListCommand,
+      nodegroups: [
+        k8sNodeGroupCommand,
+        {
+          create: k8sNodeGroupCreateCommand,
+          delete: k8sNodeGroupDeleteCommand,
+          get: k8sNodeGroupGetCommand,
+          list: k8sNodeGroupListCommand,
+          update: k8sNodeGroupUpdateCommand,
+        },
+      ],
+      quota: k8sQuotaCommand,
+      update: k8sUpdateCommand,
+      version: [
+        k8sVersionCommand,
+        {
+          check: k8sVersionCheckCommand,
+          update: k8sVersionUpdateCommand,
+        },
+      ],
     },
   ],
   keycloak: [
@@ -421,6 +454,7 @@ export const globalCommands = {
         otoroshiOpenCommand,
         {
           logs: otoroshiOpenLogsCommand,
+          swaggerui: otoroshiOpenSwaggeruiCommand,
           webui: otoroshiOpenWebuiCommand,
         },
       ],

package/src/commands/global.options.js

@@ -70,7 +70,7 @@ export const humanJsonOutputFormatOption = defineOption({
 export const skipConfirmationOption = defineOption({
   name: 'yes',
   schema: z.boolean().default(false),
-  description: 'Skip confirmation and proceed with deletion directly',
+  description: 'Skip confirmation prompts',
   aliases: ['y'],
 });
 

package/src/commands/k8s/k8s.activity.command.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { k8sListActivity } from '../../lib/k8s.js';
+import { Logger } from '../../logger.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sActivityCommand = defineCommand({
+  description: 'Show recent deployment events of a Kubernetes cluster',
+  since: '4.9.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+    limit: defineOption({
+      name: 'limit',
+      schema: z.coerce.number().int().min(1).max(1000).default(50),
+      description: 'Number of events to fetch (1 to 1000)',
+      placeholder: 'limit',
+    }),
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { format, org: orgIdOrName, limit } = options;
+    const events = await k8sListActivity(orgIdOrName, clusterIdOrName, limit);
+
+    switch (format) {
+      case 'json':
+        Logger.printJson(events);
+        break;
+      case 'human':
+      default:
+        if (events.length === 0) {
+          Logger.println('🔎 No deployment event found');
+          return;
+        }
+        console.table(
+          events.map((e) => ({
+            Date: formatDate(e.createdAt),
+            Operation: e.operation,
+            Step: e.stepName ?? '-',
+            Status: e.status,
+          })),
+        );
+        break;
+    }
+  },
+});
+
+function formatDate(iso) {
+  if (iso == null) return '-';
+  return `${iso.slice(0, 19).replace('T', ' ')}Z`;
+}

package/src/commands/k8s/k8s.args.js

@@ -7,3 +7,9 @@ export const k8sIdOrNameArg = defineArgument({
   description: 'Kubernetes cluster ID or name',
   placeholder: 'cluster-id|cluster-name',
 });
+
+export const k8sNodeGroupIdOrNameArg = defineArgument({
+  schema: z.string(),
+  description: 'Kubernetes node group ID or name',
+  placeholder: 'nodegroup-id|nodegroup-name',
+});

package/src/commands/k8s/k8s.create.command.js

@@ -3,10 +3,11 @@ import { typewriterLogo } from '../../lib/ascii.js';
 import { defineArgument } from '../../lib/define-argument.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { defineOption } from '../../lib/define-option.js';
-import { getK8sCluster, k8sCreate } from '../../lib/k8s.js';
+import { getK8sCluster, k8sCreate, k8sGetProduct } from '../../lib/k8s.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import { orgaIdOrNameOption } from '../global.options.js';
+import { flavorCount, tags } from '../../parsers.js';
+import { orgaIdOrNameOption, skipConfirmationOption } from '../global.options.js';
 
 const DEPLOY_POLL_DELAY_MS = 10000;
 
@@ -14,6 +15,78 @@ export const k8sCreateCommand = defineCommand({
   description: 'Create a Kubernetes cluster',
   since: '4.3.0',
   options: {
+    clusterVersion: defineOption({
+      name: 'cluster-version',
+      schema: z.string().optional(),
+      description: 'Kubernetes version to deploy (e.g.: 1.36)',
+      placeholder: 'cluster-version',
+      complete: async () => {
+        const product = await k8sGetProduct();
+        return product.versions?.available ?? [];
+      },
+    }),
+    description: defineOption({
+      name: 'description',
+      schema: z.string().max(4096).optional(),
+      description: 'Free-form cluster description',
+      placeholder: 'description',
+    }),
+    tag: defineOption({
+      name: 'tag',
+      schema: z.string().transform(tags).optional(),
+      description: 'Semantic tags (comma-separated, e.g.: env:prod,team:platform)',
+      placeholder: 'tag[,tag...]',
+    }),
+    autoscaling: defineOption({
+      name: 'autoscaling',
+      schema: z.boolean().default(false),
+      description: 'Enable the cluster autoscaler',
+    }),
+    persistentStorage: defineOption({
+      name: 'persistent-storage',
+      schema: z.boolean().default(false),
+      description: 'Enable persistent storage (Ceph CSI)',
+    }),
+    topology: defineOption({
+      name: 'topology',
+      schema: z
+        .string()
+        .transform((v) => v.toUpperCase())
+        .optional(),
+      description: 'Cluster topology (must be set with --flavor and --replication-factor)',
+      placeholder: 'topology',
+      complete: async () => {
+        const product = await k8sGetProduct();
+        return (product.topologies ?? []).map((t) => t.topology);
+      },
+    }),
+    flavor: defineOption({
+      name: 'flavor',
+      schema: z
+        .string()
+        .transform((v) => v.toUpperCase())
+        .optional(),
+      description: 'Control plane flavor',
+      placeholder: 'flavor',
+      complete: async () => {
+        const product = await k8sGetProduct();
+        const flavors = new Set((product.topologies ?? []).flatMap((t) => t.availableFlavors ?? []));
+        return [...flavors];
+      },
+    }),
+    replicationFactor: defineOption({
+      name: 'replication-factor',
+      schema: z.coerce.number().int().optional(),
+      description: 'Control plane replication factor',
+      placeholder: 'replication-factor',
+    }),
+    nodeGroup: defineOption({
+      name: 'nodegroup',
+      schema: z.string().transform(flavorCount).optional(),
+      description: 'Initial node group (format: <flavor>:<count>, e.g.: XS:3)',
+      placeholder: 'flavor:count',
+    }),
+    yes: skipConfirmationOption,
     watch: defineOption({
       name: 'watch',
       schema: z.boolean().default(false),
@@ -34,7 +107,18 @@ export const k8sCreateCommand = defineCommand({
     const orgIdOrName = options.org;
 
     try {
-      const cluster = await k8sCreate(clusterName, orgIdOrName);
+      const cluster = await k8sCreate(clusterName, orgIdOrName, {
+        version: options.clusterVersion,
+        description: options.description,
+        tags: options.tag,
+        autoscaling: options.autoscaling,
+        persistentStorage: options.persistentStorage,
+        topology: options.topology,
+        flavor: options.flavor,
+        replicationFactor: options.replicationFactor,
+        nodeGroup: options.nodeGroup,
+        yes: options.yes,
+      });
 
       if (options.watch) {
         await typewriterLogo();

package/src/commands/k8s/k8s.delete.command.js

@@ -1,6 +1,6 @@
 import { defineCommand } from '../../lib/define-command.js';
 import { k8sDelete } from '../../lib/k8s.js';
-import { confirm } from '../../lib/prompts.js';
+import { ask } from '../../lib/prompts.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
 import { orgaIdOrNameOption, skipConfirmationOption } from '../global.options.js';
@@ -15,26 +15,21 @@ export const k8sDeleteCommand = defineCommand({
   },
   args: [k8sIdOrNameArg],
   async handler(options, clusterIdOrName) {
-    const { org: orgIdOrName, yes: confirmDeletion } = options;
+    const { org: orgIdOrName, yes } = options;
+    const display = clusterIdOrName.addon_name || clusterIdOrName.operator_id;
 
-    let proceedDeletion;
-    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 (!yes) {
+      const proceed = await ask(
+        `Are you sure you want to delete the Kubernetes cluster ${styleText('blue', display)}?`,
+        false,
       );
+      if (!proceed) {
+        Logger.println('Kubernetes cluster deletion cancelled');
+        return;
+      }
     }
 
-    if (proceedDeletion) {
-      await k8sDelete(orgIdOrName, clusterIdOrName);
-      Logger.printSuccess(
-        `Kubernetes cluster ${styleText('green', clusterIdOrName.addon_name || clusterIdOrName.operator_id)} successfully deleted`,
-      );
-    }
+    await k8sDelete(orgIdOrName, clusterIdOrName);
+    Logger.printSuccess(`Kubernetes cluster ${styleText('green', display)} successfully deleted`);
   },
 });