clever-tools 4.7.1 → 4.9.0

package/src/commands/k8s/k8s.nodegroups.get.command.js

@@ -0,0 +1,66 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sGetNodeGroup } from '../../lib/k8s.js';
+import { Logger } from '../../logger.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg, k8sNodeGroupIdOrNameArg } from './k8s.args.js';
+
+export const k8sNodeGroupGetCommand = defineCommand({
+  description: 'Get information about a Kubernetes node group',
+  since: '4.9.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [k8sIdOrNameArg, k8sNodeGroupIdOrNameArg],
+  async handler(options, clusterIdOrName, nodeGroupIdOrName) {
+    const { format, org: orgIdOrName } = options;
+    const nodeGroup = await k8sGetNodeGroup(orgIdOrName, clusterIdOrName, nodeGroupIdOrName);
+
+    switch (format) {
+      case 'json':
+        Logger.printJson(nodeGroup);
+        break;
+      case 'human':
+      default: {
+        const overview = {
+          Name: nodeGroup.name,
+          ID: nodeGroup.id,
+          Status: nodeGroup.status,
+          Flavor: nodeGroup.flavor,
+          Nodes: `${nodeGroup.currentNodeCount}/${nodeGroup.targetNodeCount}`,
+          Autoscaling: nodeGroup.autoscalingEnabled ? 'enabled' : 'disabled',
+          'Min / Max': `${nodeGroup.minNodeCount} / ${nodeGroup.maxNodeCount}${nodeGroup.autoscalingEnabled ? '' : ' (inactive)'}`,
+          Created: formatDate(nodeGroup.createdAt),
+        };
+        const createdFmt = formatDate(nodeGroup.createdAt);
+        const updatedFmt = formatDate(nodeGroup.updatedAt);
+        if (nodeGroup.updatedAt && updatedFmt !== createdFmt) {
+          overview.Updated = updatedFmt;
+        }
+        if (nodeGroup.description) overview.Description = nodeGroup.description;
+        if (nodeGroup.tag) overview.Tag = nodeGroup.tag;
+        console.table(overview);
+
+        const labels = Object.entries(nodeGroup.labels ?? {});
+        if (labels.length > 0) {
+          Logger.println('');
+          Logger.println(`🏷️  Labels (${labels.length})`);
+          console.table(Object.fromEntries(labels.map(([k, v]) => [k, { Value: v }])));
+        }
+
+        const taints = nodeGroup.taints ?? [];
+        if (taints.length > 0) {
+          Logger.println('');
+          Logger.println(`🚫 Taints (${taints.length})`);
+          console.table(Object.fromEntries(taints.map((t) => [t.key, { Value: t.value ?? '-', Effect: t.effect }])));
+        }
+        break;
+      }
+    }
+  },
+});
+
+function formatDate(iso) {
+  if (iso == null) return '-';
+  return `${iso.slice(0, 16).replace('T', ' ')}Z`;
+}

package/src/commands/k8s/k8s.nodegroups.list.command.js

@@ -0,0 +1,49 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sListNodeGroups } from '../../lib/k8s.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sNodeGroupListCommand = defineCommand({
+  description: 'List the node groups of a Kubernetes cluster',
+  since: '4.9.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { format, org: orgIdOrName } = options;
+    const nodeGroups = await k8sListNodeGroups(orgIdOrName, clusterIdOrName);
+
+    switch (format) {
+      case 'json':
+        Logger.printJson(nodeGroups);
+        break;
+      case 'human':
+      default:
+        if (nodeGroups.length === 0) {
+          Logger.println(
+            `🔎 No node group found, create one with ${styleText('blue', 'clever k8s nodegroups create')}`,
+          );
+          return;
+        }
+        console.table(
+          Object.fromEntries(
+            nodeGroups.map((ng) => [
+              ng.id,
+              {
+                Name: ng.name,
+                Status: ng.status,
+                Flavor: ng.flavor,
+                Nodes: `${ng.currentNodeCount}/${ng.targetNodeCount}`,
+                Autoscaling: ng.autoscalingEnabled ? `${ng.minNodeCount}-${ng.maxNodeCount}` : 'disabled',
+              },
+            ]),
+          ),
+        );
+        break;
+    }
+  },
+});

