clever-tools 4.4.1 → 4.5.0

package/src/commands/webhooks/webhooks.docs.md

@@ -0,0 +1,61 @@
+# 📖 `clever webhooks` command reference
+
+## ➡️ `clever webhooks` <kbd>Since 0.6.0</kbd>
+
+Manage webhooks
+
+```bash
+clever webhooks [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+|`--list-all`|List all notifications for your user or for an organisation with the '--org' option|
+|`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|
+
+## ➡️ `clever webhooks add` <kbd>Since 0.6.0</kbd>
+
+Register webhook to be called when events happen
+
+```bash
+clever webhooks add <name> <url> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`name`|Notification name|
+|`url`|Webhook URL|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`--event` `<event-type>`|Restrict notifications to specific event types|
+|`--format` `<format>`|Format of the body sent to the webhook ('raw', 'slack', 'gitter', or 'flowdock') (default: raw)|
+|`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|
+|`--service` `<service-id>`|Restrict notifications to specific applications and add-ons|
+
+## ➡️ `clever webhooks remove` <kbd>Since 0.6.0</kbd>
+
+Remove an existing webhook
+
+```bash
+clever webhooks remove <notification-id> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`notification-id`|Notification ID|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-o`, `--org`, `--owner` `<org-id\|org-name>`|Organisation to target by its ID (or name, if unambiguous)|

package/src/commands/webhooks/webhooks.remove.command.js

@@ -0,0 +1,24 @@
+import { deleteWebhook } 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 { sendToApi } from '../../models/send-to-api.js';
+import { notificationIdArg } from '../global.args.js';
+import { orgaIdOrNameOption } from '../global.options.js';
+
+export const webhooksRemoveCommand = defineCommand({
+  description: 'Remove an existing webhook',
+  since: '0.6.0',
+  options: {
+    org: orgaIdOrNameOption,
+  },
+  args: [notificationIdArg],
+  async handler(options, notificationId) {
+    const { org } = options;
+
+    const ownerId = await getOrgaIdOrUserId(org);
+    await deleteWebhook({ ownerId, id: notificationId }).then(sendToApi);
+
+    Logger.println('The notification has been successfully removed');
+  },
+});

package/src/lib/cliparse-patched.js

