clever-tools 4.5.2 → 4.6.0

package/src/commands/config-provider/config-provider.set.command.js

@@ -0,0 +1,37 @@
+import { getConfigProviderEnv, updateConfigProviderEnv } from '@clevercloud/client/esm/api/v4/addon.js';
+import { validateName } from '@clevercloud/client/esm/utils/env-vars.js';
+import { defineCommand } from '../../lib/define-command.js';
+import { Logger } from '../../logger.js';
+import { resolveConfigProviderId } from '../../models/config-provider.js';
+import { sendToApi } from '../../models/send-to-api.js';
+import { envVariableNameArg, envVariableValueArg } from '../global.args.js';
+import { configProviderIdOrNameArg } from './config-provider.args.js';
+
+export const configProviderSetCommand = defineCommand({
+  description: 'Add or update an environment variable named <variable-name> with the value <variable-value>',
+  since: '4.6.0',
+  options: {},
+  args: [configProviderIdOrNameArg, envVariableNameArg, envVariableValueArg],
+  async handler(_options, addonIdOrRealIdOrName, varName, varValue) {
+    const nameIsValid = validateName(varName);
+    if (!nameIsValid) {
+      throw new Error(`Variable name '${varName}' is invalid`);
+    }
+
+    const { realId } = await resolveConfigProviderId(addonIdOrRealIdOrName);
+
+    // API returns an array of { name, value } objects
+    const envVars = await getConfigProviderEnv({ configurationProviderId: realId }).then(sendToApi);
+    const existingIndex = envVars.findIndex((v) => v.name === varName);
+
+    if (existingIndex >= 0) {
+      envVars[existingIndex].value = varValue;
+    } else {
+      envVars.push({ name: varName, value: varValue });
+    }
+
+    await updateConfigProviderEnv({ configurationProviderId: realId }, envVars).then(sendToApi);
+
+    Logger.println('Environment variable has been set');
+  },
+});

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

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { z } from 'zod';
+import { config } from '../../config/config.js';
 import { defineArgument } from '../../lib/define-argument.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { defineOption } from '../../lib/define-option.js';
@@ -8,8 +9,7 @@ import { Logger } from '../../logger.js';
 import * as AppConfig from '../../models/app_configuration.js';
 import * as Application from '../../models/application.js';
 import { AVAILABLE_ZONES, listAvailableTypes, listAvailableZones } from '../../models/application.js';