package/src/commands/k8s/k8s.nodegroups.update.command.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { k8sUpdateNodeGroup } from '../../lib/k8s.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg, k8sNodeGroupIdOrNameArg } from './k8s.args.js';
+
+export const k8sNodeGroupUpdateCommand = defineCommand({
+  description: 'Update a node group on a Kubernetes cluster',
+  since: '4.9.0',
+  options: {
+    count: defineOption({
+      name: 'count',
+      schema: z.coerce.number().int().min(0).max(256).optional(),
+      description: 'Target node count',
+      placeholder: 'count',
+    }),
+    min: defineOption({
+      name: 'min',
+      schema: z.coerce.number().int().min(0).max(256).optional(),
+      description: 'Minimum node count (autoscaling bound)',
+      placeholder: 'min',
+    }),
+    max: defineOption({
+      name: 'max',
+      schema: z.coerce.number().int().min(0).max(256).optional(),
+      description: 'Maximum node count (autoscaling bound)',
+      placeholder: 'max',
+    }),
+    autoscaling: defineOption({
+      name: 'autoscaling',
+      schema: z.boolean().default(false),
+      description: 'Enable the cluster autoscaler',
+    }),
+    disableAutoscaling: defineOption({
+      name: 'disable-autoscaling',
+      schema: z.boolean().default(false),
+      description: 'Disable the cluster autoscaler',
+    }),
+    description: defineOption({
+      name: 'description',
+      schema: z.string().max(4096).optional(),
+      description: 'Free-form node group description',
+      placeholder: 'description',
+    }),
+    tag: defineOption({
+      name: 'tag',
+      schema: z.string().max(1024).optional(),
+      description: 'Arbitrary tag attached to the node group',
+      placeholder: 'tag',
+    }),
+    org: orgaIdOrNameOption,
+  },
+  args: [k8sIdOrNameArg, k8sNodeGroupIdOrNameArg],
+  async handler(options, clusterIdOrName, nodeGroupIdOrName) {
+    const { org: orgIdOrName } = options;
+
+    if (options.autoscaling && options.disableAutoscaling) {
+      throw new Error('--autoscaling and --disable-autoscaling are mutually exclusive');
+    }
+
+    const updates = {};
+    if (options.count != null) updates.targetNodeCount = options.count;
+    if (options.min != null) updates.minNodeCount = options.min;
+    if (options.max != null) updates.maxNodeCount = options.max;
+    if (options.autoscaling) updates.autoscalingEnabled = true;
+    if (options.disableAutoscaling) updates.autoscalingEnabled = false;
+    if (options.description != null) updates.description = options.description;
+    if (options.tag != null) updates.tag = options.tag;
+
+    if (Object.keys(updates).length === 0) {
+      throw new Error(
+        'No update specified. Provide at least one of --count, --min, --max, --autoscaling, --disable-autoscaling, --description, --tag',
+      );
+    }
+
+    if (updates.minNodeCount != null && updates.maxNodeCount != null && updates.minNodeCount > updates.maxNodeCount) {
+      throw new Error('--min must be less than or equal to --max');
+    }
+
+    const nodeGroup = await k8sUpdateNodeGroup(orgIdOrName, clusterIdOrName, nodeGroupIdOrName, updates);
+    Logger.printSuccess(`Node group ${styleText('green', nodeGroup.name)} updated`);
+  },
+});

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