@@ -0,0 +1,192 @@
+import cliparseOriginal from 'cliparse';
+import cliparseCommandModule from 'cliparse/src/command.js';
+import semver from 'semver';
+import pkg from '../../package.json' with { type: 'json' };
+import { Logger } from '../logger.js';
+import { getCommandInfo } from './get-command-info.js';
+import { styleText } from './style-text.js';
+
+// Patch cliparse.command so we can catch errors
+const cliparseCommand = cliparseOriginal.command;
+cliparseOriginal.command = function (name, options, commandFunction) {
+  if (commandFunction == null) {
+    return cliparseCommand(name, options);
+  }
+
+  const command = cliparseCommand(name, options, (params) => {
+    const args = params.args ?? [];
+    // Map options from cliparse format (using option.name as key, e.g. 'index-prefix')
+    // to the original keys from the command definition (e.g. 'indexPrefix')
+    const mappedOptions = mapOptionsToDefinitionKeys(params.options, command._definition);
+    const promise = commandFunction(mappedOptions, ...args);
+    promise.catch((error) => {
+      Logger.error(error);
+      const semverIsOk = semver.satisfies(process.version, pkg.engines.node);
+      if (!semverIsOk) {
+        Logger.warn(
+          `You are using node ${process.version}, some of our commands require node ${pkg.engines.node}. The error may be caused by this.`,
+        );
+      }
+      process.exit(1);
+    });
+  });
+  return command;
+};
+
+/**
+ * Map options from cliparse format (using option.name) to the original definition keys.
+ * For example, { theOptionName: defineOption({ name: 'the-option-name', ... }) },
+ * cliparse will return { 'the-option-name': value }, and we need to convert it to { theOptionName: value }.
+ * @param {Record<string, unknown>} options - Options object from cliparse with option.name as keys
+ * @param {CommandDefinition} definition - Command definition
+ * @returns {Record<string, unknown>} Options object with original definition keys
+ */
+function mapOptionsToDefinitionKeys(options, definition) {
+  if (!definition?.options) {
+    return options;
+  }
+
+  // Build a reverse map: option.name -> definition key
+  const nameToKey = new Map();
+  for (const [key, optionDef] of Object.entries(definition.options)) {
+    nameToKey.set(optionDef.name, key);
+  }
+
+  // Map options to use definition keys
+  const mappedOptions = {};
+  for (const [name, value] of Object.entries(options)) {
+    const key = nameToKey.get(name) ?? name;
+    mappedOptions[key] = value;
+  }
+
+  return mappedOptions;
+}
+
+/**
+ * Patched help function for cliparse commands.
+ * Called internally by cliparse when --help is used.
+ * Generates formatted help output with usage, arguments, options, and subcommands.
+ * @param {Array<{name: string, description: string, commands: Array, _definition: CommandDefinition}>} context - Command context stack
+ * @returns {string} Formatted help text
+ */
+cliparseCommandModule.help = function (context) {
+  const cmd = context.at(-1);
+  const path = context.slice(1).map((c) => c.name);
+  const commandInfo = getCommandInfo(path, cmd._definition);
+
+  const allRows = [];
+
+  let argumentsRows;
+  if (commandInfo.args) {
+    argumentsRows = commandInfo.args.map((arg) => {
+      let description = arg.description;
+      if (arg.optional) description += ` ${styleText('dim', arg.optional)}`;
+      return [arg.name, description];
+    });
+    allRows.push(...argumentsRows);
+  }
+
+  let optionsRows;
+  if (commandInfo.options) {
+    optionsRows = commandInfo.options.map((opt) => {
+      const placeholder = opt.placeholder ? ` ${opt.placeholder}` : '';
+      const aliasesPadding = opt.aliases[0].length === 2 ? '' : '    ';
+      const aliases = aliasesPadding + opt.aliases.join(', ') + placeholder;
+      let description = opt.description;
+      if (opt.deprecated) description += ` ${styleText('dim', opt.deprecated)}`;
+      if (opt.required) description += ` ${styleText('dim', opt.required)}`;
+      if (opt.default) description += ` ${styleText('dim', opt.default)}`;
+      return [aliases, description];
+    });
+    allRows.push(...optionsRows);
+  }
+
+  const availableCommandsRows = cmd.commands.map((cmd) => [cmd.name, cmd.description.split('\n')[0]]);
+  allRows.push(...availableCommandsRows);
+
+  const firstColumnWith = Math.max(...allRows.map(([cell]) => cell.length));
+
+  const parts = [cmd._definition.description];
+
+  parts.push(formatSection('USAGE', [commandInfo.usage]));
+  if (availableCommandsRows.length > 0) {
+    parts.push(formatSectionWithColumns('COMMANDS', availableCommandsRows, firstColumnWith));
+  }
+  if (argumentsRows) {
+    parts.push(formatSectionWithColumns('ARGUMENTS', argumentsRows, firstColumnWith));
+  }
+  if (optionsRows) {
+    parts.push(formatSectionWithColumns('OPTIONS', optionsRows, firstColumnWith));
+  }
+  if (cmd._definition.examples?.length > 0) {
+    parts.push(formatSection('EXAMPLES', cmd._definition.examples));
+  }
+
+  return parts.join('\n\n');
+};
+
+/**
+ * @param {string} title
+ * @param {Array<string>} lines
+ */
+function formatSection(title, lines) {
+  return [styleText('bold', title), ...lines.map((l) => `  ${l}`)].join('\n');
+}
+
+/**
+ * @param {string} title
+ * @param {string[][]} rows
+ * @param {number} firstColumnWidth
+ */
+function formatSectionWithColumns(title, rows, firstColumnWidth) {
+  const lines = rows.map(([firstColumn, otherColumn]) => firstColumn.padEnd(firstColumnWidth + 4, ' ') + otherColumn);
+  return formatSection(title, lines);
+}
+
+// Wrap parser functions to allow them to simply return values or throw errors
+// instead of using cliparse.parsers.success/error
+function wrapParser(parser) {
+  return (value) => {
+    try {
+      return cliparseOriginal.parsers.success(parser(value));
+    } catch (error) {
+      return cliparseOriginal.parsers.error(error.message);
+    }
+  };
+}
+
+// Wrap complete functions to allow returning plain arrays
+// instead of cliparse.autocomplete.words(array)
+function wrapComplete(complete) {
+  return (word) => {
+    // Support both functions and static arrays (e.g. complete: Drain.DRAIN_TYPE_CLI_CODES)
+    const result = typeof complete === 'function' ? complete(word) : complete;
+    return Promise.resolve(result).then(cliparse.autocomplete.words);
+  };
+}
+
+// Patch cliparse.option to wrap parser and complete functions
+const cliparseOption = cliparseOriginal.option;
+cliparseOriginal.option = function (name, options) {
+  if (options?.parser != null) {
+    options.parser = wrapParser(options.parser);
+  }
+  if (options?.complete != null) {
+    options.complete = wrapComplete(options.complete);
+  }
+  return cliparseOption(name, options);
+};
+
+// Patch cliparse.argument to wrap parser and complete functions
+const cliparseArgument = cliparseOriginal.argument;
+cliparseOriginal.argument = function (name, options) {
+  if (options?.parser != null) {
+    options.parser = wrapParser(options.parser);
+  }
+  if (options?.complete != null) {
+    options.complete = wrapComplete(options.complete);
+  }
+  return cliparseArgument(name, options);
+};
+
+export const cliparse = cliparseOriginal;

