clever-tools 3.12.0 → 3.13.0

package/src/models/application_configuration.js

@@ -1,7 +1,6 @@
 import cliparse from 'cliparse';
-import colors from 'colors/safe.js';
-
 import { Logger } from '../logger.js';
+import dedent from 'dedent';
 
 const CONFIG_KEYS = [
   { id: 'name', name: 'name', displayName: 'Name', kind: 'string' },
@@ -10,31 +9,43 @@ const CONFIG_KEYS = [
   { id: 'sticky-sessions', name: 'stickySessions', displayName: 'Sticky sessions', kind: 'bool' },
   { id: 'cancel-on-push', name: 'cancelOnPush', displayName: 'Cancel current deployment on push', kind: 'bool' },
   { id: 'force-https', name: 'forceHttps', displayName: 'Force redirection of HTTP to HTTPS', kind: 'force-https' },
+  { id: 'task', name: 'instanceLifetime', displayName: 'Deploy an application as a Clever Task', kind: 'task' },
 ];
 
-export function listAvailableIds () {
-  return CONFIG_KEYS.map((config) => config.id);
+export function listAvailableIds (asText = false) {
+  const ids = CONFIG_KEYS.map((config) => config.id);
+  if (asText) {
+    return new Intl
+      .ListFormat('en', { style: 'short', type: 'disjunction' })
+      .format(ids);
+  }
+  return ids;
 }
 
 export function getById (id) {
   const config = CONFIG_KEYS.find((config) => config.id === id);
-  if (config == null) {
-    Logger.error(`Invalid configuration name: ${id}.`);
-    Logger.error(`Available configuration names are: ${listAvailableIds().join(', ')}.`);
+  if (config != null) {
+    return config;
   }
-  return config;
+  throw new Error(dedent`
+    Invalid configuration name: ${id}.
+    Available configuration names: ${listAvailableIds(true)}.
+  `);
 }
 
-function display (config, value) {
+export function formatValue (config, value) {
   switch (config.kind) {
     case 'bool': {
-      return (value) ? 'enabled' : 'disabled';
+      return value;
     }
     case 'inverted-bool': {
-      return (value) ? 'disabled' : 'enabled';
+      return !value;
     }
     case 'force-https': {
-      return value.toLowerCase();
+      return value === 'ENABLED';
+    }
+    case 'task': {
+      return value === 'TASK';
     }
     default: {
       return String(value);
@@ -44,14 +55,26 @@ function display (config, value) {
 
 export function parse (config, value) {
   switch (config.kind) {
-    case 'bool': {
-      return (value !== 'false');
-    }
-    case 'inverted-bool': {
-      return (value === 'false');
-    }
-    case 'force-https': {
-      return (value === 'false') ? 'DISABLED' : 'ENABLED';
+    case 'bool':
+    case 'inverted-bool':
+    case 'force-https':
+    case 'task': {
+      if (value !== 'true' && value !== 'false') {
+        throw new Error('Invalid configuration value, it must be a boolean (true or false)');
+      }
+      if (config.kind === 'bool') {
+        return (value === 'true');
+      }
+      if (config.kind === 'inverted-bool') {
+        return (value === 'false');
+      }
+      if (config.kind === 'force-https') {
+        return (value === 'true') ? 'ENABLED' : 'DISABLED';
+      }
+      if (config.kind === 'task') {
+        return (value === 'false') ? 'REGULAR' : 'TASK';
+      }
+      return;
     }
     default: {
       return value;
@@ -69,7 +92,8 @@ function getConfigOptions (config) {
   switch (config.kind) {
     case 'bool':
     case 'inverted-bool':
-    case 'force-https': {
+    case 'force-https':
+    case 'task': {
       return [
         cliparse.flag(`enable-${config.id}`, { description: `Enable ${config.id}` }),
         cliparse.flag(`disable-${config.id}`, { description: `Disable ${config.id}` }),
@@ -92,69 +116,45 @@ export function parseOptions (options) {
 
 function parseConfigOption (config, options) {
   switch (config.kind) {
-    case 'bool': {
-      const enable = options[`enable-${config.id}`];
-      const disable = options[`disable-${config.id}`];
-      if (enable && disable) {
-        Logger.warn(`${config.id} is both enabled and disabled, ignoring`);
-      }
-      else if (enable || disable) {
-        return [config.name, enable];
-      }
-      return null;
-    }
-    case 'inverted-bool': {
-      const disable = options[`enable-${config.id}`];
-      const enable = options[`disable-${config.id}`];
-      if (enable && disable) {
-        Logger.warn(`${config.id} is both enabled and disabled, ignoring`);
-      }
-      else if (enable || disable) {
-        return [config.name, enable];
-      }
-      return null;
-    }
-    case 'force-https': {
+    case 'bool':
+    case 'inverted-bool':
+    case 'force-https':
+    case 'task': {
       const enable = options[`enable-${config.id}`];
       const disable = options[`disable-${config.id}`];
       if (enable && disable) {
-        Logger.warn(`${config.id} is both enabled and disabled, ignoring`);
+        throw new Error(`You cannot use both --enable-${config.id} and --disable-${config.id} at the same time`);
       }
-      else if (enable || disable) {
-        const value = (enable) ? 'ENABLED' : 'DISABLED';
-        return [config.name, value];
+      if (enable || disable) {
+        if (config.kind === 'bool') {
+          return [config.name, enable];
+        }
+        if (config.kind === 'inverted-bool') {
+          return [config.name, disable];
+        }
+        if (config.kind === 'force-https' || config.kind === 'task') {
+          return [config.name, parse(config, String(enable))];
+        }
       }
-      return null;
+      return;
     }
     default: {
-      if (options[config.id] !== null) {
-        return [config.name, options[config.id]];
-      }
-      return null;
+      return [config.name, options[config.id]];
     }
   }
 }
 
-function printConfig (app, config) {
-  if (app[config.name] != null) {
-    Logger.println(`${config.displayName}: ${colors.bold(display(config, app[config.name]))}`);
-  }
-}
-
-export function printById (app, id) {
+export function printValue (app, id) {
   const config = getById(id);
-  if (config != null) {
-    printConfig(app, config);
-  }
+  Logger.println(formatValue(config, app[config.name]));
 }
 
-export function printByName (app, name) {
-  const config = CONFIG_KEYS.find((config) => config.name === name);
-  printConfig(app, config);
-}
-
-export function print (app) {
-  for (const config of CONFIG_KEYS) {
-    printConfig(app, config);
-  }
+export function printAllValues (app) {
+  console.table(
+    Object.fromEntries(
+      CONFIG_KEYS.map((config) => {
+        return [config.id, formatValue(config, app[config.name])];
+      }),
+    ),
+  );
 }

package/src/models/git.js

@@ -5,7 +5,7 @@ import _ from 'lodash';
 import git from 'isomorphic-git';
 import * as http from './isomorphic-http-with-agent.js';
 import cliparse from 'cliparse';
-import slugify from 'slugify';
+import { slugify } from '../lib/slugify.js';
 import { findPath } from './fs-utils.js';
 import { loadOAuthConf } from './configuration.js';
 
@@ -130,3 +130,31 @@ export async function isShallow () {
     return false;
   }
 }
+
+/**
+ * Check if the current directory is a git repository
+ * @returns {Promise<boolean>}
+ */
+export async function isInsideGitRepo () {
+  return getRepo()
+    .then(() => true)
+    .catch(() => false);
+}
+
+/**
+ * Check if the current git working directory is clean
+ * @returns {Promise<boolean>}
+ */
+export async function isGitWorkingDirectoryClean () {
+  const repo = await getRepo();
+  const status = await git.statusMatrix({ ...repo });
+  const isStatusEmpty = status
+    .filter(([filepath, head, workdir]) => {
+      // WARNING: isomorphic-git does not support global gitignore so we filter hidden files and dirs to reduce the amount of false positives
+      const isHidden = filepath.startsWith('.');
+      const isCleverJson = filepath === '.clever.json';
+      return (!isHidden || isCleverJson) && head !== workdir;
+    })
+    .length === 0;
+  return isStatusEmpty;
+}

package/src/models/ids-resolver.js

@@ -110,7 +110,7 @@ async function getIdsFromSummary () {
  * @param {{ orga_name?: string, orga_id?: string }} ownerNameOrId
  * @throws {Error} if no add-on is found
  * @throws {Error} if several add-ons are found
- * @returns {Object} The ID and owner ID of the add-on { addonId, ownerId }
+ * @returns {Object} The name, IDs and owner ID of the add-on { name, addonId, realId, ownerId }
  */
 export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId) {
   const summary = await getSummary().then(sendToApi);
@@ -128,7 +128,9 @@ export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId
       return matchOwner && matchAddon;
     })
     .map(({ addon, owner }) => ({
+      name: addon.name,
       addonId: addon.id,
+      realId: addon.realId,
       ownerId: owner.id,
     }));
 
@@ -139,3 +141,37 @@ export async function findAddonsByNameOrId (addonIdOrRealIdOrName, ownerNameOrId
 
   return candidates;
 }
+
+/**
+ * Get the IDs and owners of found add-ons from a name, ID or real ID
+ * @param {string} addonIdOrRealIdOrName
+ * @throws {Error} if no add-on is found
+ * @throws {Error} if several add-ons are found
+ * @returns {Object} The name, IDs and owner ID of the add-on { name, addonId, realId, ownerId }
+ */
+export async function findAddonsByAddonProvider (provider) {
+  const summary = await getSummary().then(sendToApi);
+
+  Logger.debug(`Searching for ${provider} add-ons in ${summary.user.id} and ${summary.organisations.map((org) => org.id).join(', ')}`);
+  const candidates = [summary.user, ...summary.organisations]
+    .flatMap((owner) => {
+      return owner.addons
+        .filter((addon) => addon.providerId === provider)
+        .map((addon) => {
+          return {
+            name: addon.name,
+            addonId: addon.id,
+            realId: addon.realId,
+            ownerId: owner.id,
+            ownerName: owner.name,
+          };
+        });
+    });
+
+  Logger.debug(`Found ${candidates.length} candidate(s) for provider ${provider}:`);
+  for (const candidate of candidates) {
+    Logger.debug(`  - ${candidate.addonId} (${candidate.ownerId})`);
+  }
+
+  return candidates;
+}

package/src/models/interact.js

@@ -1,24 +0,0 @@
-import readline from 'node:readline';
-
-function ask (question) {
-
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-
-export async function confirm (question, rejectionMessage, expectedAnswers = ['yes', 'y']) {
-  const answer = await ask(question);
-  if (!expectedAnswers.includes(answer)) {
-    throw new Error(rejectionMessage);
-  }
-  return true;
-}

package/src/models/log-v4.js

@@ -6,6 +6,8 @@ import { waitForDeploymentEnd, waitForDeploymentStart } from './deployments.js';
 import { ApplicationLogStream } from '@clevercloud/client/esm/streams/application-logs.js';
 import { JsonArray } from './json-array.js';
 import * as ExitStrategy from '../models/exit-strategy-option.js';
+import { getBest } from './domain.js';
+import { conf } from './configuration.js';
 
 // 2000 logs per 100ms maximum
 const THROTTLE_ELEMENTS = 2000;
@@ -98,9 +100,11 @@ export async function watchDeploymentAndDisplayLogs (options) {
 
   ExitStrategy.plotQuietWarning(exitStrategy, quiet);
   // If in quiet mode, we only log start/finished deployment messages
-  !quiet && Logger.println('Waiting for deployment to start…');
+  if (!quiet) {
+    Logger.println(`   ${colors.blue('→ Waiting for deployment to start…')}`);
+  }
   const deployment = await waitForDeploymentStart({ ownerId, appId, deploymentId, commitId, knownDeployments });
-  Logger.println(colors.bold.blue(`Deployment started (${deployment.uuid})`));
+  Logger.println(`   ${colors.green(`✓ Deployment started ${colors.grey(`(${deployment.uuid})`)}`)}`);
 
   if (exitStrategy === 'deploy-start') {
     return;
@@ -119,7 +123,9 @@ export async function watchDeploymentAndDisplayLogs (options) {
     logsStream = await displayLogs({ ownerId, appId, deploymentId: deployment.uuid, since: redeployDate, deferred });
   }
 
-  !quiet && Logger.println('Waiting for application logs…');
+  if (!quiet) {
+    Logger.println(`   ${colors.blue('→ Waiting for application logs…')}`);
+  }
 
   // Wait for deployment end (or an error thrown by logs with the deferred)
   const deploymentEnded = await Promise.race([
@@ -132,7 +138,10 @@ export async function watchDeploymentAndDisplayLogs (options) {
   }
 
   if (deploymentEnded.state === 'OK') {
-    Logger.println(colors.bold.green('Deployment successful'));
+    const favouriteDomain = await getBest(appId, ownerId);
+    Logger.println('');
+    Logger.println(`${colors.bold.green('✓ Access your application:')} ${colors.underline.bold(`https://${favouriteDomain.fqdn}`)}`);
+    Logger.println(`${colors.bold.blue('→ Manage your application:')} ${colors.underline.bold(`${conf.GOTO_URL}/${appId}`)}`);
   }
   else if (deploymentEnded.state === 'CANCELLED') {
     throw new Error('Deployment was cancelled. Please check the activity');

package/src/models/operator.js

@@ -0,0 +1,48 @@
+import colors from 'colors/safe.js';
+import dedent from 'dedent';
+
+import { sendToApi } from './send-to-api.js';
+import { findAddonsByNameOrId } from './ids-resolver.js';
+import { getOperator } from '../clever-client/operators.js';
+
+/**
+ * Get the details of an operator from its name or ID
+ * @param {string} provider The operator's provider
+ * @param {object|string} operatorIdOrName The operator's ID or name
+ * @returns {Promise<object>} The operator's details
+ * @throws {Error} If the operator provider is unknown
+ */
+export async function getDetails (provider, operatorIdOrName) {
+  const realId = await getSingleRealId(operatorIdOrName);
+  return getOperator({ provider, realId }).then(sendToApi);
+}
+
+/**
+ * Get the real ID of an operator from its name or ID
+ * @param {object|string} operatorIdOrName The operator's ID or name
+ * @returns {Promise<string>} The operator's real ID
+ * @throws {Error} If the operator is not found
+ * @throws {Error} If the operator name is ambiguous
+ */
+export async function getSingleRealId (operatorIdOrName) {
+
+  if (operatorIdOrName.operator_id != null) {
+    return operatorIdOrName.operator_id;
+  }
+
+  const name = operatorIdOrName.addon_name ?? operatorIdOrName.addon_id;
+  const operators = await findAddonsByNameOrId(name);
+
+  if (operators.length === 0) {
+    throw new Error(`Could not find ${colors.red(name)}`);
+  }
+
+  if (operators.length > 1) {
+    throw new Error(dedent`
+      Ambiguous name ${colors.red(name)}, use the real ID instead:
+        ${colors.grey(operators.map((otoroshi) => `- ${otoroshi.name} (${otoroshi.realId})`).join('\n'))}
+    `);
+  }
+
+  return operators[0].realId;
+}

package/src/models/utils.js

@@ -1,3 +1,7 @@
+import { Logger } from '../logger.js';
+import { conf } from './configuration.js';
+import openPage from 'open';
+
 // Inspirations:
 // https://github.com/sindresorhus/p-defer/blob/master/index.js
 // https://github.com/ljharb/promise-deferred/blob/master/index.js
@@ -13,6 +17,23 @@ export class Deferred {
   }
 }
 
+/**
+ * Open an absolute URL or a console path in the default browser
+ * @param {string} urlOrPath The URL to open
+ * @param {string} message The message to display before opening the URL
+ * @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;
+
+  Logger.debug(`Opening URL "${url}" in browser`);
+  Logger.println(message);
+
+  return openPage(url, { wait: false });
+}
+
 export function truncateWithEllipsis (length, string) {
   if (string.length > length - 1) {
     return string.substring(0, length - 1) + '…';

package/src/parsers.js

@@ -69,6 +69,16 @@ export function futureDateOrDuration (dateString) {
   return duration;
 }
 
+// This simple regex is enough for our use cases
+const emailRegex = /^\S+@\S+\.\S+$/g;
+
+export function email (string) {
+  if (string.match(emailRegex)) {
+    return cliparse.parsers.success(string);
+  }
+  return cliparse.parsers.error('Invalid email');
+}
+
 const appIdRegex = /^app_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 export function appIdOrName (string) {
@@ -88,11 +98,15 @@ export function orgaIdOrName (string) {
 }
 
 const addonIdRegex = /^addon_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const operatorIdRegex = /^(keycloak|otoroshi|matomo|metabase)_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 export function addonIdOrName (string) {
   if (string.match(addonIdRegex)) {
     return cliparse.parsers.success({ addon_id: string });
   }
+  if (string.match(operatorIdRegex)) {
+    return cliparse.parsers.success({ operator_id: string });
+  }
   return cliparse.parsers.success({ addon_name: string });
 }
 

package/src/prompt-password.js

@@ -1,10 +0,0 @@
-import { password } from '@inquirer/prompts';
-
-export function promptPassword (message) {
-  return password({ message, mask: true }).catch((error) => {
-    if (error instanceof Error && error.name === 'ExitPromptError') {
-      process.exit(1);
-    }
-    throw error;
-  });
-}