clever-tools 4.4.1 → 4.5.0

package/src/commands/service/service.docs.md

@@ -0,0 +1,104 @@
+# 📖 `clever service` command reference
+
+## ➡️ `clever service` <kbd>Since 0.5.0</kbd>
+
+Manage service dependencies
+
+```bash
+clever service [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+|`--only-addons`|Only show add-on dependencies|
+|`--only-apps`|Only show app dependencies|
+|`--show-all`|Show all available add-ons and applications|
+
+## ➡️ `clever service link-addon` <kbd>Since 0.5.0</kbd>
+
+Link an existing add-on to this application
+
+```bash
+clever service link-addon <addon-id|addon-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`addon-id|addon-name`|Add-on ID (or name, if unambiguous)|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+
+## ➡️ `clever service link-app` <kbd>Since 0.5.0</kbd>
+
+Add an existing app as a dependency
+
+```bash
+clever service link-app <app-id|app-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`app-id|app-name`|Application ID (or name, if unambiguous)|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+
+## ➡️ `clever service unlink-addon` <kbd>Since 0.5.0</kbd>
+
+Unlink an add-on from this application
+
+```bash
+clever service unlink-addon <addon-id|addon-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`addon-id|addon-name`|Add-on ID (or name, if unambiguous)|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+
+## ➡️ `clever service unlink-app` <kbd>Since 0.5.0</kbd>
+
+Remove an app from the dependencies
+
+```bash
+clever service unlink-app <app-id|app-name> [options]
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`app-id|app-name`|Application ID (or name, if unambiguous)|
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|

package/src/commands/service/service.link-addon.command.js

@@ -0,0 +1,24 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import * as Addon from '../../models/addon.js';
+import * as Application from '../../models/application.js';
+import { addonIdOrNameArg } from '../global.args.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const serviceLinkAddonCommand = defineCommand({
+  description: 'Link an existing add-on to this application',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [addonIdOrNameArg],
+  async handler(options, addon) {
+    const { alias, app: appIdOrName } = options;
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    await Addon.link(ownerId, appId, addon);
+    Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully linked`);
+  },
+});

package/src/commands/service/service.link-app.command.js

@@ -0,0 +1,23 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { appIdOrNameArg } from '../global.args.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const serviceLinkAppCommand = defineCommand({
+  description: 'Add an existing app as a dependency',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [appIdOrNameArg],
+  async handler(options, dependency) {
+    const { alias, app: appIdOrName } = options;
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    await Application.link(ownerId, appId, dependency);
+    Logger.println(`App ${dependency.app_id || dependency.app_name} successfully linked`);
+  },
+});

package/src/commands/service/service.unlink-addon.command.js

@@ -0,0 +1,24 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import * as Addon from '../../models/addon.js';
+import * as Application from '../../models/application.js';
+import { addonIdOrNameArg } from '../global.args.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const serviceUnlinkAddonCommand = defineCommand({
+  description: 'Unlink an add-on from this application',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [addonIdOrNameArg],
+  async handler(options, addon) {
+    const { alias, app: appIdOrName } = options;
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    await Addon.unlink(ownerId, appId, addon);
+    Logger.println(`Addon ${addon.addon_id || addon.addon_name} successfully unlinked`);
+  },
+});

package/src/commands/service/service.unlink-app.command.js

@@ -0,0 +1,23 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { appIdOrNameArg } from '../global.args.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const serviceUnlinkAppCommand = defineCommand({
+  description: 'Remove an app from the dependencies',
+  since: '0.5.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [appIdOrNameArg],
+  async handler(options, dependency) {
+    const { alias, app: appIdOrName } = options;
+
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    await Application.unlink(ownerId, appId, dependency);
+    Logger.println(`App ${dependency.app_id || dependency.app_name} successfully unlinked`);
+  },
+});

package/src/commands/ssh/ssh.command.js

@@ -0,0 +1,40 @@
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import * as Application from '../../models/application.js';
+import { conf } from '../../models/configuration.js';
+import { aliasOption, appIdOrNameOption } from '../global.options.js';
+
+export const sshCommand = defineCommand({
+  description: 'Connect to running instances through SSH',
+  since: '0.7.0',
+  options: {
+    identityFile: defineOption({
+      name: 'identity-file',
+      schema: z.string().optional(),
+      description: 'SSH identity file',
+      aliases: ['i'],
+      placeholder: 'identity-file',
+    }),
+    alias: aliasOption,
+    app: appIdOrNameOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName, identityFile } = options;
+
+    const { appId } = await Application.resolveId(appIdOrName, alias);
+    const sshParams = ['-t', conf.SSH_GATEWAY, appId];
+    if (identityFile != null) {
+      sshParams.push('-i', identityFile);
+    }
+
+    await new Promise((resolve, reject) => {
+      // TODO: we should catch errors
+      const sshProcess = spawn('ssh', sshParams, { stdio: 'inherit' });
+      sshProcess.on('exit', resolve);
+      sshProcess.on('error', reject);
+    });
+  },
+});

