clever-tools 4.4.1 → 4.5.0

package/src/commands/global.options.js

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+import { defineOption } from '../lib/define-option.js';
+import { listAvailableAliases } from '../models/application.js';
+import { listMetaEvents } from '../models/notification.js';
+import { appIdOrName, date, orgaIdOrName } from '../parsers.js';
+
+export const aliasOption = defineOption({
+  name: 'alias',
+  schema: z.string().optional(),
+  description: 'Short name for the application',
+  aliases: ['a'],
+  placeholder: 'alias',
+  complete: listAvailableAliases,
+});
+
+export const appIdOrNameOption = defineOption({
+  name: 'app',
+  schema: z.string().transform(appIdOrName).optional(),
+  description: 'Application to manage by its ID (or name, if unambiguous)',
+  placeholder: 'app-id|app-name',
+});
+
+export const logsFormatOption = defineOption({
+  name: 'format',
+  schema: z.enum(['human', 'json', 'json-stream']).default('human'),
+  description: 'Output format (human, json, json-stream)',
+  aliases: ['F'],
+  placeholder: 'format',
+});
+
+export const beforeOption = defineOption({
+  name: 'before',
+  schema: z.string().transform(date).optional(),
+  description: 'Fetch logs before this date/time (ISO8601 date, positive number in seconds or duration, e.g.: 1h)',
+  aliases: ['until'],
+  placeholder: 'before',
+});
+
+export const afterOption = defineOption({
+  name: 'after',
+  schema: z.string().transform(date).optional(),
+  description: 'Fetch logs after this date/time (ISO8601 date, positive number in seconds or duration, e.g.: 1h)',
+  aliases: ['since'],
+  placeholder: 'after',
+});
+
+export const addonIdOption = defineOption({
+  name: 'addon',
+  schema: z.string().optional(),
+  description: 'Add-on ID',
+  placeholder: 'addon-id',
+});
+
+export const orgaIdOrNameOption = defineOption({
+  name: 'org',
+  schema: z.string().transform(orgaIdOrName).optional(),
+  description: 'Organisation to target by its ID (or name, if unambiguous)',
+  aliases: ['o', 'owner'],
+  placeholder: 'org-id|org-name',
+});
+
+export const humanJsonOutputFormatOption = defineOption({
+  name: 'format',
+  schema: z.enum(['human', 'json']).default('human'),
+  description: 'Output format (human, json)',
+  aliases: ['F'],
+  placeholder: 'format',
+});
+
+export const confirmAddonDeletionOption = defineOption({
+  name: 'yes',
+  schema: z.boolean().default(false),
+  description: 'Skip confirmation and delete the add-on directly',
+  aliases: ['y'],
+});
+
+export const envFormatOption = defineOption({
+  name: 'format',
+  schema: z.enum(['human', 'json', 'shell']).default('human'),
+  description: 'Output format (human, json, shell)',
+  aliases: ['F'],
+  placeholder: 'format',
+});
+
+export const aliasCreationOption = defineOption({
+  name: 'alias',
+  schema: z.string().optional(),
+  description: 'Short name for the application',
+  aliases: ['a'],
+  placeholder: 'alias',
+});
+
+export const quietOption = defineOption({
+  name: 'quiet',
+  schema: z.boolean().default(false),
+  description: "Don't show logs during deployment",
+  aliases: ['q'],
+});
+
+export const followDeployLogsOption = defineOption({
+  name: 'follow',
+  schema: z.boolean().default(false),
+  description: 'Continue to follow logs after deployment has ended',
+  deprecated: 'use `--exit-on never` instead',
+});
+
+export const exitOnDeployOption = defineOption({
+  name: 'exit-on',
+  schema: z.enum(['deploy-start', 'deploy-end', 'never']).default('deploy-end'),
+  description: 'Step at which the logs streaming is ended, steps are: deploy-start, deploy-end, never',
+  aliases: ['e'],
+  placeholder: 'step',
+});
+
+export const importAsJsonOption = defineOption({
+  name: 'json',
+  schema: z.boolean().default(false),
+  description: 'Import variables as JSON (an array of { \"name\": \"THE_NAME\", \"value\": \"THE_VALUE\" } objects)',
+});
+
+export const targetVersionOption = defineOption({
+  name: 'target',
+  schema: z.string().optional(),
+  description: 'Target version to upgrade to (e.g.: 24, 2.4, 2.4.1)',
+  placeholder: 'version',
+});
+
+export const listAllNotificationsOption = defineOption({
+  name: 'list-all',
+  schema: z.boolean().default(false),
+  description: "List all notifications for your user or for an organisation with the '--org' option",
+});
+
+export const notificationEventTypeOption = defineOption({
+  name: 'event',
+  schema: z
+    .string()
+    .transform((v) => v.split(','))
+    .optional(),
+  description: 'Restrict notifications to specific event types',
+  placeholder: 'event-type',
+  complete: listMetaEvents,
+});
+
+export const notificationScopeOption = defineOption({
+  name: 'service',
+  schema: z
+    .string()
+    .transform((v) => v.split(','))
+    .optional(),
+  description: 'Restrict notifications to specific applications and add-ons',
+  placeholder: 'service-id',
+});
+
+export const helpOption = defineOption({
+  name: 'help',
+  schema: z.boolean().optional(),
+  description: 'Display help about this program',
+  aliases: ['?'],
+});
+
+export const versionOption = defineOption({
+  name: 'version',
+  schema: z.boolean().optional(),
+  description: 'Display the version of this program',
+  aliases: ['V'],
+});
+
+export const colorOption = defineOption({
+  name: 'color',
+  schema: z.boolean().default(true),
+  description: 'Choose whether to print colors or not. You can also use --no-color',
+});
+
+export const updateNotifierOption = defineOption({
+  name: 'update-notifier',
+  schema: z.boolean().default(true),
+  description: 'Choose whether to use update notifier or not. You can also use --no-update-notifier',
+});
+
+export const verboseOption = defineOption({
+  name: 'verbose',
+  schema: z.boolean().default(false),
+  description: 'Verbose output',
+  aliases: ['v'],
+});