package/src/lib/define-argument.js

@@ -0,0 +1,7 @@
+/**
+ * Define a CLI argument with full type inference from Zod schema.
+ * @type {import('./define-argument.types.js').defineArgument}
+ */
+export function defineArgument(argumentDefinition) {
+  return argumentDefinition;
+}

package/src/lib/define-argument.types.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { CompletionFunction } from './define-common.types.js';
+
+/** Define a CLI argument with full type inference from Zod schema. */
+export function defineArgument<S extends z.ZodType>(definition: ArgumentDefinition<S>): ArgumentDefinition<S>;
+
+/** Argument definition shape with Zod schema for type inference. */
+export interface ArgumentDefinition<S extends z.ZodType = z.ZodType> {
+  /** Zod schema defining the argument's type, default value, and validation. */
+  schema: S;
+
+  /** Human-readable description for help text. */
+  description: string;
+
+  /** Placeholder text shown in help documentation (e.g., 'addon-id'). */
+  placeholder: string;
+
+  /** Shell completion function. Can be sync or async. */
+  complete?: CompletionFunction;
+
+  /** Mark as deprecated. `true` for generic warning, or a string with migration instructions. */
+  deprecated?: boolean | string;
+}

package/src/lib/define-command.js

@@ -0,0 +1,7 @@
+/**
+ * Define a CLI command with full type inference from Zod schemas.
+ * @type {import('./define-command.types.js').defineCommand}
+ */
+export function defineCommand(definition) {
+  return definition;
+}