package/src/commands/ssh/ssh.docs.md

@@ -0,0 +1,17 @@
+# 📖 `clever ssh` command reference
+
+## ➡️ `clever ssh` <kbd>Since 0.7.0</kbd>
+
+Connect to running instances through SSH
+
+```bash
+clever ssh [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+|`-i`, `--identity-file` `<identity-file>`|SSH identity file|

package/src/commands/ssh-keys/ssh-keys.add.command.js

@@ -0,0 +1,41 @@
+import { todo_addSshKey as addSshKey } from '@clevercloud/client/esm/api/v2/user.js';
+import fs from 'node:fs';
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { sshKeyNameArg } from './ssh-keys.args.js';
+
+export const sshKeysAddCommand = defineCommand({
+  description: 'Add a new SSH key to the current user',
+  since: '3.13.0',
+  options: {},
+  args: [
+    sshKeyNameArg,
+    defineArgument({
+      schema: z.string(),
+      description: 'SSH public key path (.pub)',
+      placeholder: 'ssh-key-path',
+    }),
+  ],
+  async handler(_options, keyName, filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File ${filePath} does not exist`);
+    }
+
+    const pubKeyContent = fs.readFileSync(filePath, 'utf8').trim();
+    Logger.debug(`SSH key file content: ${pubKeyContent}`);
+
+    try {
+      await addSshKey({ key: encodeURIComponent(keyName) }, JSON.stringify(pubKeyContent)).then(sendToApi);
+    } catch (e) {
+      console.log(e?.responseBody?.id);
+      if (e?.responseBody?.id === 505) {
+        throw new Error("This SSH key is not valid, please make sure you're pointing to the public key file");
+      }
+    }
+
+    Logger.printSuccess(`SSH key ${keyName} added successfully`);
+  },
+});

package/src/commands/ssh-keys/ssh-keys.args.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { defineArgument } from '../../lib/define-argument.js';
+
+export const sshKeyNameArg = defineArgument({
+  schema: z.string(),
+  description: 'SSH key name',
+  placeholder: 'ssh-key-name',
+});

package/src/commands/ssh-keys/ssh-keys.command.js

@@ -0,0 +1,50 @@
+import dedent from 'dedent';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { getUserSshKeys } from '../../models/ssh-keys.js';
+import { humanJsonOutputFormatOption } from '../global.options.js';
+
+export const sshKeysCommand = defineCommand({
+  description: 'Manage SSH keys of the current user',
+  since: '3.13.0',
+  options: {
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { format } = options;
+
+    const keys = await getUserSshKeys();
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(keys);
+        break;
+      }
+      case 'human':
+      default: {
+        if (keys.length === 0) {
+          Logger.println(dedent`
+              ${styleText('blue', '🔐 No SSH keys')}
+              
+              To list the SSH keys on your local system, use the following command:
+              ${styleText('grey', 'ssh-add -l -E sha256')}
+              
+              To create a new key pair, use the following command:
+              ${styleText('grey', 'ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_clever -C "An optional comment"')}
+              
+              Then add the public key to your Clever Cloud account:
+              ${styleText('grey', 'clever ssh-keys add myNewKey ~/.ssh/id_ed25519_clever.pub')}
+            `);
+          return;
+        }
+
+        Logger.println(`🔐 ${keys.length} SSH key(s):`);
+        keys.forEach((key) => {
+          Logger.println(` • ${styleText('blue', key.name)}`, styleText('grey', `(${key.fingerprint})`));
+        });
+      }
+    }
+  },
+});

package/src/commands/ssh-keys/ssh-keys.docs.md