@@ -0,0 +1,77 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sGetQuota, k8sListUsage } from '../../lib/k8s.js';
+import { Logger } from '../../logger.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+
+const BYTES_PER_GB = 1024 ** 3;
+const UNIT_TO_BYTES = {
+  B: 1,
+  KB: 1024,
+  MB: 1024 ** 2,
+  GB: BYTES_PER_GB,
+  TB: 1024 ** 4,
+  PB: 1024 ** 5,
+};
+
+export const k8sQuotaCommand = defineCommand({
+  description: 'Get the Kubernetes quota, usage and remaining of an organisation',
+  since: '4.9.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { format, org: orgIdOrName } = options;
+    const [quota, usageItems] = await Promise.all([k8sGetQuota(orgIdOrName), k8sListUsage(orgIdOrName)]);
+
+    const cpuQuota = quota.quotas?.find((i) => i.type === 'MillivCPUMaxLimit');
+    const ramQuota = quota.quotas?.find((i) => i.type === 'RamMaxUsage');
+    const usedMillicores = usageItems.reduce((sum, i) => sum + i.cpuMillicores, 0);
+    const usedBytes = usageItems.reduce((sum, i) => sum + i.ramBytes, 0);
+
+    switch (format) {
+      case 'json': {
+        const { quotas, ...quotaRest } = quota;
+        Logger.printJson({
+          quota: {
+            ...quotaRest,
+            vCPUMax: cpuQuota != null ? { maximum: cpuQuota.maximum, unit: 'mCPU' } : null,
+            ramMax: ramQuota != null ? { maximum: ramQuota.information.number, unit: ramQuota.information.unit } : null,
+          },
+          usage: { cpuMillicores: usedMillicores, ramBytes: usedBytes },
+          remaining: {
+            cpuMillicores: cpuQuota != null ? cpuQuota.maximum - usedMillicores : null,
+            ramBytes: ramQuota != null ? ramToBytes(ramQuota.information) - usedBytes : null,
+          },
+        });
+        break;
+      }
+      case 'human':
+      default: {
+        const ramQuotaBytes = ramQuota != null ? ramToBytes(ramQuota.information) : null;
+        console.table({
+          'Max CPU': {
+            Quota: cpuQuota != null ? `${cpuQuota.maximum / 1000} vCPU` : 'unlimited',
+            Usage: `${usedMillicores / 1000} vCPU`,
+            Remaining: cpuQuota != null ? `${(cpuQuota.maximum - usedMillicores) / 1000} vCPU` : 'unlimited',
+          },
+          'Max RAM': {
+            Quota: ramQuota != null ? `${ramQuota.information.number} ${ramQuota.information.unit}` : 'unlimited',
+            Usage: `${formatGb(usedBytes)} GB`,
+            Remaining: ramQuotaBytes != null ? `${formatGb(ramQuotaBytes - usedBytes)} GB` : 'unlimited',
+          },
+        });
+        break;
+      }
+    }
+  },
+});
+
+function ramToBytes({ number, unit }) {
+  return number * (UNIT_TO_BYTES[unit] ?? BYTES_PER_GB);
+}
+
+function formatGb(bytes) {
+  return Math.round((bytes / BYTES_PER_GB) * 100) / 100;
+}

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

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { k8sUpdate } from '../../lib/k8s.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { tags } from '../../parsers.js';
+import { orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sUpdateCommand = defineCommand({
+  description: 'Update a Kubernetes cluster metadata or features',
+  since: '4.9.0',
+  options: {
+    name: defineOption({
+      name: 'name',
+      schema: z.string().max(128).optional(),
+      description: 'Rename the cluster',
+      placeholder: 'name',
+    }),
+    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: 'Replace 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',
+    }),
+    disableAutoscaling: defineOption({
+      name: 'disable-autoscaling',
+      schema: z.boolean().default(false),
+      description: 'Disable the cluster autoscaler',
+    }),
+    org: orgaIdOrNameOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { org: orgIdOrName } = options;
+
+    if (options.autoscaling && options.disableAutoscaling) {
+      throw new Error('--autoscaling and --disable-autoscaling are mutually exclusive');
+    }
+
+    const updates = {};
+    if (options.name != null) updates.name = options.name;
+    if (options.description != null) updates.description = options.description;
+    if (options.tag != null) updates.tags = options.tag;
+
+    const features = {};
+    if (options.autoscaling) features.autoscalingEnabled = true;
+    if (options.disableAutoscaling) features.autoscalingEnabled = false;
+    if (Object.keys(features).length > 0) updates.features = features;
+
+    if (Object.keys(updates).length === 0) {
+      throw new Error(
+        'No update specified. Provide at least one of --name, --description, --tag, --autoscaling, --disable-autoscaling',
+      );
+    }
+
+    const cluster = await k8sUpdate(orgIdOrName, clusterIdOrName, updates);
+    Logger.printSuccess(`Cluster ${styleText('green', cluster.name)} updated`);
+  },
+});

package/src/commands/k8s/k8s.version.check.command.js

@@ -0,0 +1,18 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sCheckVersion } from '../../lib/k8s.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sVersionCheckCommand = defineCommand({
+  description: 'Check a Kubernetes cluster deployed version',
+  since: '4.9.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { format, org: orgIdOrName } = options;
+    await k8sCheckVersion(orgIdOrName, clusterIdOrName, format);
+  },
+});

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

@@ -0,0 +1,18 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sCheckVersion } from '../../lib/k8s.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sVersionCommand = defineCommand({
+  description: 'Check a Kubernetes cluster deployed version',
+  since: '4.9.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { format, org: orgIdOrName } = options;
+    await k8sCheckVersion(orgIdOrName, clusterIdOrName, format);
+  },
+});

package/src/commands/k8s/k8s.version.update.command.js

