clever-tools 4.5.2 → 4.6.1

package/src/models/log.js

@@ -1,108 +1,116 @@
-import { getOldLogs } from '@clevercloud/client/esm/api/v2/log.js';
-import { LogsStream } from '@clevercloud/client/esm/streams/logs.node.js';
-import _ from 'lodash';
+import { ApplicationLogStream } from '@clevercloud/client/esm/streams/application-logs.js';
+import { ResourceLogStream } from '@clevercloud/client/esm/streams/resource-logs.js';
+import { config } from '../config/config.js';
 import { styleText } from '../lib/style-text.js';
 import { Logger } from '../logger.js';
 import { waitForDeploymentEnd, waitForDeploymentStart } from './deployments.js';
+import { getBest } from './domain.js';
 import * as ExitStrategy from './exit-strategy-option.js';
-import { getHostAndTokens, sendToApi } from './send-to-api.js';
+import { JsonArray } from './json-array.js';
+import { getHostAndTokens, processError } from './send-to-api.js';
 import { Deferred } from './utils.js';
 
-function isCleverMessage(line) {
-  return line._source.syslog_program === '/home/bas/rubydeployer/deployer.rb';
-}
+const RESET_COLOR = '\x1B[0m';
 
-function isDeploymentSuccessMessage(line) {
-  return isCleverMessage(line) && _.startsWith(line._source['@message'].toLowerCase(), 'successfully deployed in');
-}
+// 2000 logs per 100ms maximum
+const THROTTLE_ELEMENTS = 2000;
+const THROTTLE_PER_IN_MILLISECONDS = 100;
 
-function isDeploymentFailedMessage(line) {
-  return isCleverMessage(line) && _.startsWith(line._source['@message'].toLowerCase(), 'deploy failed in');
-}
+const retryConfiguration = {
+  enabled: true,
+  initRetryTimeout: 3000,
+  maxRetryCount: 10,
+};
 