package/src/commands/help/help.command.js

@@ -0,0 +1,9 @@
+import { defineCommand } from '../../lib/define-command.js';
+
+export const helpCommand = defineCommand({
+  description: 'Display help about the Clever Cloud CLI',
+  since: '0.1.0',
+  options: {},
+  args: [],
+  handler: null,
+});

package/src/commands/help/help.docs.md

@@ -0,0 +1,9 @@
+# 📖 `clever help` command reference
+
+## ➡️ `clever help` <kbd>Since 0.1.0</kbd>
+
+Display help about the Clever Cloud CLI
+
+```bash
+clever help
+```

package/src/commands/k8s/k8s.add-persistent-storage.command.js

@@ -0,0 +1,39 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { isK8sClusterActive, k8sAddPersistentStorage } from '../../lib/k8s.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sAddPersistentStorageCommand = defineCommand({
+  description: 'Activate persistent storage to a deployed Kubernetes cluster',
+  since: '4.3.0',
+  options: {
+    org: orgaIdOrNameOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const orgIdOrName = 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");
+    }
+  },
+});

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+import { addonIdOrName } from '../../parsers.js';
+
+export const k8sIdOrNameArg = defineArgument({
+  schema: z.string().transform(addonIdOrName),
+  description: 'Kubernetes cluster ID or name',
+  placeholder: 'cluster-id|cluster-name',
+});

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

@@ -0,0 +1,12 @@
+import { defineCommand } from '../../lib/define-command.js';
+
+export const k8sCommand = defineCommand({
+  description: 'Manage Kubernetes clusters',
+  since: '4.3.0',
+  isExperimental: true,
+  featureFlag: 'k8s',
+  options: {},
+  args: [],
+  // Parent command - no handler, only contains subcommands
+  handler: null,
+});

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

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+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 { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { orgaIdOrNameOption } from '../global.options.js';
+
+const DEPLOY_POLL_DELAY_MS = 10000;
+
+export const k8sCreateCommand = defineCommand({
+  description: 'Create a Kubernetes cluster',
+  since: '4.3.0',
+  options: {
+    watch: defineOption({
+      name: 'watch',
+      schema: z.boolean().default(false),
+      description: 'Watch the deployment until the cluster is deployed',
+      aliases: ['w'],
+    }),
+    org: orgaIdOrNameOption,
+  },
+  args: [
+    defineArgument({
+      schema: z.string(),
+      description: 'Kubernetes cluster name',
+      placeholder: 'cluster-name',
+    }),
+  ],
+  async handler(options, ...args) {
+    const clusterName = args[0];
+    const orgIdOrName = options.org;
+
+    try {
+      const cluster = await k8sCreate(clusterName, orgIdOrName);
+
+      if (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);
+      }
+    }
+  },
+});

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

@@ -0,0 +1,40 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sDelete } from '../../lib/k8s.js';
+import { confirm } from '../../lib/prompts.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { confirmAddonDeletionOption, orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sDeleteCommand = defineCommand({
+  description: 'Delete a Kubernetes cluster',
+  since: '4.3.0',
+  options: {
+    org: orgaIdOrNameOption,
+    yes: confirmAddonDeletionOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { org: orgIdOrName, yes: confirmDeletion } = options;
+
+    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 (proceedDeletion) {
+      await k8sDelete(orgIdOrName, clusterIdOrName);
+      Logger.printSuccess(
+        `Kubernetes cluster ${styleText('green', clusterIdOrName.addon_name || clusterIdOrName.operator_id)} successfully deleted`,
+      );
+    }
+  },
+});

