clever-tools 4.5.2 → 4.6.1

package/src/commands/login/login.command.js

@@ -1,14 +1,17 @@
+import { get as getUser } from '@clevercloud/client/esm/api/v2/organisation.js';
+import dedent from 'dedent';
 import crypto from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import open from 'open';
 import { z } from 'zod';
 import pkg from '../../../package.json' with { type: 'json' };
+import { baseConfig, config, saveProfile } from '../../config/config.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { defineOption } from '../../lib/define-option.js';
+import { formatProfile } from '../../lib/profile.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import { conf, writeOAuthConf } from '../../models/configuration.js';
-import * as User from '../../models/user.js';
+import { sendToApiWithConfig } from '../../models/send-to-api.js';
 
 function randomToken() {
   return crypto.randomBytes(20).toString('base64').replace(/\//g, '-').replace(/\+/g, '_').replace(/=/g, '');
@@ -40,24 +43,33 @@ function pollOauthData(url, tryCount = 0) {
     });
 }
 
-async function loginViaConsole() {
+async function loginViaConsole(apiHost, consoleTokenUrl) {
   const cliToken = randomToken();
 
-  const consoleUrl = new URL(conf.CONSOLE_TOKEN_URL);
+  const consoleUrl = new URL(consoleTokenUrl);
   consoleUrl.searchParams.set('cli_version', pkg.version);
   consoleUrl.searchParams.set('cli_token', cliToken);
 
-  const cliPollUrl = new URL(conf.API_HOST);
+  const cliPollUrl = new URL(apiHost);
   cliPollUrl.pathname = '/v2/self/cli_tokens';
   cliPollUrl.searchParams.set('cli_token', cliToken);
 
   Logger.debug('Try to login to Clever Cloud…');
-  Logger.println(`Opening ${styleText('green', consoleUrl.toString())} in your browser to log you in…`);
+  Logger.println(`Opening ${styleText('blue', consoleUrl.toString())} in your browser to log you in…`);
   await open(consoleUrl.toString(), { wait: false });
 
   return pollOauthData(cliPollUrl.toString());
 }
 
+/**
+ * Find an existing profile matching the target alias.
+ * @param {string} alias
+ * @returns {import('../../config/config.js').Profile | undefined}
+ */
+function getExistingTargetProfile(alias) {
+  return config.profiles.find((profile) => profile.alias === alias);
+}
+
 export const loginCommand = defineCommand({
   description: 'Login to Clever Cloud',
   since: '0.2.0',
@@ -65,34 +77,121 @@ export const loginCommand = defineCommand({
     token: defineOption({
       name: 'token',
       schema: z.string().optional(),
-      description: 'Directly give an existing token',
+      description: 'Provide an existing token',
       placeholder: 'token',
     }),
     secret: defineOption({
       name: 'secret',
       schema: z.string().optional(),
-      description: 'Directly give an existing secret',
+      description: 'Provide an existing secret',
+      placeholder: 'secret',
+    }),
+    alias: defineOption({
+      name: 'alias',
+      aliases: ['a'],
+      schema: z
+        .string()
+        .min(1, { message: 'Profile alias cannot be empty' })
+        .regex(/^[a-zA-Z0-9_-]+$/, { message: 'Alias must only contain letters, numbers, hyphens and underscores' })
+        .refine((a) => a !== '$env', { message: '"$env" is reserved auth via environment variables' })
+        .default('default'),
+      description: 'Profile alias',
+      placeholder: 'alias',
+    }),
+    apiHost: defineOption({
+      name: 'api-host',
+      schema: z.string().url().optional(),
+      description: 'API host URL override',
+      placeholder: 'url',
+    }),
+    consoleUrl: defineOption({
+      name: 'console-url',
+      schema: z.string().url().optional(),
+      description: 'Console URL override',
+      placeholder: 'url',
+    }),
+    authBridgeHost: defineOption({
+      name: 'auth-bridge-host',
+      schema: z.string().url().optional(),
+      description: 'Auth bridge URL override',
+      placeholder: 'url',
+    }),
+    sshGateway: defineOption({
+      name: 'ssh-gateway',
+      schema: z.string().optional(),
+      description: 'SSH gateway override',
+      placeholder: 'address',
+    }),
+    consumerKey: defineOption({
+      name: 'oauth-consumer-key',
+      schema: z.string().optional(),
+      description: 'OAuth consumer key override',
+      placeholder: 'key',
+    }),
+    consumerSecret: defineOption({
+      name: 'oauth-consumer-secret',
+      schema: z.string().optional(),
+      description: 'OAuth consumer secret override',
       placeholder: 'secret',
     }),
   },
-  args: [],
   async handler(options) {
     const { token, secret } = options;
-    const isLoginWithArgs = token != null && secret != null;
-    const isInteractiveLogin = token == null && secret == null;
+    const hasToken = token != null;
+    const hasSecret = secret != null;
+    const existingTargetProfile = getExistingTargetProfile(options.alias);
 
-    if (isLoginWithArgs) {
-      return writeOAuthConf({ token, secret });
+    if (hasToken !== hasSecret) {
+      throw new Error('Both `--token` and `--secret` must be defined');
     }
 
-    if (isInteractiveLogin) {
-      const oauthData = await loginViaConsole();
-      await writeOAuthConf(oauthData);
-      const { name, email } = await User.getCurrent();
-      const formattedName = name || styleText(['red', 'bold'], '[unspecified name]');
-      return Logger.println(`Login successful as ${formattedName} <${email}>`);
+    const apiHost = options.apiHost ?? baseConfig.API_HOST;
+    const consoleUrl = options.consoleUrl ? `${options.consoleUrl}/cli-oauth` : baseConfig.CONSOLE_TOKEN_URL;
+
+    if (!hasToken && existingTargetProfile != null) {
+      // KO fallback wording (3 lines):
+      // Press Ctrl+C to cancel this login if you do not want to overwrite this profile.
+      // Then run clever login --alias <another-alias> to login with a different alias.
+      Logger.println(dedent`
+        You are already logged in with profile ${styleText('gray', formatProfile(existingTargetProfile))}; this login may overwrite it.
+        Press ${styleText('gray', 'Ctrl+C')} to cancel, then run ${styleText('gray', 'clever login --alias <another-alias>')}.
+      `);
+      Logger.println();
     }
 
-    throw new Error('Both `--token` and `--secret` have to be defined');
+    const oauthData = hasToken ? { token, secret } : await loginViaConsole(apiHost, consoleUrl);
+
+    const user = await getUser({}).then(
+      sendToApiWithConfig({
+        token: oauthData.token,
+        secret: oauthData.secret,
+        apiHost,
+        consumerKey: options.consumerKey ?? baseConfig.OAUTH_CONSUMER_KEY,
+        consumerSecret: options.consumerSecret ?? baseConfig.OAUTH_CONSUMER_SECRET,
+      }),
+    );
+
+    const overrideEntries = Object.entries({
+      API_HOST: options.apiHost,
+      CONSOLE_URL: options.consoleUrl,
+      AUTH_BRIDGE_HOST: options.authBridgeHost,
+      SSH_GATEWAY: options.sshGateway,
+      OAUTH_CONSUMER_KEY: options.consumerKey,
+      OAUTH_CONSUMER_SECRET: options.consumerSecret,
+    }).filter(([, v]) => v != null);
+
+    const profile = {
+      alias: options.alias,
+      token: oauthData.token,
+      secret: oauthData.secret,
+      expirationDate: oauthData.expirationDate,
+      userId: user.id,
+      email: user.email,
+      overrides: overrideEntries.length > 0 ? Object.fromEntries(overrideEntries) : undefined,
+    };
+
+    await saveProfile(profile);
+
+    Logger.printSuccess(`Login successful as ${styleText('green', formatProfile(profile))}`);
   },
 });

package/src/commands/login/login.docs.md

@@ -12,5 +12,12 @@ clever login [options]
 
 |Name|Description|
 |---|---|
-|`--secret` `<secret>`|Directly give an existing secret|
-|`--token` `<token>`|Directly give an existing token|
+|`-a`, `--alias` `<alias>`|Profile alias (default: default)|
+|`--api-host` `<url>`|API host URL override|
+|`--auth-bridge-host` `<url>`|Auth bridge URL override|
+|`--console-url` `<url>`|Console URL override|
+|`--oauth-consumer-key` `<key>`|OAuth consumer key override|
+|`--oauth-consumer-secret` `<secret>`|OAuth consumer secret override|
+|`--secret` `<secret>`|Provide an existing secret|
+|`--ssh-gateway` `<address>`|SSH gateway override|
+|`--token` `<token>`|Provide an existing token|

package/src/commands/logout/logout.command.js

@@ -1,15 +1,47 @@
+import { z } from 'zod';
+import { config, removeProfile } from '../../config/config.js';
 import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { formatProfile } from '../../lib/profile.js';
+import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import { conf, writeOAuthConf } from '../../models/configuration.js';
 
 export const logoutCommand = defineCommand({
   description: 'Logout from Clever Cloud',
   since: '1.0.0',
-  options: {},
-  args: [],
-  async handler() {
-    // write empty object
-    await writeOAuthConf({});
-    Logger.println(`${conf.CONFIGURATION_FILE} has been updated.`);
+  options: {
+    alias: defineOption({
+      name: 'alias',
+      aliases: ['a'],
+      schema: z.string().optional(),
+      description: 'Alias of the profile to log out',
+      placeholder: 'alias',
+    }),
+  },
+  async handler(options) {
+    if (config.profiles.length === 0) {
+      throw new Error(`No profile found, use ${styleText('red', 'clever login')} command`);
+    }
+
+    const [activeProfile] = config.profiles;
+    const aliasToRemove = options.alias ?? activeProfile.alias;
+
+    if (aliasToRemove === '$env') {
+      throw new Error(
+        `Cannot logout from environment-based profile, unset ${styleText('red', 'CLEVER_TOKEN')} and ${styleText('red', 'CLEVER_SECRET')} instead`,
+      );
+    }
+
+    const profileToRemove = config.profiles.find((p) => p.alias === aliasToRemove);
+    if (profileToRemove == null) {
+      throw new Error(`Profile "${aliasToRemove}" not found.`);
+    }
+
+    const newActiveProfile = await removeProfile(aliasToRemove);
+    Logger.printSuccess(`Logged out of profile ${styleText('green', formatProfile(profileToRemove))}`);
+
+    if (newActiveProfile != null && newActiveProfile.alias !== activeProfile.alias) {
+      Logger.printSuccess(`Switched active profile to ${styleText('green', formatProfile(newActiveProfile))}`);
+    }
   },
 });

package/src/commands/logout/logout.docs.md

@@ -5,5 +5,11 @@
 Logout from Clever Cloud
 
 ```bash
-clever logout
+clever logout [options]
 ```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Alias of the profile to log out|

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

@@ -4,9 +4,8 @@ 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 { resolveAddonId } from '../../models/ids-resolver.js';
-import * as Log from '../../models/log-v4.js';
-import * as LogV2 from '../../models/log.js';
+import { resolveOwnerId, resolveRealId } from '../../models/ids-resolver.js';
+import * as Log from '../../models/log.js';
 import { Deferred } from '../../models/utils.js';
 import {
   addonIdOption,
@@ -57,15 +56,15 @@ export const logsCommand = defineCommand({
     const filter = search !== '' ? search : null;
     const isForHuman = format === 'human';
 
-    // TODO: drop when addons are migrated to the v4 API
     if (addonIdOrRealId != null) {
-      const addonId = await resolveAddonId(addonIdOrRealId);
+      const realId = await resolveRealId(addonIdOrRealId);
+      const ownerId = await resolveOwnerId(realId);
       if (isForHuman) {
         Logger.println(styleText('blue', 'Waiting for addon logs…'));
-      } else {
-        throw new Error(`"${format}" format is not yet available for add-on logs`);
       }
-      return LogV2.displayLogs({ appAddonId: addonId, since, until, filter, deploymentId });
+      const deferred = new Deferred();
+      await Log.displayLogs({ ownerId, addonId: realId, since, until, filter, format, deferred });
+      return deferred.promise;
     }
 
     const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);

package/src/commands/logs/logs.docs.md

@@ -12,7 +12,7 @@ clever logs [options]
 
 |Name|Description|
 |---|---|
-|`--addon` `<addon-id>`|Add-on ID|
+|`--addon` `<addon-id>`|Add-on ID or real ID|
 |`--after`, `--since` `<after>`|Fetch logs after this date/time (ISO8601 date, positive number in seconds or duration, e.g.: 1h)|
 |`-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/ng/ng.get-config.command.js

@@ -15,16 +15,16 @@ export const ngGetConfigCommand = defineCommand({
   async handler(options, peerIdOrLabel, ngIdOrLabel) {
     const { org, format } = options;
 
-    const config = await networkGroup.getPeerConfig(peerIdOrLabel, ngIdOrLabel, org);
+    const peerConfig = await networkGroup.getPeerConfig(peerIdOrLabel, ngIdOrLabel, org);
 
     switch (format) {
       case 'json': {
-        Logger.printJson(config);
+        Logger.printJson(peerConfig);
         break;
       }
       case 'human':
       default: {
-        const decodedConfiguration = Buffer.from(config.configuration, 'base64').toString('utf8');
+        const decodedConfiguration = Buffer.from(peerConfig.configuration, 'base64').toString('utf8');
         Logger.println(decodedConfiguration);
       }
     }

package/src/commands/profile/profile.command.js

@@ -1,8 +1,8 @@
-import dedent from 'dedent';
+import { config } from '../../config/config.js';
 import { defineCommand } from '../../lib/define-command.js';
+import { formatProfileDetails, getProfileDetails } from '../../lib/profile.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import * as User from '../../models/user.js';
 import { humanJsonOutputFormatOption } from '../global.options.js';
 
 export const profileCommand = defineCommand({
@@ -11,49 +11,25 @@ export const profileCommand = defineCommand({
   options: {
     format: humanJsonOutputFormatOption,
   },
-  args: [],
   async handler(options) {
-    const { format } = options;
-
-    const user = await User.getCurrent();
-    const currentToken = await User.getCurrentToken();
-    const tokenExpiration = new Date(currentToken.expirationDate).toLocaleString('en-US', {
-      year: 'numeric',
-      month: 'short',
-      day: 'numeric',
-      hour: 'numeric',
-      minute: 'numeric',
-      hour12: false,
-      timeZone: 'UTC',
-      timeZoneName: 'short',
-    });
+    const [activeProfile] = config.profiles;
+    if (activeProfile == null) {
+      throw new Error(`No profile found, use ${styleText('red', 'clever login')} command`);
+    }
 
-    const formattedUser = {
-      id: user.id,
-      email: user.email,
-      name: user.name,
-      avatar: user.avatar,
-      creationDate: new Date(user.creationDate),
-      tokenExpiration: new Date(currentToken.expirationDate).toISOString(),
-      lang: user.lang,
-      has2FA: user.preferredMFA != null && user.preferredMFA !== 'NONE',
-    };
+    const details = await getProfileDetails({ profile: activeProfile, isActive: true });
+    if (!details.isTokenValid) {
+      throw new Error(`Your token is invalid or has expired, use ${styleText('red', 'clever login')} command`);
+    }
 
-    switch (format) {
+    switch (options.format) {
       case 'json': {
-        Logger.printJson(formattedUser);
+        Logger.printJson(details);
         break;
       }
       case 'human':
       default: {
-        Logger.println(dedent`
-            You're currently logged in as:
-            User id           ${formattedUser.id}
-            Name              ${formattedUser.name ?? styleText(['red', 'bold'], '[not specified]')}
-            Email             ${formattedUser.email}
-            Token expiration  ${tokenExpiration}
-            Two factor auth   ${formattedUser.has2FA ? 'yes' : 'no'}
-          `);
+        Logger.println(formatProfileDetails(details));
       }
     }
   },

package/src/commands/profile/profile.docs.md

@@ -14,6 +14,20 @@ clever profile [options]
 |---|---|
 |`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
 
+## ➡️ `clever profile list` <kbd>Since 4.6.0</kbd>
+
+List all configured profiles
+
+```bash
+clever profile list [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-F`, `--format` `<format>`|Output format (human, json) (default: human)|
+
 ## ➡️ `clever profile open` <kbd>Since 3.11.0</kbd>
 
 Open your profile in the Console
@@ -21,3 +35,17 @@ Open your profile in the Console
 ```bash
 clever profile open
 ```
+
+## ➡️ `clever profile switch` <kbd>Since 4.6.0</kbd>
+
+Switch to a different profile
+
+```bash
+clever profile switch [options]
+```
+
+### ⚙️ Options
+
+|Name|Description|
+|---|---|
+|`-a`, `--alias` `<alias>`|Alias of the profile to switch to|

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

@@ -0,0 +1,44 @@
+import { config } from '../../config/config.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { formatProfileDetails, getProfileDetails } from '../../lib/profile.js';
+import { Logger } from '../../logger.js';
+import { humanJsonOutputFormatOption } from '../global.options.js';
+
+export const profileListCommand = defineCommand({
+  description: 'List all configured profiles',
+  since: '4.6.0',
+  options: {
+    format: humanJsonOutputFormatOption,
+  },
+  async handler(options) {
+    if (config.profiles.length === 0) {
+      throw new Error('No profile found. You are not logged in.');
+    }
+
+    const profilesDetails = await Promise.all(
+      config.profiles.map(async (profile, index) => {
+        return getProfileDetails({
+          profile,
+          isActive: index === 0,
+        });
+      }),
+    );
+
+    switch (options.format) {
+      case 'json': {
+        Logger.printJson(profilesDetails);
+        break;
+      }
+      case 'human':
+      default: {
+        Logger.println(
+          profilesDetails
+            .map((details) => {
+              return formatProfileDetails(details);
+            })
+            .join('\n\n'),
+        );
+      }
+    }
+  },
+});

package/src/commands/profile/profile.switch.command.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { config, saveProfile } from '../../config/config.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { defineOption } from '../../lib/define-option.js';
+import { formatProfile } from '../../lib/profile.js';
+import { selectAnswer } from '../../lib/prompts.js';
+import { styleText } from '../../lib/style-text.js';
+import { Logger } from '../../logger.js';
+
+/** @typedef {import('../../config/config.js').Profile} Profile */
+
+export const profileSwitchCommand = defineCommand({
+  description: 'Switch to a different profile',
+  since: '4.6.0',
+  options: {
+    alias: defineOption({
+      name: 'alias',
+      aliases: ['a'],
+      schema: z.string().optional(),
+      description: 'Alias of the profile to switch to',
+      placeholder: 'alias',
+    }),
+  },
+  async handler(options) {
+    if (config.profiles.length === 0) {
+      throw new Error('No profile found.');
+    }
+
+    if (config.profiles.length === 1) {
+      throw new Error('Only one profile. Use clever login --alias <name> to add another.');
+    }
+
+    const [activeProfile] = config.profiles;
+    if (activeProfile.alias === '$env') {
+      throw new Error(
+        `Cannot switch profiles while using environment-based authentication, unset ${styleText('red', 'CLEVER_TOKEN')} and ${styleText('red', 'CLEVER_SECRET')} instead`,
+      );
+    }
+
+    const targetProfile = await resolveTargetProfile(config.profiles, options.alias);
+    if (targetProfile.alias === activeProfile.alias) {
+      Logger.printInfo(`Already on profile ${styleText('blue', formatProfile(activeProfile))}`);
+      return;
+    }
+
+    await saveProfile(targetProfile);
+    Logger.printSuccess(`Switched to profile ${styleText('green', formatProfile(targetProfile))}`);
+  },
+});
+
+/**
+ * Resolve the target profile to switch to.
+ * @param {Profile[]} profiles
+ * @param {string | undefined} requestedAlias
+ * @returns {Promise<Profile>}
+ */
+async function resolveTargetProfile(profiles, requestedAlias) {
+  if (requestedAlias != null) {
+    const targetProfile = profiles.find((p) => p.alias === requestedAlias);
+    if (targetProfile == null) {
+      const availableAliases = profiles.map((p) => p.alias).join(', ');
+      throw new Error(
+        `Profile "${styleText('red', requestedAlias)}" not found. Available profiles: ${availableAliases}`,
+      );
+    }
+    return targetProfile;
+  }
+
+  if (profiles.length === 2) {
+    Logger.printInfo(`Switching to ${styleText('blue', formatProfile(profiles[1]))}`);
+    return profiles[1];
+  }
+
+  const choices = profiles.map((profile) => ({
+    name: formatProfile(profile),
+    value: profile.alias,
+  }));
+  const selectedAlias = await selectAnswer('Select a profile:', choices);
+  return profiles.find((profile) => profile.alias === selectedAlias);
+}

package/src/commands/restart/restart.command.js

@@ -5,8 +5,8 @@ import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
 import * as Application from '../../models/application.js';
 import * as ExitStrategy from '../../models/exit-strategy-option.js';
-import * as git from '../../models/git.js';
-import * as Log from '../../models/log-v4.js';
+import { Git } from '../../models/git.js';
+import * as Log from '../../models/log.js';
 import {
   aliasOption,
   appIdOrNameOption,
@@ -43,6 +43,7 @@ export const restartCommand = defineCommand({
     const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
 
     const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+    const git = await Git.get();
     const fullCommitId = await git.resolveFullCommitId(commit);
     const app = await Application.get(ownerId, appId);
 

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

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process';
 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 * as Application from '../../models/application.js';
-import { conf } from '../../models/configuration.js';
 import { aliasOption, appIdOrNameOption } from '../global.options.js';
 
 export const sshCommand = defineCommand({
@@ -25,7 +25,7 @@ export const sshCommand = defineCommand({
     const { alias, app: appIdOrName, identityFile } = options;
 
     const { appId } = await Application.resolveId(appIdOrName, alias);
-    const sshParams = ['-t', conf.SSH_GATEWAY, appId];
+    const sshParams = ['-t', config.SSH_GATEWAY, appId];
     if (identityFile != null) {
       sshParams.push('-i', identityFile);
     }

package/src/commands/tokens/tokens.command.js

@@ -1,14 +1,14 @@
 import { listApiTokens } from '../../clever-client/auth-bridge.js';
+import { config } from '../../config/config.js';
+import { formatDate } from '../../lib/date-utils.js';
 import { defineCommand } from '../../lib/define-command.js';
-import { formatDate } from '../../lib/format-date.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import { conf } from '../../models/configuration.js';
 import { sendToAuthBridge } from '../../models/send-to-api.js';
 import { humanJsonOutputFormatOption } from '../global.options.js';
 
 export const tokensCommand = defineCommand({
-  description: `Manage API tokens to query Clever Cloud API from ${conf.AUTH_BRIDGE_HOST}`,
+  description: `Manage API tokens to query Clever Cloud API from ${config.AUTH_BRIDGE_HOST}`,
   since: '3.12.0',
   options: {
     format: humanJsonOutputFormatOption,