-function isBuildSucessMessage(line) {
-  return isCleverMessage(line) && _.startsWith(line._source['@message'].toLowerCase(), 'build succeeded in');
-}
+export async function displayLogs(params) {
+  const deferred = params.deferred || new Deferred();
+  const { apiHost, tokens } = await getHostAndTokens();
+  const { ownerId, appId, addonId, filter, since, until, format } = params;
+  // deploymentId only applies to apps
+  const deploymentId = addonId != null ? undefined : params.deploymentId;
 
-function formatLogLine(line) {
-  const { '@timestamp': timestamp, '@message': message } = line._source;
-  if (isDeploymentSuccessMessage(line)) {
-    return `${timestamp}: ${styleText(['bold', 'green'], message)}`;
-  } else if (isDeploymentFailedMessage(line)) {
-    return `${timestamp}: ${styleText(['bold', 'red'], message)}`;
-  } else if (isBuildSucessMessage(line)) {
-    return `${timestamp}: ${styleText(['bold', 'blue'], message)}`;
+  if (format === 'json' && until == null) {
+    throw new Error('"json" format is only applicable with a limiting parameter such as `--until`');
   }
-  return `${timestamp}: ${message}`;
-}
 
-async function displayLiveLogs({ appId, filter, until, deploymentId }, deferred) {
-  const { apiHost, tokens } = await getHostAndTokens();
-  const logsStream = new LogsStream({ apiHost, tokens, appId, filter, deploymentId });
-
-  logsStream
-    .on('open', () => Logger.debug('SSE for logs (open) ' + JSON.stringify({ appId, filter, deploymentId })))
-    .on('log', (line) => {
-      const { '@timestamp': timestamp } = line._source;
-      if (until != null && new Date(timestamp) > until) {
-        logsStream.close();
-      } else {
-        Logger.println(formatLogLine(line));
+  const commonStreamParams = {
+    apiHost,
+    tokens,
+    ownerId,
+    connectionTimeout: 10_000,
+    retryConfiguration,
+    since,
+    until,
+    deploymentId,
+    filter,
+    throttleElements: THROTTLE_ELEMENTS,
+    throttlePerInMilliseconds: THROTTLE_PER_IN_MILLISECONDS,
+  };
+
+  const logStream =
+    addonId != null
+      ? new ResourceLogStream({ ...commonStreamParams, addonId })
+      : new ApplicationLogStream({ ...commonStreamParams, appId });
+
+  // Properly close the stream
+  process.once('SIGINT', (signal) => {
+    logStream.close(signal);
+    process.kill(process.pid, 'SIGINT');
+  });
+  const jsonArray = new JsonArray();
+
+  logStream
+    .on('open', () => {
+      Logger.debug(styleText('blue', `Logs stream (open) ${JSON.stringify({ appId, addonId, filter, deploymentId })}`));
+      if (format === 'json') {
+        jsonArray.open();
       }
     })
-    .on('ping', () => Logger.debug('SSE for logs (ping)'))
-    .on('close', ({ reason }) => Logger.debug('SSE for logs (close) ' + reason))
-    .on('error', (error) => deferred.reject(error));
-
-  logsStream.open({ autoRetry: true, maxRetryCount: 6 });
+    .on('error', (event) => {
+      Logger.debug(styleText('red', `Logs stream (error) ${event.error.message}`));
+    })
+    .onLog((log) => {
+      switch (format) {
+        case 'json':
+          jsonArray.push(log);
+          return;
+        case 'json-stream':
+          Logger.println(JSON.stringify(log));
+          return;
+        case 'human':
+        default:
+          if (log.message === RESET_COLOR) {
+            return;
+          }
+          Logger.println(formatLogLine(log));
+      }
+    });
+
+  // start() is blocking until end of stream
+  logStream
+    .start()
+    .then(() => {
+      if (format === 'json') {
+        jsonArray.close();
+      }
+      return deferred.resolve();
+    })
+    .catch(processError)
+    .catch((error) => deferred.reject(error));
 
-  return logsStream;
+  return logStream;
 }
 
-export async function displayLogs({ appAddonId, until, since, filter, deploymentId }) {
-  const now = new Date();
-
-  const fetchOldLogs = since == null || since < now;
-  if (fetchOldLogs) {
-    const oldLogs = await getOldLogs({
-      appId: appAddonId,
-      before: until != null ? until.toISOString() : null,
-      after: since != null ? since.toISOString() : null,
-      filter,
-      deployment_id: deploymentId,
-    }).then(sendToApi);
-
-    for (const line of oldLogs.reverse()) {
-      Logger.println(formatLogLine(line));
-    }
-  }
-
-  // No need to fetch live logs if until date is in the past
-  if (until != null && until < now) {
-    return;
-  }
-
-  const deferred = new Deferred();
+export async function watchDeploymentAndDisplayLogs(options) {
+  const { ownerId, appId, deploymentId, commitId, knownDeployments, quiet, redeployDate, exitStrategy } = options;
 
-  await displayLiveLogs({ appId: appAddonId, filter, deploymentId, until }, deferred);
-
-  return deferred.promise;
-}
-
-export async function watchDeploymentAndDisplayLogs({
-  ownerId,
-  appId,
-  deploymentId,
-  commitId,
-  knownDeployments,
-  quiet,
-  exitStrategy,
-}) {
   ExitStrategy.plotQuietWarning(exitStrategy, quiet);
   // If in quiet mode, we only log start/finished deployment messages
-  Logger.println('Waiting for deployment to start…');
+  if (!quiet) {
+    Logger.println(`   ${styleText('blue', '→ Waiting for deployment to start…')}`);
+  }
   const deployment = await waitForDeploymentStart({ ownerId, appId, deploymentId, commitId, knownDeployments });
-  Logger.println(styleText(['bold', 'blue'], `Deployment started (${deployment.uuid})`));
+  Logger.println(`   ${styleText('green', `✓ Deployment started ${styleText('grey', `(${deployment.uuid})`)}`)}`);
 
   if (exitStrategy === 'deploy-start') {
     return;
@@ -113,15 +121,17 @@ export async function watchDeploymentAndDisplayLogs({
 
   if (!quiet) {
     // About the deferred…
-    // If displayLiveLogs() throws an error,
+    // If displayLogs() throws an error,
     // the async function we're in (watchDeploymentAndDisplayLogs) will stop here and the error will be passed to the parent.
-    // displayLiveLogs() defines callback listeners so if it catches error in those callbacks,
+    // displayLogs() defines callback listeners so if it catches error in those callbacks,
     // it has no proper way to bubble up the error here.
     // Using the deferred enables this.
-    logsStream = await displayLiveLogs({ appId, deploymentId: deployment.uuid }, deferred);
+    logsStream = await displayLogs({ ownerId, appId, deploymentId: deployment.uuid, since: redeployDate, deferred });
   }
 
-  Logger.println('Waiting for application logs…');
+  if (!quiet) {
+    Logger.println(`   ${styleText('blue', '→ Waiting for application logs…')}`);
+  }
 
   // Wait for deployment end (or an error thrown by logs with the deferred)
   const deploymentEnded = await Promise.race([
@@ -130,7 +140,7 @@ export async function watchDeploymentAndDisplayLogs({
   ]);
 
   if (!quiet && exitStrategy !== 'never') {
-    logsStream.close();
+    logsStream.close(quiet ? 'quiet' : 'follow');
   }
 
   // deploymentEnded can be undefined if deferred resolved (e.g., stream closed via SIGINT)
@@ -139,10 +149,51 @@ export async function watchDeploymentAndDisplayLogs({
   }
 
   if (deploymentEnded.state === 'OK') {
-    Logger.println(styleText(['bold', 'green'], 'Deployment successful'));
+    Logger.println('');
+
+    // There can be applications without any domain, so we don't fail if we can't get one
+    const favouriteDomain = await getBest(appId, ownerId).catch(() => null);
+
+    if (favouriteDomain) {
+      Logger.println(
+        `${styleText(['bold', 'green'], '✓ Access your application:')} ${styleText(['underline', 'bold'], `https://${favouriteDomain.fqdn}`)}`,
+      );
+    }
+
+    Logger.println(
+      `${styleText(['bold', 'blue'], '→ Manage your application:')} ${styleText(['underline', 'bold'], `${config.GOTO_URL}/${appId}`)}`,
+    );
   } else if (deploymentEnded.state === 'CANCELLED') {
     throw new Error('Deployment was cancelled. Please check the activity');
   } else {
     throw new Error('Deployment failed. Please check the logs');
   }
 }
+
+function formatLogLine(log) {
+  const { date, message } = log;
+  if (isDeploymentSuccessMessage(log)) {
+    return `${date.toISOString()}: ${styleText(['bold', 'green'], message)}`;
+  } else if (isDeploymentFailedMessage(log)) {
+    return `${date.toISOString()}: ${styleText(['bold', 'red'], message)}`;
+  } else if (isBuildSuccessMessage(log)) {
+    return `${date.toISOString()}: ${styleText(['bold', 'blue'], message)}`;
+  }
+  return `${date.toISOString()}: ${message}${RESET_COLOR}`;
+}
+
+function isCleverMessage(log) {
+  return log.service !== 'bas-deploy.service';
+}
+
+function isDeploymentSuccessMessage(log) {
+  return isCleverMessage(log) && log.message.toLowerCase().startsWith('successfully deployed in');
+}
+
+function isDeploymentFailedMessage(log) {
+  return isCleverMessage(log) && log.message.toLowerCase().startsWith('deploy failed in');
+}
+
+function isBuildSuccessMessage(log) {
+  return isCleverMessage(log) && log.message.toLowerCase().startsWith('build succeeded in');
+}

package/src/models/send-to-api.js

@@ -1,49 +1,70 @@
 import { addOauthHeader } from '@clevercloud/client/esm/oauth.js';
 import { prefixUrl } from '@clevercloud/client/esm/prefix-url.js';
 import { request } from '@clevercloud/client/esm/request.fetch.js';
-import { subtle as cryptoSuble } from 'node:crypto';
-import { addOauthHeaderPlaintext } from '../clever-client/auth-bridge.js';
+import { subtle as cryptoSubtle } from 'node:crypto';
+import { config } from '../config/config.js';
 import { styleText } from '../lib/style-text.js';
 import { Logger } from '../logger.js';
-import { conf, loadOAuthConf } from './configuration.js';
 
 // Required for @clevercloud/client with "old" Node.js
 if (globalThis.crypto == null) {
   globalThis.crypto = {
-    subtle: cryptoSuble,
-  };
-}
-
-async function loadTokens() {
-  const tokens = await loadOAuthConf();
-  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,
+    subtle: cryptoSubtle,
   };
 }
 
 export async function sendToApi(requestParams) {
-  const tokens = await loadTokens();
-  return Promise.resolve(requestParams)
-    .then(prefixUrl(conf.API_HOST))
-    .then(addOauthHeader(tokens))
-    .then((requestParams) => {
-      Logger.debug(
-        `${requestParams.method.toUpperCase()} ${requestParams.url} ? ${JSON.stringify(requestParams.queryParams)}`,
-      );
-      return requestParams;
-    })
-    .then(request)
-    .catch(processError);
+  return executeRequest(requestParams);
 }
 
 export async function sendToAuthBridge(requestParams) {
-  const tokens = await loadTokens();
+  return executeRequest(requestParams, { API_HOST: config.AUTH_BRIDGE_HOST });
+}
+
+/**
+ * Creates an API request function with a custom config.
+ * @param {object} customConfig
+ * @param {string} customConfig.token - OAuth token
+ * @param {string} customConfig.secret - OAuth secret
+ * @param {string} customConfig.apiHost - API host
+ * @param {string} customConfig.consumerKey - OAuth consumer key
+ * @param {string} customConfig.consumerSecret - OAuth consumer secret
+ * @returns {(requestParams: object) => Promise<unknown>}
+ */
+export function sendToApiWithConfig(customConfig) {
+  return (requestParams) =>
+    executeRequest(requestParams, {
+      API_HOST: customConfig.apiHost,
+      OAUTH_CONSUMER_KEY: customConfig.consumerKey,
+      OAUTH_CONSUMER_SECRET: customConfig.consumerSecret,
+      API_OAUTH_TOKEN: customConfig.token,
+      API_OAUTH_TOKEN_SECRET: customConfig.secret,
+    });
+}
+
+/**
+ * Executes the request pipeline with the given configuration.
+ * @param {object} requestParams - The request parameters
+ * @param {object} [customConfig] - Optional configuration overrides
+ * @param {string} [customConfig.API_HOST] - API host URL
+ * @param {string} [customConfig.OAUTH_CONSUMER_KEY] - OAuth consumer key
+ * @param {string} [customConfig.OAUTH_CONSUMER_SECRET] - OAuth consumer secret
+ * @param {string} [customConfig.API_OAUTH_TOKEN] - OAuth token
+ * @param {string} [customConfig.API_OAUTH_TOKEN_SECRET] - OAuth token secret
+ * @returns {Promise<unknown>}
+ */
+async function executeRequest(requestParams, customConfig = {}) {
+  const host = customConfig.API_HOST ?? config.API_HOST;
+  const tokens = {
+    OAUTH_CONSUMER_KEY: customConfig.OAUTH_CONSUMER_KEY ?? config.OAUTH_CONSUMER_KEY,
+    OAUTH_CONSUMER_SECRET: customConfig.OAUTH_CONSUMER_SECRET ?? config.OAUTH_CONSUMER_SECRET,
+    API_OAUTH_TOKEN: customConfig.API_OAUTH_TOKEN ?? config.token,
+    API_OAUTH_TOKEN_SECRET: customConfig.API_OAUTH_TOKEN_SECRET ?? config.secret,
+  };
+
   return Promise.resolve(requestParams)
-    .then(prefixUrl(conf.AUTH_BRIDGE_HOST))
-    .then(addOauthHeaderPlaintext(tokens))
+    .then(prefixUrl(host))
+    .then(addOauthHeader(tokens))
     .then((requestParams) => {
       Logger.debug(
         `${requestParams.method.toUpperCase()} ${requestParams.url} ? ${JSON.stringify(requestParams.queryParams)}`,
@@ -71,10 +92,14 @@ export function processError(error) {
   throw error;
 }
 
-export async function getHostAndTokens() {
-  const tokens = await loadTokens();
+export function getHostAndTokens() {
   return {
-    apiHost: conf.API_HOST,
-    tokens,
+    apiHost: config.API_HOST,
+    tokens: {
+      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,
+    },
   };
 }

package/src/models/user.js

@@ -10,14 +10,3 @@ export function getCurrentId() {
     .then(sendToApi)
     .then(({ id }) => id);
 }
-
-// TODO move to clever client
-export function getCurrentToken() {
-  return Promise.resolve({
-    method: 'get',
-    url: '/v2/self/tokens/current',
-    headers: { Accept: 'application/json' },
-    // no query params
-    // no body
-  }).then(sendToApi);
-}

package/src/models/utils.js

@@ -1,6 +1,6 @@
 import openPage from 'open';
+import { config } from '../config/config.js';
 import { Logger } from '../logger.js';
-import { conf } from './configuration.js';
 
 // Inspirations:
 // https://github.com/sindresorhus/p-defer/blob/master/index.js
@@ -23,7 +23,7 @@ export class Deferred {
  * @returns {Promise<void>} A promise that resolves when the URL is opened
  */
 export function openBrowser(urlOrPath, message) {
-  const url = urlOrPath.startsWith('/') ? `${conf.CONSOLE_URL}${urlOrPath}` : urlOrPath;
+  const url = urlOrPath.startsWith('/') ? `${config.CONSOLE_URL}${urlOrPath}` : urlOrPath;
 
   Logger.debug(`Opening URL "${url}" in browser`);
   Logger.println(message);

package/src/experimental-features.js

@@ -1,91 +0,0 @@
-import dedent from 'dedent';
-import { conf } from './models/configuration.js';
-
-export const EXPERIMENTAL_FEATURES = {
-  k8s: {
-    status: 'beta',
-    description: 'Deploy and manage Kubernetes clusters on Clever Cloud',
-    instructions: dedent`
-      - Create a Kubernetes cluster:
-          clever k8s create my-cluster
-          clever k8s create my-cluster --org myOrg
-
-      - List Kubernetes clusters:
-          clever k8s list
-
-      - Get details about a Kubernetes cluster:
-          clever k8s get my-cluster
-
-      - Get kubeconfig file for a Kubernetes cluster:
-          clever k8s get-kubeconfig my-cluster
-          clever k8s get-kubeconfig my-cluster > ~/.kube/config
-
-      - Activate persistent storage on a Kubernetes cluster:
-          clever k8s add-persistent-storage my-cluster
-
-      - Delete a Kubernetes cluster:
-          clever k8s delete my-cluster
-
-      Learn more about Clever Kubernetes: ${conf.DOC_URL}/kubernetes/
-    `,
-  },
-  kv: {
-    status: 'beta',
-    description:
-      'Send commands to databases such as Materia KV or Redis® directly from Clever Tools, without other dependencies',
-    instructions: dedent`
-      Target any compatible add-on by its name or ID (with an org ID if needed) and send commands to it:
-
-          clever kv myMateriaKV SET myKey myValue
-          clever kv kv_xxxxxxxx GET myKey -F json
-          clever kv addon_xxxxx SET myTempKey myTempValue EX 120
-          clever kv myMateriaKV -o myOrg TTL myTempKey
-          clever kv redis_xxxxx --org org_xxxxx PING
-
-      Learn more about Materia KV: ${conf.DOC_URL}/addons/materia-kv/
-    `,
-  },
-  ng: {
-    status: 'beta',
-    description: 'Manage Network Groups to manage applications, add-ons, external peers through a WireGuard network',
-    instructions: dedent`
-      - Create a Network Group:
-          clever ng create myNG
-      - Create a Network Group with members (application, database add-on):
-          clever ng create myNG --link app_xxx,postgresql_xxx
-      - List Network Groups:
-          clever ng
-      - Delete a Network Group:
-          clever ng delete myNG
-      - (Un)Link an application or a database add-on to an existing Network Group:
-          clever ng link app_xxx myNG
-          clever ng unlink postgresql_xxx myNG
-      - Get the WireGuard configuration of a peer:
-          clever ng get-config peerIdOrLabel myNG
-      - Get details about a Network Group, a member or a peer:
-          clever ng get myNg
-          clever ng get app_xxx
-          clever ng get peerId
-          clever ng get memberLabel
-      - Search Network Groups, members or peers:
-          clever ng search myQuery
-
-      Learn more about Network Groups: ${conf.DOC_URL}/develop/network-groups/
-    `,
-  },
-  operators: {
-    status: 'beta',
-    description: 'Manage operators and their features such as Keycloak, Matomo, Metabase, Otoroshi',
-    instructions: dedent`
-      clever keycloak
-      clever keycloak get keycloak_xxx
-      clever keycloak ng enable myKeycloak
-
-      clever metabase version check myMetabase
-      clever metabase version update myMetabase 0.53
-
-      clever matomo open myMatomo
-      clever otoroshi open logs myOtoroshi
-    `,
-  },
-};

package/src/lib/format-date.js

@@ -1,3 +0,0 @@
-export function formatDate(dateInput) {
-  return new Date(dateInput).toISOString().substring(0, 16).replace('T', ' ');
-}

package/src/models/configuration.js

@@ -1,140 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import xdg from 'xdg';
-import { Logger } from '../logger.js';
-
-const CONFIG_FILES = {
-  MAIN: 'clever-tools.json',
-  IDS_CACHE: 'ids-cache.json',
-  EXPERIMENTAL_FEATURES_FILE: 'clever-tools-experimental-features.json',
-};
-
-function getConfigDir() {
-  return process.platform === 'win32'
-    ? path.resolve(process.env.APPDATA, 'clever-cloud')
-    : xdg.basedir.configPath('clever-cloud');
-}
-
-function getConfigPath(configFile) {
-  return path.resolve(getConfigDir(), configFile);
-}
-
-// Every function which need 'clever-cloud' directory, need to call it before
-async function ensureConfigDirExists() {
-  await fs.mkdir(getConfigDir(), { mode: 0o700, recursive: true });
-}
-
-export async function loadOAuthConf() {
-  Logger.debug('Load configuration from environment variables');
-  if (process.env.CLEVER_TOKEN != null && process.env.CLEVER_SECRET != null) {
-    return {
-      source: 'environment variables',
-      token: process.env.CLEVER_TOKEN,
-      secret: process.env.CLEVER_SECRET,
-    };
-  }
-  Logger.debug('Load configuration from ' + conf.CONFIGURATION_FILE);
-  try {
-    const rawFile = await fs.readFile(conf.CONFIGURATION_FILE);
-    const { token, secret } = JSON.parse(rawFile);
-    return {
-      source: 'configuration file',
-      token,
-      secret,
-    };
-  } catch (error) {
-    Logger.info(`Cannot load configuration from ${conf.CONFIGURATION_FILE}\n${error.message}`);
-    return {
-      source: 'none',
-    };
-  }
-}
-
-export async function writeOAuthConf(oauthData) {
-  Logger.debug('Write the tokens in the configuration file…');
-  try {
-    await ensureConfigDirExists();
-    await fs.writeFile(conf.CONFIGURATION_FILE, JSON.stringify(oauthData));
-  } catch (error) {
-    throw new Error(`Cannot write configuration to ${conf.CONFIGURATION_FILE}\n${error.message}`);
-  }
-}
-
-export async function loadIdsCache() {
-  const cachePath = getConfigPath(CONFIG_FILES.IDS_CACHE);
-  try {
-    const rawFile = await fs.readFile(cachePath);
-    return JSON.parse(rawFile);
-  } catch (error) {
-    Logger.info(`Cannot load IDs cache from ${cachePath}\n${error.message}`);
-    return {
-      owners: {},
-      addons: {},
-    };
-  }
-}
-
-export async function writeIdsCache(ids) {
-  const cachePath = getConfigPath(CONFIG_FILES.IDS_CACHE);
-  const idsJson = JSON.stringify(ids);
-  try {
-    await ensureConfigDirExists();
-    await fs.writeFile(cachePath, idsJson);
-  } catch (error) {
-    throw new Error(`Cannot write IDs cache to ${cachePath}\n${error.message}`);
-  }
-}
-
-export async function getFeatures() {
-  Logger.debug('Get features configuration from ' + conf.EXPERIMENTAL_FEATURES_FILE);
-  try {
-    const rawFile = await fs.readFile(conf.EXPERIMENTAL_FEATURES_FILE);
-    return JSON.parse(rawFile);
-  } catch (error) {
-    if (error.code !== 'ENOENT') {
-      throw new Error(`Cannot get experimental features configuration from ${conf.EXPERIMENTAL_FEATURES_FILE}`);
-    }
-    return {};
-  }
-}
-
-export async function setFeature(feature, value) {
-  const currentFeatures = await getFeatures();
-  const newFeatures = { ...currentFeatures, ...{ [feature]: value } };
-
-  try {
-    await ensureConfigDirExists();
-    await fs.writeFile(conf.EXPERIMENTAL_FEATURES_FILE, JSON.stringify(newFeatures, null, 2));
-  } catch {
-    throw new Error(`Cannot write experimental features configuration to ${conf.EXPERIMENTAL_FEATURES_FILE}`);
-  }
-}
-
-const defaultConf = {
-  API_HOST: 'https://api.clever-cloud.com',
-  AUTH_BRIDGE_HOST: 'https://api-bridge.clever-cloud.com',
-  SSH_GATEWAY: 'ssh@sshgateway-clevercloud-customers.services.clever-cloud.com',
-
-  // the disclosure of these tokens is not considered as a vulnerability. Do not report this to our security service.
-  OAUTH_CONSUMER_KEY: 'T5nFjKeHH4AIlEveuGhB5S3xg8T19e',
-  OAUTH_CONSUMER_SECRET: 'MgVMqTr6fWlf2M0tkC2MXOnhfqBWDT',
-
-  APP_CONFIGURATION_FILE: path.resolve('.', '.clever.json'),
-  CONFIGURATION_FILE: getConfigPath(CONFIG_FILES.MAIN),
-  EXPERIMENTAL_FEATURES_FILE: getConfigPath(CONFIG_FILES.EXPERIMENTAL_FEATURES_FILE),
-
-  API_DOC_URL: 'https://www.clever.cloud/developers/api',
-  DOC_URL: 'https://www.clever.cloud/developers/doc',
-  CONSOLE_URL: 'https://console.clever-cloud.com',
-  CONSOLE_TOKEN_URL: 'https://console.clever-cloud.com/cli-oauth',
-  GOTO_URL: 'https://console.clever-cloud.com/goto',
-};
-
-export const conf = Object.fromEntries(
-  Object.entries(defaultConf).map(([name, value]) => {
-    if (process.env[name] != null) {
-      return [name, process.env[name]];
-    }
-    return [name, value];
-  }),
-);