-import { conf } from '../../models/configuration.js';
-import { isGitWorkingDirectoryClean, isInsideGitRepo } from '../../models/git.js';
+import { Git } from '../../models/git.js';
 import { aliasCreationOption, humanJsonOutputFormatOption, orgaIdOrNameOption } from '../global.options.js';
 
 function getGithubDetails(githubOwnerRepo) {
@@ -45,15 +45,16 @@ async function displayAppCreation(app, alias, github, taskCommand) {
   Logger.println('  ' + styleText('bold', 'Next steps:'));
 
   if (!github) {
-    const isInsideGit = await isInsideGitRepo();
-    if (!isInsideGit) {
+    const git = await Git.get();
+    const isInsideGitRepo = await git.isInsideGitRepo();
+    if (!isInsideGitRepo) {
       Logger.println(`  ${styleText('yellow', '!')} Initialize a git repository first, for example:`);
       Logger.println(`    ${shellCommand('git init')}`);
       Logger.println(`    ${shellCommand('git add .')}`);
       Logger.println(`    ${shellCommand('git commit -m "Initial commit"')}`);
       Logger.println();
     } else {
-      const isClean = await isGitWorkingDirectoryClean();
+      const isClean = await git.isGitWorkingDirectoryClean();
       if (!isClean) {
         Logger.println(`  ${styleText('yellow', '!')} Commit your changes first:`);
         Logger.println(`    ${shellCommand('git add .')}`);
@@ -74,7 +75,7 @@ async function displayAppCreation(app, alias, github, taskCommand) {
   }
 
   Logger.println(
-    `  ${styleText('blue', '→')} Manage your application at: ${styleText('underline', `${conf.GOTO_URL}/${app.id}`)}`,
+    `  ${styleText('blue', '→')} Manage your application at: ${styleText('underline', `${config.GOTO_URL}/${app.id}`)}`,
   );
   Logger.println('');
 }

package/src/commands/curl/curl.command.js

@@ -1,18 +1,17 @@
 import { addOauthHeader } from '@clevercloud/client/esm/oauth.js';
 import dedent from 'dedent';
 import { spawn } from 'node:child_process';
+import { config } from '../../config/config.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import { conf, loadOAuthConf } from '../../models/configuration.js';
 
-async function loadTokens() {
-  const tokens = await loadOAuthConf();
+function getTokens() {
   return {
-    OAUTH_CONSUMER_KEY: conf.OAUTH_CONSUMER_KEY,
-    OAUTH_CONSUMER_SECRET: conf.OAUTH_CONSUMER_SECRET,
-    API_OAUTH_TOKEN: tokens.token,
-    API_OAUTH_TOKEN_SECRET: tokens.secret,
+    OAUTH_CONSUMER_KEY: config.OAUTH_CONSUMER_KEY,
+    OAUTH_CONSUMER_SECRET: config.OAUTH_CONSUMER_SECRET,
+    API_OAUTH_TOKEN: config.token,
+    API_OAUTH_TOKEN_SECRET: config.secret,
   };
 }
 
@@ -21,16 +20,16 @@ function printCleverCurlHelp() {
     Usage: clever curl
     Query Clever Cloud's API using Clever Tools credentials. For example:
     
-      clever curl ${conf.API_HOST}/v2/self
-      clever curl ${conf.API_HOST}/v2/summary
-      clever curl ${conf.API_HOST}/v4/products/zones
-      clever curl ${conf.API_HOST}/v2/organisations/<ORGANISATION_ID>/applications | jq '.[].id'
-      clever curl ${conf.API_HOST}/v4/billing/organisations/<ORGANISATION_ID>/<INVOICE_NUMBER>.pdf > invoice.pdf
+      clever curl ${config.API_HOST}/v2/self
+      clever curl ${config.API_HOST}/v2/summary
+      clever curl ${config.API_HOST}/v4/products/zones
+      clever curl ${config.API_HOST}/v2/organisations/<ORGANISATION_ID>/applications | jq '.[].id'
+      clever curl ${config.API_HOST}/v4/billing/organisations/<ORGANISATION_ID>/<INVOICE_NUMBER>.pdf > invoice.pdf
     
     Our API documentation is available here :
     
-      ${conf.API_DOC_URL}/v2/
-      ${conf.API_DOC_URL}/v4/
+      ${config.API_DOC_URL}/v2/
+      ${config.API_DOC_URL}/v4/
   `);
 }
 
@@ -46,21 +45,21 @@ export async function curl() {
     return;
   }
 
-  const curlUrl = curlArgs.find((part) => part.startsWith(conf.API_HOST));
+  const curlUrl = curlArgs.find((part) => part.startsWith(config.API_HOST));
 
   // We only allow request to the respective API_HOST
   if (curlUrl == null) {
-    Logger.error('"clever curl" command must be used with ' + styleText('blue', conf.API_HOST));
+    Logger.error('"clever curl" command must be used with ' + styleText('blue', config.API_HOST));
     process.exit(1);
   }
 
   const lastCurlArg = curlArgs.at(-1);
-  const lastCurlArgIsHelp = lastCurlArg !== '--help' && lastCurlArg !== '-h';
+  const lastCurlArgIsNotHelp = lastCurlArg !== '--help' && lastCurlArg !== '-h';
 
   // Add OAuth header, only if last cURL arg is not help
   // We do this because cURL's help arg expect a category
-  if (lastCurlArgIsHelp) {
-    const tokens = await loadTokens();
+  if (lastCurlArgIsNotHelp) {
+    const tokens = getTokens();
     const oauthHeader = await Promise.resolve({})
       .then(addOauthHeader(tokens))
       .then((request) => request.headers.authorization);

package/src/commands/deploy/deploy.command.js

@@ -3,14 +3,14 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { defineCommand } from '../../lib/define-command.js';
 import { defineOption } from '../../lib/define-option.js';
+import { slugify } from '../../lib/slugify.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
 import * as AppConfig from '../../models/app_configuration.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 { completeBranches } 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 { sendToApi } from '../../models/send-to-api.js';
 import { aliasOption, exitOnDeployOption, followDeployLogsOption, quietOption } from '../global.options.js';
 
@@ -22,7 +22,7 @@ async function restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, withou
   return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, deploymentId: restart.deploymentId, quiet, exitStrategy });
 }
 
-async function getBranchToDeploy(branchName, tagName) {
+async function getBranchToDeploy(git, branchName, tagName) {
   if (tagName) {
     const useTag = await git.isExistingTag(tagName);
     if (useTag) {
@@ -46,7 +46,10 @@ export const deployCommand = defineCommand({
       description: 'Branch to push (current branch by default)',
       aliases: ['b'],
       placeholder: 'branch',
-      complete: completeBranches,
+      complete: async () => {
+        const git = await Git.get();
+        return git.completeBranches();
+      },
     }),
     tag: defineOption({
       name: 'tag',
@@ -78,11 +81,12 @@ export const deployCommand = defineCommand({
     const { alias, branch: branchName, tag: tagName, quiet, force, follow, sameCommitPolicy, exitOnDeploy } = options;
 
     const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
+    const git = await Git.get();
 
     const appData = await AppConfig.getAppDetails({ alias });
     const { ownerId, appId } = appData;
 
-    const branchRefspec = await getBranchToDeploy(branchName, tagName);
+    const branchRefspec = await getBranchToDeploy(git, branchName, tagName);
     const commitIdToPush = await git.getBranchCommit(branchRefspec);
     const remoteHeadCommitId = await git.getRemoteCommit(appData.deployUrl);
     const deployedCommitId = await Application.get(ownerId, appId).then(({ commitId }) => commitId);
@@ -141,7 +145,8 @@ export const deployCommand = defineCommand({
            ${styleText('blue', '→ Pushing source code to Clever Cloud…')}
       `);
 
-    await git.push(appData.deployUrl, commitIdToPush, force).catch(async (e) => {
+    const pushStart = Date.now();
+    await git.push(appData.deployUrl, commitIdToPush, force, slugify(appData.alias)).catch(async (e) => {
       const isShallow = await git.isShallow();
       if (isShallow) {
         throw new Error(
@@ -151,8 +156,9 @@ export const deployCommand = defineCommand({
         throw e;
       }
     });
+    const pushDuration = ((Date.now() - pushStart) / 1000).toFixed(1);
 
-    await Logger.println(`   ${styleText('green', '✓ Code pushed to Clever Cloud')}`);
+    await Logger.println(`   ${styleText('green', `✓ Code pushed to Clever Cloud (${pushDuration}s)`)}`);
 
     return Log.watchDeploymentAndDisplayLogs({
       ownerId,

package/src/commands/deploy/deploy.docs.md

@@ -20,3 +20,23 @@ clever deploy [options]
 |`-q`, `--quiet`|Don't show logs during deployment|
 |`-p`, `--same-commit-policy` `<policy>`|What to do when local and remote commit are identical (error, ignore, restart, rebuild) (default: error)|
 |`-t`, `--tag` `<tag>`|Tag to push (none by default)|
+
+### 🧪 Experimental: System git backend
+
+Clever Tools uses a current JS implementation for git operations. This works without requiring git to be installed on your system, but has some limitations:
+
+* **HTTP-only**: cannot use SSH-based git protocols
+* **Slow performance** on repositories with rewritten history (rebases, squashes)
+* **Connection timeouts** on large repositories or when pushing big files, due to HTTP-based transfers
+
+If you experience any of these issues, you can enable the **system git backend** which uses the `git` command installed on your system (it must be in your `PATH` environment variable).
+
+```bash
+clever features enable system-git
+```
+
+To disable and return to the current JS implementation:
+
+```bash
+clever features disable system-git
+```

package/src/commands/diag/diag.command.js

@@ -1,11 +1,12 @@
+import { get as getUser } from '@clevercloud/client/esm/api/v2/organisation.js';
 import { releaseInfo as getLinuxInfos } from 'linux-release-info';
 import os from 'node:os';
 import pkg from '../../../package.json' with { type: 'json' };
+import { config } from '../../config/config.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import { conf, loadOAuthConf } from '../../models/configuration.js';
-import * as User from '../../models/user.js';
+import { sendToApi } from '../../models/send-to-api.js';
 import { humanJsonOutputFormatOption } from '../global.options.js';
 
 function getShell() {
@@ -37,29 +38,27 @@ function getTerminal() {
   return process.env.TERM_PROGRAM || process.env.TERMINAL_EMULATOR || process.env.TERM;
 }
 
+function getAuthState({ hasToken, apiUser }) {
+  if (!hasToken) {
+    return 'not connected';
+  }
+  if (apiUser == null) {
+    return 'authentication failed';
+  }
+  return 'authenticated';
+}
+
 export const diagCommand = defineCommand({
   description: 'Diagnose the current installation (prints various informations for support)',
   since: '1.6.0',
   options: {
     format: humanJsonOutputFormatOption,
   },
-  args: [],
   async handler(options) {
-    const { format } = options;
-
-    /** @type {string} */
-    const userId = await User.getCurrentId().catch(() => null);
-    const authDetails = await loadOAuthConf();
-
-    function getAuthState() {
-      if (authDetails.token == null) {
-        return 'not connected';
-      }
-      if (userId == null) {
-        return 'authentication failed';
-      }
-      return 'authenticated';
-    }
+    const activeProfile = config.profiles[0];
+    const user = await getUser({})
+      .then(sendToApi)
+      .catch(() => null);
 
     const formattedDiag = {
       version: pkg.version,
@@ -72,11 +71,15 @@ export const diagCommand = defineCommand({
       terminal: getTerminal(),
       isPackaged: process.pkg != null,
       execPath: process.execPath,
-      configFile: conf.CONFIGURATION_FILE,
-      authSource: authDetails.source,
-      oAuthToken: authDetails.token,
-      authState: getAuthState(),
-      userId,
+      configFile: config.CONFIGURATION_FILE,
+      profile: activeProfile?.alias ?? null,
+      userId: activeProfile?.userId ?? user?.id ?? null,
+      authSource: activeProfile?.alias === '$env' ? 'environment variables' : 'configuration file',
+      oAuthToken: config.token,
+      loggedIn: user != null,
+      profileOverrides: activeProfile?.overrides ?? null,
+      // No longer useful but kept for compatibility reasons
+      authState: getAuthState({ hasToken: config.token != null, apiUser: user }),
     };
 
     const linuxInfos = await getLinuxInfos()
@@ -86,7 +89,7 @@ export const diagCommand = defineCommand({
       formattedDiag.linuxInfos = linuxInfos;
     }
 
-    switch (format) {
+    switch (options.format) {
       case 'json': {
         Logger.printJson(formattedDiag);
         break;
@@ -111,23 +114,33 @@ export const diagCommand = defineCommand({
         Logger.println('Exec path     ' + styleText('green', formattedDiag.execPath));
         Logger.println('Config file   ' + styleText('green', formattedDiag.configFile));
 
-        Logger.println('Auth source   ' + styleText('green', formattedDiag.authSource));
-
-        const token =
-          formattedDiag.oAuthToken == null ? styleText('red', '(none)') : styleText('green', formattedDiag.oAuthToken);
-        Logger.println('oAuth token   ' + token);
-
-        switch (formattedDiag.authState) {
-          case 'authenticated': {
+        if (formattedDiag.profile != null) {
+          Logger.println('Profile       ' + styleText('green', formattedDiag.profile));
+          if (formattedDiag.userId != null) {
             Logger.println('User ID       ' + styleText('green', formattedDiag.userId));
-            break;
-          }
-          case 'authentication failed': {
-            Logger.println('User ID       ' + styleText('red', 'Authentication failed'));
-            break;
           }
-          case 'not connected': {
-            Logger.println('User ID       ' + styleText('red', 'Not connected'));
+          Logger.println('Auth source   ' + styleText('green', formattedDiag.authSource));
+          Logger.println('Auth token    ' + styleText('green', formattedDiag.oAuthToken));
+        }
+
+        if (formattedDiag.profile == null) {
+          Logger.println('Auth state    ' + styleText('red', 'not connected'));
+        } else if (formattedDiag.loggedIn) {
+          Logger.println('Auth state    ' + styleText('green', 'valid token'));
+        } else {
+          Logger.println('Auth state    ' + styleText('red', 'expired or revoked token'));
+        }
+
+        if (formattedDiag.profileOverrides != null) {
+          const overrideEntries = Object.entries(formattedDiag.profileOverrides).filter(([k, v]) => v != null);
+          if (overrideEntries.length > 0) {
+            const maxKeyLength = Math.max(...overrideEntries.map(([key]) => key.length));
+            const pad = maxKeyLength + 2;
+            Logger.println('');
+            Logger.println('Profile overrides:');
+            for (const [key, value] of overrideEntries) {
+              Logger.println('  ' + key.padEnd(pad) + styleText('green', value));
+            }
           }
         }
       }

package/src/commands/features/features.disable.command.js

@@ -1,7 +1,6 @@
-import { EXPERIMENTAL_FEATURES } from '../../experimental-features.js';
+import { EXPERIMENTAL_FEATURES, setFeature } from '../../config/features.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { Logger } from '../../logger.js';
-import { setFeature } from '../../models/configuration.js';
 import { featuresArg } from './features.args.js';
 
 export const featuresDisableCommand = defineCommand({

package/src/commands/features/features.enable.command.js

@@ -1,7 +1,6 @@
-import { EXPERIMENTAL_FEATURES } from '../../experimental-features.js';
+import { EXPERIMENTAL_FEATURES, setFeature } from '../../config/features.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { Logger } from '../../logger.js';
-import { setFeature } from '../../models/configuration.js';
 import { featuresArg } from './features.args.js';
 
 export const featuresEnableCommand = defineCommand({

package/src/commands/features/features.info.command.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { EXPERIMENTAL_FEATURES } from '../../experimental-features.js';
+import { EXPERIMENTAL_FEATURES } from '../../config/features.js';
 import { defineArgument } from '../../lib/define-argument.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { Logger } from '../../logger.js';

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

@@ -1,8 +1,7 @@
-import { EXPERIMENTAL_FEATURES } from '../../experimental-features.js';
+import { EXPERIMENTAL_FEATURES, getFeatures } from '../../config/features.js';
 import { formatTable } from '../../format-table.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { Logger } from '../../logger.js';
-import { getFeatures } from '../../models/configuration.js';
 import { humanJsonOutputFormatOption } from '../global.options.js';
 
 export const featuresListCommand = defineCommand({

package/src/commands/global.commands.js

@@ -11,6 +11,13 @@ import { addonRenameCommand } from './addon/addon.rename.command.js';
 import { applicationsCommand } from './applications/applications.command.js';
 import { applicationsListCommand } from './applications/applications.list.command.js';
 import { cancelDeployCommand } from './cancel-deploy/cancel-deploy.command.js';
+import { configProviderCommand } from './config-provider/config-provider.command.js';
+import { configProviderGetCommand } from './config-provider/config-provider.get.command.js';
+import { configProviderImportCommand } from './config-provider/config-provider.import.command.js';
+import { configProviderListCommand } from './config-provider/config-provider.list.command.js';
+import { configProviderOpenCommand } from './config-provider/config-provider.open.command.js';
+import { configProviderRmCommand } from './config-provider/config-provider.rm.command.js';
+import { configProviderSetCommand } from './config-provider/config-provider.set.command.js';
 import { configCommand } from './config/config.command.js';
 import { configGetCommand } from './config/config.get.command.js';
 import { configSetCommand } from './config/config.set.command.js';
@@ -125,7 +132,9 @@ import { otoroshiVersionCheckCommand } from './otoroshi/otoroshi.version.check.c
 import { otoroshiVersionCommand } from './otoroshi/otoroshi.version.command.js';
 import { otoroshiVersionUpdateCommand } from './otoroshi/otoroshi.version.update.command.js';
 import { profileCommand } from './profile/profile.command.js';
+import { profileListCommand } from './profile/profile.list.command.js';
 import { profileOpenCommand } from './profile/profile.open.command.js';
+import { profileSwitchCommand } from './profile/profile.switch.command.js';
 import { publishedConfigCommand } from './published-config/published-config.command.js';
 import { publishedConfigImportCommand } from './published-config/published-config.import.command.js';
 import { publishedConfigRmCommand } from './published-config/published-config.rm.command.js';
@@ -192,6 +201,17 @@ export const globalCommands = {
       update: configUpdateCommand,
     },
   ],
+  'config-provider': [
+    configProviderCommand,
+    {
+      get: configProviderGetCommand,
+      import: configProviderImportCommand,
+      list: configProviderListCommand,
+      open: configProviderOpenCommand,
+      rm: configProviderRmCommand,
+      set: configProviderSetCommand,
+    },
+  ],
   console: consoleCommand,
   create: createCommand,
   curl: curlCommand,
@@ -400,7 +420,9 @@ export const globalCommands = {
   profile: [
     profileCommand,
     {
+      list: profileListCommand,
       open: profileOpenCommand,
+      switch: profileSwitchCommand,
     },
   ],
   'published-config': [

package/src/commands/global.options.js

@@ -47,7 +47,7 @@ export const afterOption = defineOption({
 export const addonIdOption = defineOption({
   name: 'addon',
   schema: z.string().optional(),
-  description: 'Add-on ID',
+  description: 'Add-on ID or real ID',
   placeholder: 'addon-id',
 });