@@ -0,0 +1,18 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sUpdateVersion } from '../../lib/k8s.js';
+import { orgaIdOrNameOption, targetVersionOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sVersionUpdateCommand = defineCommand({
+  description: 'Update a Kubernetes cluster to a target version',
+  since: '4.9.0',
+  options: {
+    org: orgaIdOrNameOption,
+    target: targetVersionOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { target, org: orgIdOrName } = options;
+    await k8sUpdateVersion(orgIdOrName, clusterIdOrName, target);
+  },
+});

package/src/commands/logs/logs.command.js

@@ -4,11 +4,11 @@ import { defineOption } from '../../lib/define-option.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
 import * as Application from '../../models/application.js';
-import { resolveOwnerId, resolveRealId } from '../../models/ids-resolver.js';
+import { resolveAddon } from '../../models/ids-resolver.js';
 import * as Log from '../../models/log.js';
 import { Deferred } from '../../models/utils.js';
 import {
-  addonIdOption,
+  addonIdOrRealIdOption,
   afterOption,
   aliasOption,
   appIdOrNameOption,
@@ -36,7 +36,7 @@ export const logsCommand = defineCommand({
     app: appIdOrNameOption,
     before: beforeOption,
     after: afterOption,
-    addon: addonIdOption,
+    addon: addonIdOrRealIdOption,
     format: logsFormatOption,
   },
   args: [],
@@ -57,8 +57,7 @@ export const logsCommand = defineCommand({
     const isForHuman = format === 'human';
 
     if (addonIdOrRealId != null) {
-      const realId = await resolveRealId(addonIdOrRealId);
-      const ownerId = await resolveOwnerId(realId);
+      const { ownerId, realId } = await resolveAddon(addonIdOrRealId);
       if (isForHuman) {
         Logger.println(styleText('blue', 'Waiting for addon logs…'));
       }

package/src/commands/ng/ng.docs.md

@@ -146,7 +146,6 @@ clever ng get-config <peer-id|peer-label> <ng-id|ng-label> [options]
 
 |Name|Description|
 |---|---|
-|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
 |`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|
 
 ## ➡️ `clever ng link` <kbd>Since 3.12.0</kbd>

package/src/commands/ng/ng.get-config.command.js

@@ -1,7 +1,7 @@
 import { defineCommand } from '../../lib/define-command.js';
 import { Logger } from '../../logger.js';
 import * as networkGroup from '../../models/ng.js';
-import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+import { orgaIdOrNameOption } from '../global.options.js';
 import { ngExternalIdOrLabelArg, ngIdOrLabelArg } from './ng.args.js';
 
 export const ngGetConfigCommand = defineCommand({
@@ -9,24 +9,13 @@ export const ngGetConfigCommand = defineCommand({
   since: '3.12.0',
   options: {
     org: orgaIdOrNameOption,
-    format: humanJsonOutputFormatOption,
   },
   args: [ngExternalIdOrLabelArg, ngIdOrLabelArg],
   async handler(options, peerIdOrLabel, ngIdOrLabel) {
-    const { org, format } = options;
+    const { org } = options;
 
     const peerConfig = await networkGroup.getPeerConfig(peerIdOrLabel, ngIdOrLabel, org);
 
-    switch (format) {
-      case 'json': {
-        Logger.printJson(peerConfig);
-        break;
-      }
-      case 'human':
-      default: {
-        const decodedConfiguration = Buffer.from(peerConfig.configuration, 'base64').toString('utf8');
-        Logger.println(decodedConfiguration);
-      }
-    }
+    Logger.println(peerConfig);
   },
 });

package/src/commands/ng/ng.options.js

@@ -4,6 +4,6 @@ import { defineOption } from '../../lib/define-option.js';
 export const ngResourceTypeOption = defineOption({
   name: 'type',
   schema: z.enum(['NetworkGroup', 'Member', 'CleverPeer', 'ExternalPeer']).optional(),
-  description: 'Type of resource to look for (NetworkGroup, Member, CleverPeer, ExternalPeer)',
+  description: 'Type of resource to look for',
   placeholder: 'resource-type',
 });

package/src/commands/notify-email/notify-email.remove.command.js

@@ -1,7 +1,7 @@
 import { deleteEmailhook } from '@clevercloud/client/esm/api/v2/notification.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { Logger } from '../../logger.js';
-import { getOrgaIdOrUserId } from '../../models/notification.js';
+import { getOwnerIdFromOrgIdOrName } from '../../models/ids-resolver.js';
 import { sendToApi } from '../../models/send-to-api.js';
 import { notificationIdArg } from '../global.args.js';
 import { orgaIdOrNameOption } from '../global.options.js';
@@ -16,7 +16,7 @@ export const notifyEmailRemoveCommand = defineCommand({
   async handler(options, notificationId) {
     const { org } = options;
 
-    const ownerId = await getOrgaIdOrUserId(org);
+    const ownerId = await getOwnerIdFromOrgIdOrName(org);
     await deleteEmailhook({ ownerId, id: notificationId }).then(sendToApi);
 
     Logger.println('The notification has been successfully removed');

package/src/commands/oauth-consumers/oauth-consumers.args.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+
+export const consumerKeyOrNameArg = defineArgument({
+  schema: z.string(),
+  description: 'OAuth consumer key (or name, if unambiguous)',
+  placeholder: 'consumer-key|consumer-name',
+});

package/src/commands/oauth-consumers/oauth-consumers.command.js

@@ -0,0 +1,6 @@
+import { defineCommand } from '../../lib/define-command.js';
+
+export const oauthConsumersCommand = defineCommand({
+  description: 'Manage OAuth consumers used with a Clever Cloud login',
+  since: '4.8.0',
+});

package/src/commands/oauth-consumers/oauth-consumers.create.command.js

@@ -0,0 +1,64 @@
+import { create } from '@clevercloud/client/esm/api/v2/oauth-consumer.js';
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { promptTextOption } from '../../lib/prompts.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { getOwnerIdFromOrgIdOrName } from '../../models/ids-resolver.js';
+import { promptRights, rightsFromList } from '../../models/oauth-consumer.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+import { baseUrlOption, descriptionOption, pictureOption, rightsOption, urlOption } from './oauth-consumers.options.js';
+
+export const oauthConsumersCreateCommand = defineCommand({
+  description: 'Create an OAuth consumer',
+  since: '4.8.0',
+  options: {
+    org: orgaIdOrNameOption,
+    description: descriptionOption,
+    url: urlOption,
+    picture: pictureOption,
+    baseUrl: baseUrlOption,
+    rights: rightsOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [
+    defineArgument({
+      schema: z.string(),
+      description: 'Consumer name',
+      placeholder: 'name',
+    }),
+  ],
+  async handler(options, name) {
+    const { org, description, url, picture, baseUrl, rights, format } = options;
+
+    const ownerId = await getOwnerIdFromOrgIdOrName(org);
+
+    const body = {
+      name,
+      description: description ?? (await promptTextOption(descriptionOption)),
+      url: url ?? (await promptTextOption(urlOption)),
+      picture: picture ?? (await promptTextOption(pictureOption)),
+      baseUrl: baseUrl ?? (await promptTextOption(baseUrlOption)),
+      rights: rights != null ? rightsFromList(rights) : await promptRights(),
+    };
+
+    const oauthConsumer = await create({ id: ownerId }, body).then(sendToApi);
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(oauthConsumer);
+        break;
+      }
+      case 'human':
+      default: {
+        Logger.printSuccess(`OAuth consumer ${styleText(['bold', 'green'], oauthConsumer.key)} has been created!`);
+        Logger.println();
+        Logger.println(
+          `Retrieve the secret with ${styleText('blue', `clever oauth-consumers get ${oauthConsumer.key} --with-secret`)}`,
+        );
+      }
+    }
+  },
+});

package/src/commands/oauth-consumers/oauth-consumers.delete.command.js

@@ -0,0 +1,33 @@
+import { remove } from '@clevercloud/client/esm/api/v2/oauth-consumer.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { confirm } from '../../lib/prompts.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { resolveOauthConsumer } from '../../models/oauth-consumer.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { skipConfirmationOption } from '../global.options.js';
+import { consumerKeyOrNameArg } from './oauth-consumers.args.js';
+
+export const oauthConsumersDeleteCommand = defineCommand({
+  description: 'Delete an OAuth consumer',
+  since: '4.8.0',
+  options: {
+    skipConfirmation: skipConfirmationOption,
+  },
+  args: [consumerKeyOrNameArg],
+  async handler(options, keyOrName) {
+    const { skipConfirmation } = options;
+
+    const oauthConsumer = await resolveOauthConsumer(keyOrName);
+
+    if (!skipConfirmation) {
+      await confirm(
+        `Are you sure you want to delete the OAuth consumer ${styleText('blue', oauthConsumer.key)}?`,
+        'OAuth consumer deletion cancelled.',
+      );
+    }
+
+    await remove({ id: oauthConsumer.ownerId, key: oauthConsumer.key }).then(sendToApi);
+    Logger.printSuccess(`OAuth consumer ${styleText(['bold', 'green'], oauthConsumer.key)} has been deleted!`);
+  },
+});