package/src/lib/define-command.types.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+
+import { ArgumentDefinition } from './define-argument.types.js';
+import { OptionDefinition } from './define-option.types.js';
+
+/** Define a CLI command with full type inference from option and argument definitions. */
+// The `const` modifier on `A` is critical: it tells TypeScript to infer the exact
+// tuple type (e.g., `[StringArg, NumberArg]`) rather than widening to `ArgumentDefinition[]`.
+// This preserves argument order and types for the handler signature.
+export function defineCommand<O extends OptionsRecord | undefined, const A extends ArgumentsArray | undefined>(
+  definition: CommandDefinition<O, A>,
+): CommandDefinition<O, A>;
+
+/**
+ * Full specification for a CLI command.
+ * @template O - Options record type, inferred from the `options` property.
+ * @template A - Arguments tuple type, inferred from the `args` property.
+ */
+// Generic parameters allow TypeScript to infer exact types for options and arguments,
+// which then flow into the handler signature for full type safety.
+// Some commands don't have options, some don't have arguments, some don't have both.
+export interface CommandDefinition<
+  O extends OptionsRecord | undefined = OptionsRecord,
+  A extends ArgumentsArray | undefined = ArgumentsArray,
+> {
+  /** Short description for help text. */
+  description: string;
+
+  /** Usage examples shown in help output. */
+  examples?: string[];
+
+  /**
+   * Mark command as experimental.
+   * Experimental commands may show a warning when used.
+   */
+  isExperimental?: boolean;
+
+  /**
+   * Feature flag name that must be enabled for this command to be available.
+   * If the feature flag is not enabled, the command will be hidden.
+   */
+  featureFlag?: string;
+
+  /** Version when this command was introduced (semver format, e.g., '2.1.0'). */
+  since?: `${number}.${number}.${number}`;
+
+  /** Options (named options like --type, --region, --format). */
+  options?: O;
+
+  /** Positional arguments, passed to the handler as individual parameters in order. */
+  args?: A;
+
+  /** Command handler. Receives parsed options, then args. Null for parent-only commands. */
+  handler: CommandHandler<O, A> | null;
+}
+
+// Dictionary of named options (e.g., { format: OptionDefinition, region: OptionDefinition }).
+type OptionsRecord = Record<string, OptionDefinition>;
+
+// Tuple of positional arguments.
+// Must be `readonly` to preserve tuple structure and allow `const` inference.
+type ArgumentsArray = readonly ArgumentDefinition[];
+
+// Handler signature adapts based on whether args are defined.
+// - With args: `(options, ...args) => Promise<void>` - args spread as individual parameters.
+// - Without args: `(options) => Promise<void>` - no extra parameters.
+type CommandHandler<O, A> = A extends ArgumentsArray
+  ? (options: InferOptionsType<O>, ...args: InferArgsType<A>) => Promise<void>
+  : (options: InferOptionsType<O>) => Promise<void>;
+
+// Extracts runtime types from option definitions using Zod inference.
+// Maps `{ foo: { schema: z.string() } }` → `{ foo: string }`.
+type InferOptionsType<O> = O extends OptionsRecord
+  ? { [K in keyof O]: z.infer<O[K]['schema']> }
+  : Record<string, never>;
+
+// Extracts runtime types from argument definitions as a tuple.
+// Maps `[{ schema: z.string() }, { schema: z.number() }]` → `[string, number]`.
+// Preserves tuple order so args are passed to handlers in the correct position.
+// `keyof A` on an array includes both numeric indices ("0", "1", ...) and
+// array properties ("length", "push", etc.). The `extends ArgumentDefinition`
+// check returns `never` for non-index keys, effectively filtering them out.
+type InferArgsType<A extends ArgumentsArray> = {
+  [K in keyof A]: A[K] extends ArgumentDefinition ? z.infer<A[K]['schema']> : never;
+};

package/src/lib/define-common.types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Completion function signature for shell autocompletion.
+ * Can be sync or async for API-based completions.
+ */
+export type CompletionFunction = (context?: CompletionContext) => string[] | Promise<string[]>;
+
+/**
+ * Completion context provided to completion functions.
+ * Contains partial command state for intelligent completion.
+ */
+interface CompletionContext {
+  /** The current partial input being completed */
+  current?: string;
+  /** Previously parsed option values */
+  options?: Record<string, unknown>;
+  /** Previously parsed argument values */
+  args?: unknown[];
+}

package/src/lib/define-option.js

@@ -0,0 +1,7 @@
+/**
+ * Define a CLI option with full type inference from Zod schema.
+ * @type {import('./define-option.types.js').defineOption}
+ */
+export function defineOption(optionDefinition) {
+  return optionDefinition;
+}

package/src/lib/define-option.types.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { CompletionFunction } from './define-common.types.js';
+
+/** Define a CLI option with full type inference from Zod schema. */
+export function defineOption<S extends z.ZodType>(definition: OptionDefinition<S>): OptionDefinition<S>;
+
+/** Option definition shape with Zod schema for type inference. */
+export interface OptionDefinition<S extends z.ZodType = z.ZodType> {
+  /** The CLI option name (e.g., 'region' for --region). */
+  name: string;
+
+  /** Zod schema defining the option's type, default value, and validation. */
+  schema: S;
+
+  /** Human-readable description for help text. */
+  description: string;
+
+  /** Alternative names for this option (e.g., ['v'] for -v). */
+  aliases?: string[];
+
+  /** Placeholder text shown in help (e.g., 'ZONE' for --region <ZONE>). */
+  placeholder?: string;
+
+  /** Shell completion function. Can be sync or async. */
+  complete?: CompletionFunction;
+
+  /** Mark as deprecated. `true` for generic warning, or a string with migration instructions. */
+  deprecated?: boolean | string;
+}

