clever-tools 4.6.1 → 4.7.1

package/package.json

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

package/src/commands/database/database.backups.download.command.js

@@ -1,6 +1,7 @@
 import { getBackups } from '@clevercloud/client/esm/api/v2/backups.js';
 import fs from 'node:fs';
-import { Writable } from 'node:stream';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import { z } from 'zod';
 import { defineArgument } from '../../lib/define-argument.js';
 import { defineCommand } from '../../lib/define-command.js';
@@ -50,6 +51,7 @@ export const databaseBackupsDownloadCommand = defineCommand({
       throw new Error('Failed to download backup');
     }
 
-    await response.body.pipeTo(Writable.toWeb(output ? fs.createWriteStream(output) : process.stdout));
+    const nodeReadable = Readable.fromWeb(response.body);
+    await pipeline(nodeReadable, output ? fs.createWriteStream(output) : process.stdout);
   },
 });

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

@@ -55,7 +55,7 @@ export const drainCreateCommand = defineCommand({
   args: [
     defineArgument({
       schema: z.string(),
-      description: 'No description available',
+      description: `Drain type (${DRAIN_TYPE_CLI_CODES.join(', ')})`,
       placeholder: 'drain-type',
       complete: DRAIN_TYPE_CLI_CODES,
     }),

package/src/commands/drain/drain.docs.md

@@ -28,7 +28,7 @@ clever drain create <drain-type> <drain-url> [options]
 
 |Name|Description|
 |---|---|
-|`drain-type`|No description available|
+|`drain-type`|Drain type (datadog, elasticsearch, newrelic, ovh-tcp, raw-http, syslog-tcp, syslog-udp)|
 |`drain-url`|Drain URL|
 
 ### ⚙️ Options

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

@@ -1,9 +1,13 @@
+import { getAllInstances } from '@clevercloud/client/esm/api/v2/application.js';
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { config } from '../../config/config.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { defineOption } from '../../lib/define-option.js';
+import { selectAnswer } from '../../lib/prompts.js';
 import * as Application from '../../models/application.js';
+import { sendToApi } from '../../models/send-to-api.js';
 import { aliasOption, appIdOrNameOption } from '../global.options.js';
 
 export const sshCommand = defineCommand({
@@ -17,24 +21,102 @@ export const sshCommand = defineCommand({
       aliases: ['i'],
       placeholder: 'identity-file',
     }),
+    command: defineOption({
+      name: 'command',
+      schema: z.string().optional(),
+      description: 'Execute a command on the remote instance and exit',
+      aliases: ['c'],
+      placeholder: 'command',
+    }),
     alias: aliasOption,
     app: appIdOrNameOption,
   },
   args: [],
   async handler(options) {
-    const { alias, app: appIdOrName, identityFile } = options;
+    const { alias, app: appIdOrName, identityFile, command } = options;
+    const { appId, ownerId } = await Application.resolveId(appIdOrName, alias);
+
+    const instances = await getAllInstances({ id: ownerId, appId }).then(sendToApi);
+
+    if (instances.length === 0) {
+      throw new Error('No running instances found for this application');
+    }
+
+    let sshTarget;
+    if (instances.length === 1) {
+      sshTarget = instances[0].id;
+    } else if (process.stdout.isTTY) {
+      const choices = instances
+        .sort((a, b) => a.instanceNumber - b.instanceNumber)
+        .map((inst) => ({
+          name: `${inst.displayName} - Instance ${inst.instanceNumber} - ${inst.state} (${inst.id})`,
+          value: inst.id,
+        }));
+      sshTarget = await selectAnswer('Select an instance:', choices);
+    } else {
+      throw new Error('Multiple instances are running. Cannot select in non-interactive mode.');
+    }
 
-    const { appId } = await Application.resolveId(appIdOrName, alias);
-    const sshParams = ['-t', config.SSH_GATEWAY, appId];
+    const sshParams = [];
+    // -t: force PTY allocation (SSH skips it by default because appId is passed as a command for gateway routing)
+    if (command == null) {
+      sshParams.push('-t');
+    }
     if (identityFile != null) {
       sshParams.push('-i', identityFile);
     }
+    sshParams.push(config.SSH_GATEWAY, sshTarget);
 
-    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);
+    // Interactive session mode (spawn SSH with inherited stdio)
+    if (command == null) {
+      return new Promise((resolve, reject) => {
+        const sshProcess = spawn('ssh', sshParams, { stdio: 'inherit' });
+        sshProcess.on('exit', resolve);
+        sshProcess.on('error', reject);
+      });
+    }
+
+    // Single command mode (pipe stdio to filter gateway noise via a marker)
+    const sshProcess = spawn('ssh', sshParams, { stdio: 'pipe' });
+
+    // We can't pass the command directly via `ssh gateway 'cmd'` because appId already occupies
+    // the remote command slot (used by the gateway for routing). So we write into stdin and use
+    // a marker to delimit the start of real output from gateway/login noise.
+    const marker = `__CLEVER_${randomUUID()}__`;
+    sshProcess.stdin.write(`echo '${marker}'\n`);
+
+    // `exec $SHELL --login -c` ensures the full login environment is loaded (.bashrc, env vars)
+    // while keeping stdout clean (no PTY = no prompt/ANSI noise).
+    const escapedCommand = command.replaceAll("'", "'\\''");
+    sshProcess.stdin.write(`exec $SHELL --login -c '${escapedCommand}'\n`);
+    sshProcess.stdin.end();
+
+    // Skip gateway/login noise on both stdout and stderr, stream after the marker
+    let started = false;
+    let buf = '';
+    sshProcess.stdout.on('data', (chunk) => {
+      if (started) {
+        process.stdout.write(chunk);
+        return;
+      }
+      buf += chunk.toString();
+      const idx = buf.indexOf(marker + '\n');
+      if (idx !== -1) {
+        started = true;
+        const rest = buf.slice(idx + marker.length + 1);
+        if (rest) process.stdout.write(rest);
+        buf = '';
+      }
+    });
+
+    // Discard stderr noise before the marker, forward after
+    sshProcess.stderr.on('data', (chunk) => {
+      if (started) {
+        process.stderr.write(chunk);
+      }
     });
+
+    const exitCode = await new Promise((resolve) => sshProcess.on('exit', resolve));
+    process.exit(exitCode);
   },
 });

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

@@ -14,4 +14,5 @@ clever ssh [options]
 |---|---|
 |`-a`, `--alias` `<alias>`|Short name for the application|
 |`--app` `<app-id\|app-name>`|Application to manage by its ID (or name, if unambiguous)|
+|`-c`, `--command` `<command>`|Execute a command on the remote instance and exit|
 |`-i`, `--identity-file` `<identity-file>`|SSH identity file|

package/src/models/drain.js

@@ -10,6 +10,26 @@ export const DRAIN_TYPES = {
 
 export const DRAIN_TYPE_CLI_CODES = Object.values(DRAIN_TYPES).map(({ cliCode }) => cliCode);
 
+function formatRate(messagesPerSecond) {
+  if (messagesPerSecond < 1) {
+    return Math.floor(messagesPerSecond * 3600) + ' messages/hour';
+  }
+  if (messagesPerSecond < 60) {
+    return Math.floor(messagesPerSecond * 60) + ' messages/minute';
+  }
+  return Math.floor(messagesPerSecond) + ' messages/second';
+}
+
+function formatThroughput(bytesPerSecond) {
+  if (bytesPerSecond < 1024) {
+    return Math.floor(bytesPerSecond) + ' bytes/second';
+  }
+  if (bytesPerSecond < 1024 * 1024) {
+    return (bytesPerSecond / 1024).toFixed(2) + ' KiB/second';
+  }
+  return (bytesPerSecond / (1024 * 1024)).toFixed(2) + ' MiB/second';
+}
+
 export function formatDrain(rawDrain) {
   const drainType = DRAIN_TYPES[rawDrain.recipient.type];
   const drainDetails = [
@@ -20,9 +40,18 @@ export function formatDrain(rawDrain) {
     ['Type', drainType.label],
     ['Custom index', rawDrain.recipient.index],
     ['SD parameters', rawDrain.recipient.rfc5424StructuredDataParameters],
-    ['Message output rate', Math.floor(rawDrain.backlog.msgRateOut * 60) + ' messages/minute'],
-    ['Message throughput', Math.floor(rawDrain.backlog.msgRateOut) + ' bytes/second'],
+    ['Message output rate', formatRate(rawDrain.backlog.msgRateOut)],
+    ['Message throughput', formatThroughput(rawDrain.backlog.msgThroughputOut)],
     ['Backlog', rawDrain.backlog.msgBacklog + ' pending messages'],
+    [
+      'Retry attempts',
+      rawDrain.execution.attempt != null && rawDrain.execution.maxAttempt != null
+        ? `${rawDrain.execution.attempt}/${rawDrain.execution.maxAttempt}`
+        : null,
+    ],
+    ['Last attempt at', rawDrain.execution.lastAttemptAt],
+    ['Next attempt at', rawDrain.execution.nextAttemptAt],
+    ['Retrying since', rawDrain.execution.retryingSince],
     ['Last error', rawDrain.execution.lastError],
   ];
   return Object.fromEntries(drainDetails.filter(([_name, value]) => value != null));

package/src/models/git-system.js

@@ -86,20 +86,13 @@ export class GitSystem extends Git {
   async getFullBranch(branchName) {
     this._debug('getFullBranch', branchName);
     const git = await this.#getSimpleGit();
-    if (branchName === '') {
-      const branch = await git.branch();
-      if (branch.current) {
-        return `refs/heads/${branch.current}`;
-      }
-      return 'HEAD';
-    }
-    // Try to expand the ref
+    const ref = branchName === '' ? 'HEAD' : branchName;
     try {
-      const fullRef = await git.revparse(['--symbolic-full-name', branchName]);
+      const fullRef = await git.revparse(['--symbolic-full-name', ref]);
       return fullRef.trim();
     } catch {
-      // If it fails, it might be a commit hash, return as-is
-      return branchName;
+      // Not a symbolic ref (e.g. a commit hash), return as-is
+      return ref;
     }
   }