@@ -0,0 +1,66 @@
+# 📖 `clever ssh-keys` command reference
+
+## ➡️ `clever ssh-keys` <kbd>Since 3.13.0</kbd>
+
+Manage SSH keys of the current user
+
+```bash
+clever ssh-keys [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+
+## ➡️ `clever ssh-keys add` <kbd>Since 3.13.0</kbd>
+
+Add a new SSH key to the current user
+
+```bash
+clever ssh-keys add <ssh-key-name> <ssh-key-path>
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`ssh-key-name`|SSH key name|
+|`ssh-key-path`|SSH public key path (.pub)|
+
+## ➡️ `clever ssh-keys open` <kbd>Since 3.13.0</kbd>
+
+Open the SSH keys management page in the Console
+
+```bash
+clever ssh-keys open
+```
+
+## ➡️ `clever ssh-keys remove` <kbd>Since 3.13.0</kbd>
+
+Remove a SSH key from the current user
+
+```bash
+clever ssh-keys remove <ssh-key-name>
+```
+
+### 📥 Arguments
+
+|Name|Description|
+|---|---|
+|`ssh-key-name`|SSH key name|
+
+## ➡️ `clever ssh-keys remove-all` <kbd>Since 3.13.0</kbd>
+
+Remove all SSH keys from the current user
+
+```bash
+clever ssh-keys remove-all [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-y`, `--yes`|Skip confirmation and remove all SSH keys directly|

package/src/commands/ssh-keys/ssh-keys.open.command.js

@@ -0,0 +1,12 @@
+import { defineCommand } from '../../lib/define-command.js';
+import { openBrowser } from '../../models/utils.js';
+
+export const sshKeysOpenCommand = defineCommand({
+  description: 'Open the SSH keys management page in the Console',
+  since: '3.13.0',
+  options: {},
+  args: [],
+  handler() {
+    return openBrowser('/users/me/ssh-keys', 'Opening the SSH keys management page of the Console in your browser');
+  },
+});

package/src/commands/ssh-keys/ssh-keys.remove-all.command.js

@@ -0,0 +1,54 @@
+import { todo_removeSshKey as removeSshKey } from '@clevercloud/client/esm/api/v2/user.js';
+import { z } from 'zod';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { confirm } from '../../lib/prompts.js';
+import { Logger } from '../../logger.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { getUserSshKeys } from '../../models/ssh-keys.js';
+
+export const sshKeysRemoveAllCommand = defineCommand({
+  description: 'Remove all SSH keys from the current user',
+  since: '3.13.0',
+  options: {
+    yes: defineOption({
+      name: 'yes',
+      schema: z.boolean().default(false),
+      description: 'Skip confirmation and remove all SSH keys directly',
+      aliases: ['y'],
+    }),
+  },
+  args: [],
+  async handler(options) {
+    if (!options.yes) {
+      await confirm('Are you sure you want to remove all your SSH keys?', 'No SSH keys removed');
+    }
+
+    const keys = await getUserSshKeys();
+
+    if (keys.length === 0) {
+      Logger.println('No SSH keys to remove');
+      return;
+    }
+
+    const results = await Promise.all(
+      keys.map((key) => {
+        const keyNameEncoded = encodeURIComponent(key.name);
+        return removeSshKey({ key: keyNameEncoded })
+          .then(sendToApi)
+          .then(() => [true, key.name])
+          .catch(() => [false, key.name]);
+      }),
+    );
+
+    if (results.every(([isRemoved]) => isRemoved)) {
+      Logger.printSuccess('All SSH keys were removed successfully');
+    } else {
+      const keyNamesWithErrors = results
+        .filter(([isRemoved]) => !isRemoved)
+        .map(([_, keyName]) => keyName)
+        .join(', ');
+      throw new Error(`Some errors occured while removing these SSH keys: ${keyNamesWithErrors}`);
+    }
+  },
+});

package/src/commands/ssh-keys/ssh-keys.remove.command.js

@@ -0,0 +1,26 @@
+import { todo_removeSshKey as removeSshKey } from '@clevercloud/client/esm/api/v2/user.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { getUserSshKeys } from '../../models/ssh-keys.js';
+import { sshKeyNameArg } from './ssh-keys.args.js';
+
+export const sshKeysRemoveCommand = defineCommand({
+  description: 'Remove a SSH key from the current user',
+  since: '3.13.0',
+  options: {},
+  args: [sshKeyNameArg],
+  async handler(_options, keyName) {
+    const keys = await getUserSshKeys();
+
+    if (keys.find((key) => key.name === keyName) == null) {
+      throw new Error(`SSH key ${styleText('red', keyName)} not found`);
+    }
+
+    const keyNameEncoded = encodeURIComponent(keyName);
+    await removeSshKey({ key: keyNameEncoded }).then(sendToApi);
+
+    Logger.printSuccess(`SSH key ${keyName} removed successfully`);
+  },
+});

package/src/commands/status/status.command.js

