clever-tools 3.6.1 → 3.8.0

package/src/commands/status.js

@@ -3,22 +3,49 @@
 const _ = require('lodash');
 const colors = require('colors/safe');
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 
 const { get: getApplication, getAllInstances } = require('@clevercloud/client/cjs/api/v2/application.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
-function displayGroupInfo (instances, commit) {
-  return `(${displayFlavors(instances)},  Commit: ${commit || 'N/A'})`;
+async function status (params) {
+  const { alias, app: appIdOrName, format } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
+
+  const instances = await getAllInstances({ id: ownerId, appId }).then(sendToApi);
+  const app = await getApplication({ id: ownerId, appId }).then(sendToApi);
+
+  const status = computeStatus(instances, app);
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(status);
+      break;
+    }
+    case 'human':
+    default: {
+      const statusMessage = status.status === 'running'
+        ? `${colors.bold.green('running')} ${displayInstances(status.instances, status.commit)}`
+        : colors.bold.red('stopped');
+
+      Logger.println(`${status.name}: ${statusMessage}`);
+      Logger.println(`Executed as: ${colors.bold(status.lifetime)}`);
+      if (status.deploymentInProgress) {
+        Logger.println(`Deployment in progress ${displayInstances(status.deploymentInProgress.instances, status.deploymentInProgress.commit)}`);
+      }
+      Logger.println();
+      Logger.println('Scalability:');
+      Logger.println(`  Auto scalability: ${status.scalability.enabled ? colors.green('enabled') : colors.red('disabled')}`);
+      Logger.println(`  Scalers: ${colors.bold(formatScalability(status.scalability.horizontal))}`);
+      Logger.println(`  Sizes: ${colors.bold(formatScalability(status.scalability.vertical))}`);
+      Logger.println(`  Dedicated build: ${status.separateBuild ? colors.bold(status.buildFlavor) : colors.red('disabled')}`);
+    }
+  }
 }
 