package/src/lib/get-command-info.js

@@ -0,0 +1,86 @@
+import { getDefault, isBoolean, isRequired } from './zod-utils.js';
+
+/**
+ * @typedef {import('./get-command-info.types.d.ts').ArgumentInfo} ArgumentInfo
+ * @typedef {import('./get-command-info.types.d.ts').OptionInfo} OptionInfo
+ * @typedef {import('./get-command-info.types.d.ts').CommandInfo} CommandInfo
+ * @typedef {import('./define-command.types.d.ts').CommandDefinition} CommandDefinition
+ * @typedef {import('./define-option.types.d.ts').OptionDefinition} OptionDefinition
+ */
+
+/**
+ * Extracts normalized command information for display purposes.
+ * This function provides a shared source of truth for CLI help, reference docs, and LLM docs.
+ * @param {string[]} path - Command path (e.g., ['env', 'set'])
+ * @param {CommandDefinition} definition
+ * @return {CommandInfo}
+ */
+export function getCommandInfo(path, definition) {
+  const usageParts = ['clever', ...path];
+  if (definition.options != null) {
+    for (const option of Object.values(definition.options)) {
+      if (isRequired(option.schema)) {
+        usageParts.push(`--${option.name} <${option.placeholder ?? option.name}>`);
+      }
+    }
+  }
+  if (definition.args != null) {
+    for (const arg of definition.args) {
+      if (isRequired(arg.schema)) {
+        usageParts.push(`<${arg.placeholder}>`);
+      } else {
+        usageParts.push(`[<${arg.placeholder}>]`);
+      }
+    }
+  }
+  if (definition.options != null && Object.keys(definition.options).length > 0) {
+    usageParts.push('[options]');
+  }
+  const usage = usageParts.join(' ');
+
+  // Build args info (sorted by position, i.e., as defined)
+  const args = definition.args?.length
+    ? definition.args.map((arg) => {
+        return {
+          name: arg.placeholder,
+          description: arg.description,
+          optional: isRequired(arg.schema) ? null : '(optional)',
+        };
+      })
+    : null;
+
+  // Build options info (sorted: required first, then alphabetically)
+  const optionValues = Object.values(definition.options ?? {});
+  const options = optionValues.length
+    ? optionValues
+        .sort((optA, optB) => {
+          const aRequired = isRequired(optA.schema);
+          const bRequired = isRequired(optB.schema);
+          if (aRequired !== bRequired) return aRequired ? -1 : 1;
+          return optA.name.localeCompare(optB.name);
+        })
+        .map((option) => {
+          const shortAliases = (option.aliases?.filter((a) => a.length === 1) ?? []).map((a) => `-${a}`);
+          const longAliases = (option.aliases?.filter((a) => a.length > 1) ?? []).map((a) => `--${a}`);
+          const allAliases = [...shortAliases, `--${option.name}`, ...longAliases];
+          const defaultValue = getDefault(option.schema);
+
+          return {
+            name: option.name,
+            aliases: allAliases,
+            placeholder: isBoolean(option.schema) ? null : `<${option.placeholder ?? option.name}>`,
+            description: option.description,
+            deprecated:
+              typeof option.deprecated === 'string'
+                ? `(deprecated, ${option.deprecated})`
+                : option.deprecated === true
+                  ? '(deprecated)'
+                  : null,
+            required: isRequired(option.schema) ? '(required)' : null,
+            default: defaultValue ? `(default: ${defaultValue})` : null,
+          };
+        })
+    : null;
+
+  return { usage, args, options };
+}

package/src/lib/get-command-info.types.d.ts