@@ -0,0 +1,122 @@
+import { getAllInstances, get as getApplication } from '@clevercloud/client/esm/api/v2/application.js';
+import _ from 'lodash';
+import { defineCommand } from '../../lib/define-command.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+import * as Application from '../../models/application.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { aliasOption, appIdOrNameOption, humanJsonOutputFormatOption } from '../global.options.js';
+
+function displayInstances(instances, commit) {
+  return `(${instances.map((instance) => `${instance.count}*${instance.flavor}`)},  Commit: ${commit || 'N/A'})`;
+}
+
+function computeStatus(instances, app) {
+  const upInstances = _.filter(instances, ({ state }) => state === 'UP');
+  const isUp = !_.isEmpty(upInstances);
+  const upCommit = _(upInstances).map('commit').head();
+
+  const deployingInstances = _.filter(instances, ({ state }) => state === 'DEPLOYING');
+  const isDeploying = !_.isEmpty(deployingInstances);
+  const deployingCommit = _(deployingInstances).map('commit').head();
+
+  const { minFlavor, maxFlavor, minInstances, maxInstances } = app.instance;
+
+  const scalabilityEnabled = minFlavor.name !== maxFlavor.name || minInstances !== maxInstances;
+
+  const status = {
+    id: app.id,
+    name: app.name,
+    type: {
+      name: app.instance.variant.name,
+      slug: app.instance.variant.slug,
+    },
+    lifetime: app.instance.lifetime,
+    status: isUp ? 'running' : 'stopped',
+    commit: upCommit,
+    instances: groupInstances(upInstances),
+    scalability: {
+      enabled: scalabilityEnabled,
+      vertical: { min: minFlavor.name, max: maxFlavor.name },
+      horizontal: { min: minInstances, max: maxInstances },
+    },
+    separateBuild: app.separateBuild,
+    buildFlavor: app.buildFlavor.name,
+  };
+
+  if (isDeploying) {
+    status.deploymentInProgress = {
+      commit: deployingCommit,
+      instances: groupInstances(deployingInstances),
+    };
+  }
+
+  return status;
+}
+
+function formatScalability({ min, max }) {
+  return min === max ? min.toString() : `${min} to ${max}`;
+}
+
+function groupInstances(instances) {
+  return _(instances)
+    .groupBy((i) => i.flavor.name)
+    .map((instances, flavorName) => ({
+      flavor: flavorName,
+      count: instances.length,
+    }))
+    .value();
+}
+
+export const statusCommand = defineCommand({
+  description: 'See the status of an application',
+  since: '0.2.0',
+  options: {
+    alias: aliasOption,
+    app: appIdOrNameOption,
+    format: humanJsonOutputFormatOption,
+  },
+  args: [],
+  async handler(options) {
+    const { alias, app: appIdOrName, format } = options;
+    const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+    const instances = await getAllInstances({ id: ownerId, appId }).then(sendToApi);
+    const app = await getApplication({ id: ownerId, appId }).then(sendToApi);
+
+    const status = computeStatus(instances, app);
+
+    switch (format) {
+      case 'json': {
+        Logger.printJson(status);
+        break;
+      }
+      case 'human':
+      default: {
+        const statusMessage =
+          status.status === 'running'
+            ? `${styleText(['bold', 'green'], 'running')} ${displayInstances(status.instances, status.commit)}`
+            : styleText(['bold', 'red'], 'stopped');
+
+        Logger.println(`${status.name}: ${statusMessage}`);
+        Logger.println(`Type: ${status.type.name}`);
+        Logger.println(`Executed as: ${styleText('bold', status.lifetime)}`);
+        if (status.deploymentInProgress) {
+          Logger.println(
+            `Deployment in progress ${displayInstances(status.deploymentInProgress.instances, status.deploymentInProgress.commit)}`,
+          );
+        }
+        Logger.println();
+        Logger.println('Scalability:');
+        Logger.println(
+          `  Auto scalability: ${status.scalability.enabled ? styleText('green', 'enabled') : styleText('red', 'disabled')}`,
+        );
+        Logger.println(`  Scalers: ${styleText('bold', formatScalability(status.scalability.horizontal))}`);
+        Logger.println(`  Sizes: ${styleText('bold', formatScalability(status.scalability.vertical))}`);
+        Logger.println(
+          `  Dedicated build: ${status.separateBuild ? styleText('bold', status.buildFlavor) : styleText('red', 'disabled')}`,
+        );
+      }
+    }
+  },
+});

package/src/commands/status/status.docs.md

@@ -0,0 +1,17 @@
+# 📖 `clever status` command reference
+
+## ➡️ `clever status` <kbd>Since 0.2.0</kbd>
+
+See the status of an application
+
+```bash
+clever status [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Short name for the application|
+|`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|