-function displayFlavors (instances) {
-  return _(instances)
-    .groupBy((i) => i.flavor.name)
-    .map((instances, flavorName) => `${instances.length}*${flavorName}`)
-    .value()
-    .join(', ');
+function displayInstances (instances, commit) {
+  return `(${instances.map((instance) => `${instance.count}*${instance.flavor}`)},  Commit: ${commit || 'N/A'})`;
 }
 
 function computeStatus (instances, app) {
@@ -30,50 +57,49 @@ function computeStatus (instances, app) {
   const isDeploying = !_.isEmpty(deployingInstances);
   const deployingCommit = _(deployingInstances).map('commit').head();
 
-  const statusMessage = isUp
-    ? `${colors.bold.green('running')} ${displayGroupInfo(upInstances, upCommit)}`
-    : colors.bold.red('stopped');
-
-  const statusLine = `${app.name}: ${statusMessage}`;
-  const taskLine = `Executed as: ${colors.bold(app.instance.lifetime)}`;
-  const deploymentLine = isDeploying
-    ? `Deployment in progress ${displayGroupInfo(deployingInstances, deployingCommit)}`
-    : '';
-
-  return [statusLine, taskLine, deploymentLine].join('\n');
-}
-
-function displayScalability (app) {
-
   const { minFlavor, maxFlavor, minInstances, maxInstances } = app.instance;
 
-  const vertical = (minFlavor.name === maxFlavor.name)
-    ? minFlavor.name
-    : `${minFlavor.name} to ${maxFlavor.name}`;
-
-  const horizontal = (minInstances === maxInstances)
-    ? minInstances
-    : `${minInstances} to ${maxInstances}`;
-
-  const enabled = (minFlavor.name !== maxFlavor.name)
+  const scalabilityEnabled = (minFlavor.name !== maxFlavor.name)
     || (minInstances !== maxInstances);
 
-  return `Scalability:
-  Auto scalability: ${enabled ? colors.green('enabled') : colors.red('disabled')}
-  Scalers: ${colors.bold(horizontal)}
-  Sizes: ${colors.bold(vertical)}
-  Dedicated build: ${app.separateBuild ? colors.bold(app.buildFlavor.name) : colors.red('disabled')}`;
+  const status = {
+    id: app.id,
+    name: app.name,
+    lifetime: app.instance.lifetime,
+    status: isUp ? 'running' : 'stopped',
+    commit: upCommit,
+    instances: groupInstances(upInstances),
+    scalability: {
+      enabled: scalabilityEnabled,
+      vertical: { min: minFlavor.name, max: maxFlavor.name },
+      horizontal: { min: minInstances, max: maxInstances },
+    },
+    separateBuild: app.separateBuild,
+    buildFlavor: app.buildFlavor.name,
+  };
+
+  if (isDeploying) {
+    status.deploymentInProgress = {
+      commit: deployingCommit,
+      instances: groupInstances(deployingInstances),
+    };
+  }
+
+  return status;
 }
 
-async function status (params) {
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
-
-  const instances = await getAllInstances({ id: ownerId, appId }).then(sendToApi);
-  const app = await getApplication({ id: ownerId, appId }).then(sendToApi);
+function formatScalability ({ min, max }) {
+  return (min === max) ? min : `${min} to ${max}`;
+}
 
-  Logger.println(computeStatus(instances, app));
-  Logger.println(displayScalability(app));
+function groupInstances (instances) {
+  return _(instances)
+    .groupBy((i) => i.flavor.name)
+    .map((instances, flavorName) => ({
+      flavor: flavorName,
+      count: instances.length,
+    }))
+    .value();
 }
 
 module.exports = { status };

package/src/commands/stop.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
 const Logger = require('../logger.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
 async function stop (params) {
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await application.undeploy({ id: ownerId, appId }).then(sendToApi);
   Logger.println('App successfully stopped!');

package/src/commands/tcp-redirs.js

@@ -2,32 +2,68 @@
 
 const colors = require('colors/safe');
 
-const AppConfig = require('../models/app_configuration.js');
-const Organisation = require('../models/organisation.js');
+const Namespaces = require('../models/namespaces.js');
 const { sendToApi } = require('../models/send-to-api.js');
 const Interact = require('../models/interact.js');
 const Logger = require('../logger.js');
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
+const Application = require('../models/application.js');
 
 async function listNamespaces (params) {
-  const namespaces = await Organisation.getNamespaces(params);
+  const { alias, app: appIdOrName, format } = params.options;
+  const { ownerId } = await Application.resolveId(appIdOrName, alias);
 
-  Logger.println('Available namespaces: ' + namespaces.map(({ namespace }) => namespace).join(', '));
-};
+  const namespaces = await Namespaces.getNamespaces(ownerId);
+
+  namespaces.sort((a, b) => a.namespace.localeCompare(b.namespace));
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(namespaces);
+      break;
+    }
+    case 'human':
+    default: {
+      Logger.println('Available namespaces:');
+      namespaces.forEach(({ namespace }) => {
+        switch (namespace) {
+          case 'cleverapps':
+            Logger.println(`- ${namespace}: for redirections used with 'cleverapps.io' domain`);
+            break;
+          case 'default':
+            Logger.println(`- ${namespace}: for redirections used with custom domains`);
+            break;
+          default:
+            Logger.println(`- ${namespace}`);
+        }
+      });
+      break;
+    }
+  }
+}
 
 async function list (params) {
-  const { alias } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, format } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const redirs = await application.getTcpRedirs({ id: ownerId, appId }).then(sendToApi);
 
-  if (redirs.length === 0) {
-    Logger.println('No active TCP redirection for this application');
-  }
-  else {
-    Logger.println('Enabled TCP redirections:');
-    for (const { namespace, port } of redirs) {
-      Logger.println(port + ' on ' + namespace);
+  switch (format) {
+    case 'json': {
+      Logger.printJson(redirs);
+      break;
+    }
+    case 'human':
+    default: {
+      if (redirs.length === 0) {
+        Logger.println('No active TCP redirection for this application');
+      }
+      else {
+        Logger.println('Enabled TCP redirections:');
+        for (const { namespace, port } of redirs) {
+          Logger.println(port + ' on ' + namespace);
+        }
+      }
     }
   }
 }
@@ -46,8 +82,8 @@ async function acceptPayment (result, skipConfirmation) {
 }
 
 async function add (params) {
-  const { alias, namespace, yes: skipConfirmation } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, namespace, yes: skipConfirmation } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const { port } = await application.addTcpRedir({ id: ownerId, appId }, { namespace }).then(sendToApi).catch((error) => {
     if (error.status === 402) {
@@ -65,8 +101,8 @@ async function add (params) {
 
 async function remove (params) {
   const [port] = params.args;
-  const { alias, namespace } = params.options;
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, namespace } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   await application.removeTcpRedir({ id: ownerId, appId, sourcePort: port, namespace }).then(sendToApi);
 

package/src/commands/webhooks.js

@@ -8,29 +8,44 @@ const { getOwnerAndApp, getOrgaIdOrUserId } = require('../models/notification.js
 const { getWebhooks, createWebhook, deleteWebhook } = require('@clevercloud/client/cjs/api/v2/notification.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
-function displayWebhook (hook) {
-  Logger.println((hook.name && colors.bold(hook.name)) || hook.id);
-  Logger.println(`  id: ${hook.id}`);
-  Logger.println(`  services: ${(hook.scope && hook.scope.join(', ')) || hook.ownerId}`);
-  Logger.println(`  events: ${(hook.events && hook.events.join(', ')) || colors.bold('ALL')}`);
-  Logger.println('  hooks:');
-  hook.urls.forEach((url) => Logger.println(`    ${url.url} (${url.format})`));
-  Logger.println();
-}
-
 async function list (params) {
-  const { org, 'list-all': listAll } = params.options;
+  const { org, 'list-all': listAll, format } = params.options;
 
   // TODO: fix alias option
   const { ownerId, appId } = await getOwnerAndApp(null, org, !listAll);
   const hooks = await getWebhooks({ ownerId }).then(sendToApi);
 
-  hooks
+  const formattedHooks = hooks
     .filter((hook) => {
       const emptyScope = !hook.scope || hook.scope.length === 0;
       return !appId || emptyScope || hook.scope.includes(appId);
     })
-    .forEach((hook) => displayWebhook(hook));
+    .map((hook) => ({
+      id: hook.id,
+      name: hook.name,
+      ownerId: hook.ownerId,
+      services: hook.scope ?? [hook.ownerId],
+      events: hook.events ?? ['ALL'],
+      urls: hook.urls,
+    }));
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(formattedHooks);
+      break;
+    }
+    case 'human':
+    default: {
+      formattedHooks.forEach((hook) => {
+        Logger.println(hook.name ? colors.bold(hook.name) : hook.id);
+        Logger.println(`  id: ${hook.id}`);
+        Logger.println(`  services: ${hook.services.join(', ')}`);
+        Logger.println(`  events: ${hook.events.join(', ')}`);
+        Logger.println('  hooks:');
+        hook.urls.forEach((url) => Logger.println(`    ${url.url} (${url.format})`));
+      });
+    }
+  }
 }
 
 async function add (params) {

package/src/logger.js

@@ -28,20 +28,24 @@ function formatLines (prefixLength, lines) {
     .join('\n');
 }
 
+function consoleErrorWithoutColor (line) {
+  process.stderr.write(line + '\n');
+}
+
 const Logger = _(['debug', 'info', 'warn', 'error'])
   .map((severity) => {
     if (process.env.CLEVER_QUIET || (!process.env.CLEVER_VERBOSE && (severity === 'debug' || severity === 'info'))) {
       return [severity, _.noop];
     }
-    const consoleFn = (severity === 'error') ? console.error : console.log;
+    const consoleFn = (severity === 'error') ? consoleErrorWithoutColor : console.log;
     const { prefix, prefixLength } = getPrefix(severity);
     return [severity, (err) => {
       const message = _.get(err, 'message', err);
       const formattedMsg = formatLines(prefixLength, processApiError(message));
       if (process.env.CLEVER_VERBOSE && severity === 'error') {
-        console.error('[STACKTRACE]');
-        console.error(err);
-        console.error('[/STACKTRACE]');
+        consoleErrorWithoutColor('[STACKTRACE]');
+        consoleErrorWithoutColor(err);
+        consoleErrorWithoutColor('[/STACKTRACE]');
       }
       return consoleFn(`${prefix}${formattedMsg}`);
     }];
@@ -57,8 +61,7 @@ Logger.printJson = (obj) => {
   console.log(JSON.stringify(obj, null, 2));
 };
 
-// No decoration for Logger.printErrorLine
-Logger.printErrorLine = console.error;
+Logger.printErrorLine = consoleErrorWithoutColor;
 
 // Only exported for testing, shouldn't be used directly
 Logger.processApiError = processApiError;

package/src/models/addon.js

@@ -26,7 +26,7 @@ async function getProvider (providerName) {
   const providers = await listProviders();
   const provider = providers.find((p) => p.id === providerName);
   if (provider == null) {
-    throw new Error('invalid provider name');
+    throw new Error(`Invalid provider name. Available providers: ${providers.map((p) => p.id).join(', ')}`);
   }
   return provider;
 }
@@ -136,22 +136,17 @@ function validateAddonVersionAndOptions (region, version, addonOptions, provider
 async function create ({ ownerId, name, providerName, planName, region, skipConfirmation, version, addonOptions }) {
 
   // TODO: We should be able to use it without {}
-  const providers = await listProviders();
+  const provider = await getProvider(providerName);
 
-  const provider = providers.find((p) => p.id === providerName);
-  if (provider == null) {
-    throw new Error('invalid provider name');
-  }
   if (!provider.regions.includes(region)) {
-    throw new Error(`invalid region name. Available regions: ${provider.regions.join(', ')}`);
+    throw new Error(`Invalid region name. Available regions: ${provider.regions.join(', ')}`);
   }
-
-  const plan = provider.plans.find((p) => p.slug.toLowerCase() === planName.toLowerCase());
-  if (plan == null) {
-    const availablePlans = provider.plans.map((p) => p.slug);
-    throw new Error(`invalid plan name. Available plans: ${availablePlans.join(', ')}`);
+  if (provider.plans.length === 0) {
+    throw new Error(`No plans available for provider ${providerName}`);
   }
 
+  const plan = getPlan(planName, provider.plans);
+
   const providerInfos = await getProviderInfos(provider.id);
   const planType = plan.features.find(({ name }) => name.toLowerCase() === 'type');
 
@@ -289,6 +284,20 @@ function parseAddonOptions (options) {
   }, {});
 }
 
+function getPlan (planName, plans) {
+  // if no plan specified, pick the cheapest one
+  if (planName == null || planName === '') {
+    return plans.sort((p1, p2) => p1.price - p2.price)[0];
+  }
+
+  const plan = plans.find((p) => p.slug.toLowerCase() === planName.toLowerCase());
+  if (plan == null) {
+    const availablePlans = plans.map((p) => p.slug);
+    throw new Error(`Invalid plan name. Available plans: ${availablePlans.join(', ')}`);
+  }
+  return plan;
+}
+
 module.exports = {
   completePlan,
   completeRegion,

package/src/models/app_configuration.js

@@ -54,13 +54,21 @@ async function addLinkedApplication (appData, alias, ignoreParentConfig) {
   return persistConfig(currentConfig);
 };
 
-async function removeLinkedApplication (alias) {
+async function removeLinkedApplication ({ appId, alias }) {
   const currentConfig = await loadApplicationConf();
   const newConfig = {
     ...currentConfig,
-    apps: currentConfig.apps.filter((appEntry) => appEntry.alias !== alias),
+    apps: currentConfig.apps.filter((appEntry) => {
+      return appEntry.app_id !== appId && appEntry.alias !== alias;
+    }),
   };
-  return persistConfig(newConfig);
+
+  if (currentConfig.apps.length !== newConfig.apps.length) {
+    await persistConfig(newConfig);
+    return true;
+  }
+
+  return false;
 };
 
 function findApp (config, alias) {

package/src/models/application.js

@@ -4,6 +4,7 @@ const _ = require('lodash');
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
 const autocomplete = require('cliparse').autocomplete;
 const product = require('@clevercloud/client/cjs/api/v2/product.js');
+const { getSummary } = require('@clevercloud/client/cjs/api/v2/user.js');
 
 const AppConfiguration = require('./app_configuration.js');
 const Interact = require('./interact.js');
@@ -12,6 +13,8 @@ const Organisation = require('./organisation.js');
 const User = require('./user.js');
 
 const { sendToApi } = require('../models/send-to-api.js');
+const AppConfig = require('./app_configuration.js');
+const { resolveOwnerId } = require('./ids-resolver.js');
 
 function listAvailableTypes () {
   return autocomplete.words(['docker', 'elixir', 'go', 'gradle', 'haskell', 'jar', 'maven', 'meteor', 'node', 'php', 'play1', 'play2', 'python', 'ruby', 'rust', 'sbt', 'static-apache', 'war']);
@@ -86,20 +89,58 @@ async function create (name, typeName, region, orgaIdOrName, github, isTask, env
   return application.create({ id: ownerId }, newApp).then(sendToApi);
 };
 
-async function deleteApp (addDetails, skipConfirmation) {
-  Logger.debug('Deleting app: ' + addDetails.name + ' (' + addDetails.appId + ')');
+async function deleteApp (app, skipConfirmation) {
+  Logger.debug('Deleting app: ' + app.name + ' (' + app.id + ')');
 
   if (!skipConfirmation) {
     await Interact.confirm(
-      `Deleting the application ${addDetails.name} can't be undone, please type '${addDetails.name}' to confirm: `,
+      `Deleting the application ${app.name} can't be undone, please type '${app.name}' to confirm: `,
       'No confirmation, aborting application deletion',
-      [addDetails.name],
+      [app.name],
     );
   }
 
-  return application.remove({ id: addDetails.ownerId, appId: addDetails.appId }).then(sendToApi);
+  return application.remove({ id: app.ownerId, appId: app.id }).then(sendToApi);
 };
 
+async function getAllApps (ownerId) {
+
+  const summary = await getSummary().then(sendToApi);
+
+  const orgaWithApps = await Promise.all(
+    summary.organisations
+      // If owner ID is present, only keep the matching org
+      .filter((org) => ownerId == null || org.id === ownerId)
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .map(async (org) => {
+        const applications = await getApplicationsForOwner(org.id);
+        return {
+          id: org.id,
+          name: org.name,
+          applications: applications.sort((a, b) => a.name.localeCompare(b.name)),
+        };
+      }),
+  );
+
+  return orgaWithApps;
+};
+
+async function getApplicationsForOwner (ownerId) {
+  const rawApplications = await application.getAll({ id: ownerId }).then(sendToApi);
+  return rawApplications.map((app) => {
+    return {
+      app_id: app.id,
+      org_id: ownerId,
+      name: app.name,
+      zone: app.zone,
+      type: app.instance.variant.slug,
+      createdAt: new Date(app.creationDate).toISOString(),
+      deploy_url: app.deployment.httpUrl,
+      git_ssh_url: app.deployment.url,
+    };
+  });
+}
+
 function getApplicationByName (apps, name) {
   const filteredApps = apps.filter((app) => app.name === name);
   if (filteredApps.length === 1) {
@@ -129,6 +170,62 @@ function getFromSelf (appId) {
   return application.get({ appId }).then(sendToApi);
 };
 
+/**
+ * @param {{app_id: string}|{app_name: string}} appIdOrName
+ * @param {string} alias
+ * @return {Promise<{appId: string, ownerId: string}>}
+ */
+async function resolveId (appIdOrName, alias) {
+  if (appIdOrName != null && alias != null) {
+    throw new Error('Only one of the `--app` or `--alias` options can be set at a time');
+  }
+
+  // -- resolve by linked app
+
+  if (appIdOrName == null) {
+    const appDetails = await AppConfig.getAppDetails({ alias });
+    return { appId: appDetails.appId, ownerId: appDetails.ownerId };
+  }
+
+  // -- resolve by app id
+
+  if (appIdOrName.app_id != null) {
+    const ownerId = await resolveOwnerId(appIdOrName.app_id);
+    if (ownerId != null) {
+      return {
+        appId: appIdOrName.app_id,
+        ownerId,
+      };
+    }
+
+    throw new Error('Application not found');
+  }
+
+  // -- resolve by app name
+
+  const summary = await getSummary({}).then(sendToApi);
+
+  const candidates = [summary.user, ...summary.organisations]
+    .flatMap((owner) => owner.applications.map((app) => ({ app, owner })))
+    .filter((candidate) => candidate.app.name === appIdOrName.app_name);
+
+  if (candidates.length === 0) {
+    throw new Error('Application not found');
+  }
+  if (candidates.length === 1) {
+    return {
+      appId: candidates[0].app.id,
+      ownerId: candidates[0].owner.id,
+    };
+  }
+
+  Logger.printErrorLine(`The name '${appIdOrName.app_name}' refers to multiple applications:`);
+  candidates.forEach((candidate) => {
+    Logger.printErrorLine(`- ${candidate.owner.name}: ${candidate.app.id} (${candidate.app.variantSlug})`);
+  });
+  throw new Error('Ambiguous application name, use the `--app` option with one of the IDs above');
+}
+
 async function linkRepo (app, orgaIdOrName, alias, ignoreParentConfig) {
   Logger.debug(`Linking current repository to the app: ${app.app_id || app.app_name}`);
 
@@ -145,7 +242,7 @@ async function linkRepo (app, orgaIdOrName, alias, ignoreParentConfig) {
 
 function unlinkRepo (alias) {
   Logger.debug(`Unlinking current repository from the app: ${alias}`);
-  return AppConfiguration.removeLinkedApplication(alias);
+  return AppConfiguration.removeLinkedApplication({ alias });
 };
 
 function redeploy (ownerId, appId, commit, withoutCache) {
@@ -214,7 +311,7 @@ async function listDependencies (ownerId, appId, showAll) {
   const applicationDeps = await application.getAllDependencies({ id: ownerId, appId }).then(sendToApi);
 
   if (!showAll) {
-    return applicationDeps;
+    return applicationDeps.map((app) => ({ ...app, isLinked: true }));
   }
 
   const allApps = await application.getAll({ id: ownerId }).then(sendToApi);
@@ -237,9 +334,11 @@ async function unlink (ownerId, appId, dependency) {
 };
 
 module.exports = {
+  resolveId,
   create,
   deleteApp,
   get,
+  getAllApps,
   link,
   linkRepo,
   listAvailableAliases,

package/src/models/exit-strategy-option.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const colors = require('colors/safe');
+const Logger = require('../logger.js');
+
+function get (follow, exitOnDeploy) {
+  if (follow) {
+    if (exitOnDeploy === 'deploy-start') {
+      throw new Error('The `follow` and `exit-on` set to "deploy-start" options are not compatible');
+    }
+    Logger.println(colors.yellow('The `follow` option is deprecated and will be removed in an upcoming major, use --exit-on set to "never" instead'));
+    return 'never';
+  }
+  return exitOnDeploy;
+}
+
+// plotQuietWarning: If in quiet mode and exitStrategy set to never plot a warning to indicate that the command will end
+function plotQuietWarning (exitStrategy, quiet) {
+  if (exitStrategy === 'never' && quiet) {
+    Logger.println(colors.bold.yellow('The "never" exit-on strategy is not compatible with the "quiet" mode, it will exit once the deployment ends'));
+  }
+}
+
+module.exports = { get, plotQuietWarning };

package/src/models/json-array.js

@@ -0,0 +1,28 @@
+/**
+ * Helper to print a real JSON array with starting `[` and ending `]`
+ */
+class JsonArray {
+  constructor () {
+    this._isFirst = true;
+  }
+
+  open () {
+    process.stdout.write('[\n');
+  }
+
+  push (log) {
+    if (this._isFirst) {
+      this._isFirst = false;
+    }
+    else {
+      process.stdout.write(',\n');
+    }
+    process.stdout.write(`  ${JSON.stringify(log)}`);
+  }
+
+  close () {
+    process.stdout.write('\n]');
+  }
+}
+
+module.exports = { JsonArray };