package/src/commands/k8s/k8s.docs.md

@@ -0,0 +1,131 @@
+# 📖 `clever k8s` command reference
+
+> [!NOTE]
+> 🧪 **Experimental**: This command may change or be removed in future versions.
+> Enable with: `clever features enable k8s`
+
+## ➡️ `clever k8s` <kbd>Since 4.3.0</kbd>
+
+Manage Kubernetes clusters
+
+```bash
+clever k8s
+```
+
+## ➡️ `clever k8s add-persistent-storage` <kbd>Since 4.3.0</kbd>
+
+Activate persistent storage to a deployed Kubernetes cluster
+
+```bash
+clever k8s add-persistent-storage <cluster-id|cluster-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`cluster-id|cluster-name`|Kubernetes cluster ID or name|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|
+
+## ➡️ `clever k8s create` <kbd>Since 4.3.0</kbd>
+
+Create a Kubernetes cluster
+
+```bash
+clever k8s create <cluster-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`cluster-name`|Kubernetes cluster name|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|
+|`-w`, `--watch`|Watch the deployment until the cluster is deployed|
+
+## ➡️ `clever k8s delete` <kbd>Since 4.3.0</kbd>
+
+Delete a Kubernetes cluster
+
+```bash
+clever k8s delete <cluster-id|cluster-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`cluster-id|cluster-name`|Kubernetes cluster ID or 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 delete the add-on directly|
+
+## ➡️ `clever k8s get` <kbd>Since 4.3.0</kbd>
+
+Get information about a Kubernetes cluster
+
+```bash
+clever k8s get <cluster-id|cluster-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`cluster-id|cluster-name`|Kubernetes cluster ID or name|
+
+### ⚙️ 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 k8s get-kubeconfig` <kbd>Since 4.3.0</kbd>
+
+Get configuration of a Kubernetes cluster
+
+```bash
+clever k8s get-kubeconfig <cluster-id|cluster-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`cluster-id|cluster-name`|Kubernetes cluster ID or name|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|
+
+## ➡️ `clever k8s list` <kbd>Since 4.3.0</kbd>
+
+List Kubernetes clusters
+
+```bash
+clever k8s list [options]
+```
+
+### ⚙️ 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)|

package/src/commands/k8s/k8s.get-kubeconfig.command.js

@@ -0,0 +1,32 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { isK8sClusterActive, k8sGetConfig } from '../../lib/k8s.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { orgaIdOrNameOption } from '../global.options.js';
+import { k8sIdOrNameArg } from './k8s.args.js';
+
+export const k8sGetKubeconfigCommand = defineCommand({
+  description: 'Get configuration of a Kubernetes cluster',
+  since: '4.3.0',
+  options: {
+    org: orgaIdOrNameOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const orgIdOrName = 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/k8s/k8s.get.command.js

@@ -0,0 +1,43 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { getK8sCluster } 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 k8sGetCommand = defineCommand({
+  description: 'Get information about a Kubernetes cluster',
+  since: '4.3.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [k8sIdOrNameArg],
+  async handler(options, clusterIdOrName) {
+    const { format, org: orgIdOrName } = 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;
+    }
+  },
+});

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

@@ -0,0 +1,38 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { k8sList } from '../../lib/k8s.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
+
+export const k8sListCommand = defineCommand({
+  description: 'List Kubernetes clusters',
+  since: '4.3.0',
+  options: {
+    org: orgaIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { format, org: orgIdOrName } = 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;
+    }
+  },
+});

package/src/commands/keycloak/keycloak.command.js

@@ -0,0 +1,17 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { operatorList } from '../../lib/operator-commands.js';
+import { humanJsonOutputFormatOption } from '../global.options.js';
+
+export const keycloakCommand = defineCommand({
+  description: 'Manage Clever Cloud Keycloak services',
+  since: '3.13.0',
+  isExperimental: true,
+  featureFlag: 'operators',
+  options: {
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    await operatorList('keycloak', options.format);
+  },
+});

package/src/commands/keycloak/keycloak.disable-ng.command.js

@@ -0,0 +1,13 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { operatorNgDisable } from '../../lib/operator-commands.js';
+import { addonIdOrNameArg } from '../global.args.js';
+
+export const keycloakDisableNgCommand = defineCommand({
+  description: 'Unlink Keycloak from its Network Group',
+  since: '3.13.0',
+  options: {},
+  args: [addonIdOrNameArg],
+  async handler(_options, addonIdOrName) {
+    await operatorNgDisable('keycloak', addonIdOrName);
+  },
+});