@@ -0,0 +1,42 @@
+export interface ZodSchemaLike {
+  _def?: {
+    type?: string;
+    innerType?: ZodSchemaLike;
+    defaultValue?: unknown;
+  };
+}
+
+export interface ArgumentInfo {
+  /** The argument placeholder name */
+  name: string;
+  /** The argument description */
+  description: string;
+  /** '(optional)' or null */
+  optional: string | null;
+}
+
+export interface OptionInfo {
+  /** The option name (without dashes) */
+  name: string;
+  /** Aliases with dashes (short first, then name, then other long aliases) */
+  aliases: string[];
+  /** The option description */
+  description: string;
+  /** Placeholder, or null for booleans */
+  placeholder: string | null;
+  /** '(deprecated)', '(deprecated, with message)' or null */
+  deprecated: string | null;
+  /** '(required)' or null */
+  required: string | null;
+  /** '(default: value)' or null */
+  default: string | null;
+}
+
+export interface CommandInfo {
+  /** The usage line string */
+  usage: string;
+  /** Sorted by position, or null if no arguments */
+  args: ArgumentInfo[] | null;
+  /** Sorted by required first, then alphabetically, or null if no options */
+  options: OptionInfo[] | null;
+}

package/src/lib/zod-utils.js

@@ -0,0 +1,66 @@
+/**
+ * @typedef {Object} ZodSchemaLike
+ * @property {{ type?: string, innerType?: ZodSchemaLike, defaultValue?: unknown, typeName?: string, in?: ZodSchemaLike }} [_def]
+ */
+
+/**
+ * Checks if a Zod schema is a boolean.
+ * Handles wrapped schemas (default, optional, nullable).
+ * @param {ZodSchemaLike} schema
+ * @return {boolean}
+ */
+export function isBoolean(schema) {
+  const schemaType = schema._def?.type;
+  if (schemaType === 'boolean') return true;
+  if (schemaType === 'default' || schemaType === 'optional' || schemaType === 'nullable') {
+    const innerType = schema._def?.innerType;
+    if (innerType) return isBoolean(innerType);
+  }
+  return false;
+}
+
+/**
+ * Checks if a Zod schema is required (no default, not optional, not nullable).
+ * @param {ZodSchemaLike} schema
+ * @return {boolean}
+ */
+export function isRequired(schema) {
+  const schemaType = schema._def?.type;
+  if (schemaType === 'default' || schemaType === 'optional' || schemaType === 'nullable') {
+    return false;
+  }
+  // For pipe schemas (created by .transform()), check the input schema
+  if (schemaType === 'pipe') {
+    const inputSchema = schema._def?.in;
+    if (inputSchema) return isRequired(inputSchema);
+  }
+  return true;
+}
+
+/**
+ * Extracts the default value from a Zod schema.
+ * Handles wrapped schemas (optional, nullable, pipe).
+ * @param {ZodSchemaLike} schema
+ * @return {unknown}
+ */
+export function getDefault(schema) {
+  /** @type {ZodSchemaLike | undefined} */
+  let current = schema;
+  while (current) {
+    const schemaType = current._def?.type;
+    if (schemaType === 'default') {
+      return current._def?.defaultValue;
+    }
+    if (schemaType === 'optional' || schemaType === 'nullable') {
+      current = current._def?.innerType;
+      continue;
+    }
+    // For pipe schemas (created by .transform()), check the input schema
+    if (schemaType === 'pipe') {
+      current = current._def?.in;
+      continue;
+    }
+    break;
+  }
+  return undefined;
+}

package/src/models/addon.js

@@ -10,7 +10,6 @@ import { getAllLinkedAddons, linkAddon, unlinkAddon } from '@clevercloud/client/
 import { getAllAddonProviders } from '@clevercloud/client/esm/api/v2/product.js';
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
 import { getAddonProvider } from '@clevercloud/client/esm/api/v4/addon-providers.js';
-import cliparse from 'cliparse';
 import { confirm } from '../lib/prompts.js';
 import { Logger } from '../logger.js';
 import { resolveOwnerId } from './ids-resolver.js';
@@ -220,12 +219,12 @@ export async function rename(ownerId, addon, name) {
 }
 
 export function completeRegion() {
-  return cliparse.autocomplete.words(['par', 'mtl']);
+  return ['par', 'mtl'];
 }
 
 // TODO: We need to fix this
 export function completePlan() {
-  return cliparse.autocomplete.words(['dev', 's', 'm', 'l', 'xl', 'xxl']);
+  return ['dev', 's', 'm', 'l', 'xl', 'xxl'];
 }
 
 export async function findByName(addonName) {