clever-tools 3.14.0 → 4.0.0

package/src/commands/diag.js

@@ -1,23 +1,19 @@
-import os from 'node:os';
-
 import { releaseInfo as getLinuxInfos } from 'linux-release-info';
-import colors from 'colors/safe.js';
-
+import os from 'node:os';
+import { styleText } from 'node:util';
+import pkg from '../../package.json' with { type: 'json' };
 import { Logger } from '../logger.js';
-import { getPackageJson } from '../load-package-json.cjs';
-import * as User from '../models/user.js';
 import { conf, loadOAuthConf } from '../models/configuration.js';
+import * as User from '../models/user.js';
 
-const pkg = getPackageJson();
-
-export async function diag (params) {
+export async function diag(params) {
   const { format } = params.options;
 
   /** @type {string} */
   const userId = await User.getCurrentId().catch(() => null);
   const authDetails = await loadOAuthConf();
 
-  function getAuthState () {
+  function getAuthState() {
     if (authDetails.token == null) {
       return 'not connected';
     }
@@ -31,6 +27,7 @@ export async function diag (params) {
 
   const formattedDiag = {
     version: pkg.version,
+    commitId: pkg.commitId,
     nodeVersion: process.version,
     platform: os.platform(),
     release: os.release(),
@@ -59,35 +56,40 @@ export async function diag (params) {
     }
     case 'human':
     default: {
-      Logger.println('clever-tools  ' + colors.green(formattedDiag.version));
-      Logger.println('Node.js       ' + colors.green(formattedDiag.nodeVersion));
-      Logger.println('Platform      ' + colors.green(formattedDiag.platform));
-      Logger.println('Release       ' + colors.green(formattedDiag.release));
-      Logger.println('Architecture  ' + colors.green(formattedDiag.arch));
+      Logger.println('clever-tools  ' + styleText('green', formattedDiag.version));
+      // Only available in built binaries
+      if (formattedDiag.commitId) {
+        Logger.println('Commit        ' + styleText('green', formattedDiag.commitId));
+      }
+      Logger.println('Node.js       ' + styleText('green', formattedDiag.nodeVersion));
+      Logger.println('Platform      ' + styleText('green', formattedDiag.platform));
+      Logger.println('Release       ' + styleText('green', formattedDiag.release));
+      Logger.println('Architecture  ' + styleText('green', formattedDiag.arch));
       if (formattedDiag.linuxInfos != null) {
-        Logger.println('Linux         ' + colors.green(formattedDiag.linuxInfos));
+        Logger.println('Linux         ' + styleText('green', formattedDiag.linuxInfos));
       }
-      Logger.println('Shell         ' + colors.green(formattedDiag.shell));
-      Logger.println('Packaged      ' + colors.green(formattedDiag.isPackaged));
-      Logger.println('Exec path     ' + colors.green(formattedDiag.execPath));
-      Logger.println('Config file   ' + colors.green(formattedDiag.configFile));
+      Logger.println('Shell         ' + styleText('green', formattedDiag.shell));
+      Logger.println('Packaged      ' + styleText('green', String(formattedDiag.isPackaged)));
+      Logger.println('Exec path     ' + styleText('green', formattedDiag.execPath));
+      Logger.println('Config file   ' + styleText('green', formattedDiag.configFile));
 
-      Logger.println('Auth source   ' + colors.green(formattedDiag.authSource));
+      Logger.println('Auth source   ' + styleText('green', formattedDiag.authSource));
 
-      const token = formattedDiag.oAuthToken == null ? colors.red('(none)') : colors.green(formattedDiag.oAuthToken);
+      const token =
+        formattedDiag.oAuthToken == null ? styleText('red', '(none)') : styleText('green', formattedDiag.oAuthToken);
       Logger.println('oAuth token   ' + token);
 
       switch (formattedDiag.authState) {
         case 'authenticated': {
-          Logger.println('User ID       ' + colors.green(formattedDiag.userId));
+          Logger.println('User ID       ' + styleText('green', formattedDiag.userId));
           break;
         }
         case 'authentication failed': {
-          Logger.println('User ID       ' + colors.red('Authentication failed'));
+          Logger.println('User ID       ' + styleText('red', 'Authentication failed'));
           break;
         }
         case 'not connected': {
-          Logger.println('User ID       ' + colors.red('Not connected'));
+          Logger.println('User ID       ' + styleText('red', 'Not connected'));
         }
       }
     }

package/src/commands/domain.js

@@ -1,23 +1,23 @@
-import * as Application from '../models/application.js';
-import { Logger } from '../logger.js';
 import {
   addDomain,
-  get as getApp,
   getAllDomains,
+  get as getApp,
   getFavouriteDomain as getFavouriteDomainWithError,
   markFavouriteDomain,
   removeDomain,
   unmarkFavouriteDomain,
 } from '@clevercloud/client/esm/api/v2/application.js';
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
-import { sendToApi } from '../models/send-to-api.js';
-import colors from 'colors/safe.js';
-import { parse as parseDomain } from 'tldts';
+import { getDefaultLoadBalancersDnsInfo } from '@clevercloud/client/esm/api/v4/load-balancers.js';
 import { diagDomainConfig } from '@clevercloud/client/esm/utils/diag-domain-config.js';
 import { sortDomains } from '@clevercloud/client/esm/utils/domains.js';
-import { DnsResolver } from '../models/node-dns-resolver.js';
 import _ from 'lodash';
-import { getDefaultLoadBalancersDnsInfo } from '@clevercloud/client/esm/api/v4/load-balancers.js';
+import { styleText } from 'node:util';
+import { parse as parseDomain } from 'tldts';
+import { Logger } from '../logger.js';
+import * as Application from '../models/application.js';
+import { DnsResolver } from '../models/node-dns-resolver.js';
+import { sendToApi } from '../models/send-to-api.js';
 
 /**
  * @typedef {import('@clevercloud/client/esm/utils/diag-domain-config.types.js').DomainInfo} DomainInfo
@@ -25,7 +25,7 @@ import { getDefaultLoadBalancersDnsInfo } from '@clevercloud/client/esm/api/v4/l
  * @typedef {import('@clevercloud/client/esm/utils/diag-domain-config.types.js').DomainDiag} DomainDiag
  */
 
-function getFavouriteDomain ({ ownerId, appId }) {
+function getFavouriteDomain({ ownerId, appId }) {
   return getFavouriteDomainWithError({ id: ownerId, appId })
     .then(sendToApi)
     .then(({ fqdn }) => fqdn)
@@ -38,21 +38,19 @@ function getFavouriteDomain ({ ownerId, appId }) {
     });
 }
 
-export async function list (params) {
+export async function list(params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
   const app = await getApp({ id: ownerId, appId }).then(sendToApi);
   const favouriteDomain = await getFavouriteDomain({ ownerId, appId });
   return app.vhosts.forEach(({ fqdn }) => {
-    const prefix = (fqdn === favouriteDomain)
-      ? '* '
-      : '  ';
+    const prefix = fqdn === favouriteDomain ? '* ' : '  ';
     Logger.println(prefix + fqdn);
   });
 }
 
-export async function add (params) {
+export async function add(params) {
   const [fqdn] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -62,7 +60,7 @@ export async function add (params) {
   Logger.println('Your domain has been successfully saved');
 }
 
-export async function getFavourite (params) {
+export async function getFavourite(params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
@@ -75,7 +73,7 @@ export async function getFavourite (params) {
   return Logger.println(favouriteDomain);
 }
 
-export async function setFavourite (params) {
+export async function setFavourite(params) {
   const [fqdn] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -84,7 +82,7 @@ export async function setFavourite (params) {
   Logger.println('Your favourite domain has been successfully set');
 }
 
-export async function unsetFavourite (params) {
+export async function unsetFavourite(params) {
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
@@ -92,7 +90,7 @@ export async function unsetFavourite (params) {
   Logger.println('Favourite domain has been successfully unset');
 }
 
-export async function rm (params) {
+export async function rm(params) {
   const [fqdn] = params.args;
   const { alias, app: appIdOrName } = params.options;
   const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
@@ -102,7 +100,7 @@ export async function rm (params) {
   Logger.println('Your domain has been successfully removed');
 }
 
-export async function diagApplication (params) {
+export async function diagApplication(params) {
   const dnsResolver = new DnsResolver();
   const allDomainDiagnostics = [];
   const { alias, app: appIdOrName, format, filter } = params.options;
@@ -125,14 +123,18 @@ export async function diagApplication (params) {
   for (const { hostname, pathPrefix, isApex } of sortedDomains) {
     const resolvedDnsConfig = {
       aRecords: await dnsResolver.resolveA(hostname),
-      cnameRecords: await dnsResolver.resolveCname(hostname) ?? [],
+      cnameRecords: (await dnsResolver.resolveCname(hostname)) ?? [],
     };
 
-    const diagnosticResults = diagDomainConfig({
-      hostname,
-      pathPrefix,
-      isApex,
-    }, resolvedDnsConfig, loadBalancerDnsConfig);
+    const diagnosticResults = diagDomainConfig(
+      {
+        hostname,
+        pathPrefix,
+        isApex,
+      },
+      resolvedDnsConfig,
+      loadBalancerDnsConfig,
+    );
     allDomainDiagnostics.push({ ...diagnosticResults, resolvedDnsConfig });
 
     if (diagnosticResults.diagSummary === 'invalid' || diagnosticResults.diagSummary === 'no-config') {
@@ -162,8 +164,7 @@ export async function diagApplication (params) {
   }
 }
 
-export async function overview (params) {
-
+export async function overview(params) {
   const { format, filter } = params.options;
 
   const summary = await getSummary().then(sendToApi);
@@ -196,39 +197,40 @@ export async function overview (params) {
     }),
   );
 
-  const applicationsWithParsedDomain = applicationsWithDomains
-    .flatMap(({ app, domains }) => {
-      return domains
-        .filter((domain) => filter == null || domain.fqdn.includes(filter))
-        .map((domain) => {
-
-          // `validateHostname` is set to `false` so that wildcard domains may be parsed correctly
-          const parsedDomain = parseDomain(domain.fqdn, { validateHostname: false });
-          const pathname = new URL('https://' + domain.fqdn).pathname;
-          const subdomains = parsedDomain.subdomain !== '' ? parsedDomain.subdomain.split('.') : [];
-
-          // We're trying to create a propertyPath for lodash to create a tree structure object,
-          // the propertyPath for `aaa.bbb.ccc.example.com/the-path` would be:
-          // ["example.com", "example.com.ccc", "example.com.ccc.bbb", "example.com.ccc.bbb.aaa", "/path-aaa"]",
-
-          const sortSegments = [parsedDomain.domain, ...subdomains.reverse()];
-          const propertyPath = sortSegments.map((item, i, all) => {
-            return all.slice(0, i + 1).reverse().join('.');
-          });
-          propertyPath.push(pathname);
-
-          return {
-            ownerId: app.ownerId,
-            ownerName: app.ownerName,
-            appId: app.id,
-            appName: app.name,
-            appConsoleUrl: `${consoleUrl}/goto/${app.id}`,
-            appVariantSlug: app.variantSlug,
-            domain: domain.fqdn,
-            propetyPath: propertyPath,
-          };
+  const applicationsWithParsedDomain = applicationsWithDomains.flatMap(({ app, domains }) => {
+    return domains
+      .filter((domain) => filter == null || domain.fqdn.includes(filter))
+      .map((domain) => {
+        // `validateHostname` is set to `false` so that wildcard domains may be parsed correctly
+        const parsedDomain = parseDomain(domain.fqdn, { validateHostname: false });
+        const pathname = new URL('https://' + domain.fqdn).pathname;
+        const subdomains = parsedDomain.subdomain !== '' ? parsedDomain.subdomain.split('.') : [];
+
+        // We're trying to create a propertyPath for lodash to create a tree structure object,
+        // the propertyPath for `aaa.bbb.ccc.example.com/the-path` would be:
+        // ["example.com", "example.com.ccc", "example.com.ccc.bbb", "example.com.ccc.bbb.aaa", "/path-aaa"]",
+
+        const sortSegments = [parsedDomain.domain, ...subdomains.reverse()];
+        const propertyPath = sortSegments.map((item, i, all) => {
+          return all
+            .slice(0, i + 1)
+            .reverse()
+            .join('.');
         });
-    });
+        propertyPath.push(pathname);
+
+        return {
+          ownerId: app.ownerId,
+          ownerName: app.ownerName,
+          appId: app.id,
+          appName: app.name,
+          appConsoleUrl: `${consoleUrl}/goto/${app.id}`,
+          appVariantSlug: app.variantSlug,
+          domain: domain.fqdn,
+          propetyPath: propertyPath,
+        };
+      });
+  });
 
   const applicationsWithParsedDomainAsTree = {};
   for (const { propetyPath, ...appWithDomain } of applicationsWithParsedDomain) {
@@ -246,12 +248,10 @@ export async function overview (params) {
       if (Object.keys(applicationsWithParsedDomainAsSortedTree).length === 0) {
         if (filter?.length > 0) {
           Logger.println(`No matches for filter "${filter}"`);
-        }
-        else {
+        } else {
           Logger.println('No domains');
         }
-      }
-      else {
+      } else {
         recursiveDisplay(applicationsWithParsedDomainAsSortedTree);
       }
       break;
@@ -259,8 +259,7 @@ export async function overview (params) {
 }
 
 /** @param {DomainDiag & { resolvedDnsConfig: ResolveDnsResult }} domainDiag */
-function reportDomainDiagnostics ({ hostname, pathPrefix, resolvedDnsConfig, diagDetails, diagSummary }) {
-
+function reportDomainDiagnostics({ hostname, pathPrefix, resolvedDnsConfig, diagDetails, diagSummary }) {
   const validDiags = diagDetails.filter((diag) => diag.code === 'valid-a');
   const unknownDiags = diagDetails.filter((diag) => diag.code === 'unknown-a');
   const missingDiags = diagDetails.filter((diag) => diag.code === 'missing-a');
@@ -271,24 +270,24 @@ function reportDomainDiagnostics ({ hostname, pathPrefix, resolvedDnsConfig, dia
   const hasARecords = resolvedDnsConfig.aRecords.length > 0;
   const hasCnameRecord = resolvedDnsConfig.cnameRecords.length > 0;
 
-  Logger.println('\n' + colors.blue(hostname) + colors.yellow(pathPrefix) + '\n');
+  Logger.println('\n' + styleText('blue', hostname) + styleText('yellow', pathPrefix) + '\n');
 
   switch (diagSummary) {
     case 'managed':
-      printlnWithIndent(colors.green('✔ Managed by Clever Cloud'), 2);
+      printlnWithIndent(styleText('green', '✔ Managed by Clever Cloud'), 2);
       printlnWithIndent('ⓘ cleverapps.io domains should only be used for testing purposes', 2);
       break;
     case 'no-config':
-      printlnWithIndent(colors.red('✘ No DNS configuration found'), 2);
+      printlnWithIndent(styleText('red', '✘ No DNS configuration found'), 2);
       break;
     case 'valid':
-      printlnWithIndent(colors.green('✔ Your configuration is valid'), 2);
+      printlnWithIndent(styleText('green', '✔ Your configuration is valid'), 2);
       break;
     case 'invalid':
-      printlnWithIndent(colors.red('✘ Something is wrong with your configuration'), 2);
+      printlnWithIndent(styleText('red', '✘ Something is wrong with your configuration'), 2);
       break;
     case 'incomplete':
-      printlnWithIndent(colors.yellow('⚠ Your configuration is incomplete'), 2);
+      printlnWithIndent(styleText('yellow', '⚠ Your configuration is incomplete'), 2);
       break;
   }
 
@@ -297,7 +296,7 @@ function reportDomainDiagnostics ({ hostname, pathPrefix, resolvedDnsConfig, dia
     Logger.println('');
     validDiags.forEach((diag) => {
       const source = hasCnameRecord ? `(from CNAME ${resolvedDnsConfig.cnameRecords[0]}.)` : '';
-      printlnWithIndent(`${diag.record.value} ${colors.green('✔ A Record OK')} ${source}`, 2);
+      printlnWithIndent(`${diag.record.value} ${styleText('green', '✔ A Record OK')} ${source}`, 2);
     });
   }
 
@@ -320,7 +319,7 @@ function reportDomainDiagnostics ({ hostname, pathPrefix, resolvedDnsConfig, dia
   }
 
   // Replace unknown CNAME with missing CNAME
-  if ((diagSummary === 'invalid') && missingCname != null && unknownCname != null) {
+  if (diagSummary === 'invalid' && missingCname != null && unknownCname != null) {
     Logger.println('');
     printlnWithIndent('➖Remove this CNAME record:', 2);
     printlnWithIndent(unknownCname.record.value + '. ', 6);
@@ -367,7 +366,7 @@ function reportDomainDiagnostics ({ hostname, pathPrefix, resolvedDnsConfig, dia
  * @param {Array<{ fqdn: string }>} vhosts
  * @returns {Array<Partial<DomainInfo>>} Array of parsed domain objects
  */
-function getParsedDomains (vhosts) {
+function getParsedDomains(vhosts) {
   return vhosts.map(({ fqdn }) => {
     const { hostname, pathname } = new URL('https://' + fqdn);
     const { subdomain } = parseDomain(fqdn);
@@ -382,44 +381,43 @@ function getParsedDomains (vhosts) {
  * @param {string} text - The text to be printed.
  * @param {number} indentLevel - The number of spaces to indent the text.
  */
-function printlnWithIndent (text, indentLevel) {
+function printlnWithIndent(text, indentLevel) {
   Logger.println(' '.repeat(indentLevel) + text);
 }
 
-function recursiveSort (obj) {
-
+function recursiveSort(obj) {
   if (typeof obj === 'object' && obj.appId != null) {
     return obj;
   }
 
   const sortedObj = {};
-  Object.keys(obj).sort((a, b) => {
-    // if the domain contains a wildcard, we want it to be the first of subdomains
-    const aWithReplacedWildcard = a.replace(/^\*/, 'a');
-    const bWithReplacedWildcard = b.replace(/^\*/, 'a');
-    return aWithReplacedWildcard.localeCompare(bWithReplacedWildcard);
-  }).forEach((key) => {
-    sortedObj[key] = recursiveSort(obj[key]);
-  });
+  Object.keys(obj)
+    .sort((a, b) => {
+      // if the domain contains a wildcard, we want it to be the first of subdomains
+      const aWithReplacedWildcard = a.replace(/^\*/, 'a');
+      const bWithReplacedWildcard = b.replace(/^\*/, 'a');
+      return aWithReplacedWildcard.localeCompare(bWithReplacedWildcard);
+    })
+    .forEach((key) => {
+      sortedObj[key] = recursiveSort(obj[key]);
+    });
 
   return sortedObj;
 }
 
-function recursiveDisplay (obj, indentLevel = 0) {
-
+function recursiveDisplay(obj, indentLevel = 0) {
   if (typeof obj === 'object' && obj.appId != null) {
     printlnWithIndent(`${obj.ownerName} | ${obj.appName} (${obj.appVariantSlug})`, indentLevel);
-    printlnWithIndent(colors.blue(obj.appConsoleUrl), indentLevel);
+    printlnWithIndent(styleText('blue', obj.appConsoleUrl), indentLevel);
     return;
   }
 
   for (const [propertyPath, subObj] of Object.entries(obj)) {
     if (propertyPath !== '/') {
       Logger.println('');
-      printlnWithIndent(colors.yellow(propertyPath), indentLevel);
+      printlnWithIndent(styleText('yellow', propertyPath), indentLevel);
       recursiveDisplay(subObj, indentLevel + 2);
-    }
-    else {
+    } else {
       recursiveDisplay(subObj, indentLevel);
     }
   }

package/src/commands/drain.js

@@ -1,18 +1,15 @@
+import { createDrain, deleteDrain, getDrains, updateDrainState } from '@clevercloud/client/esm/api/v2/log.js';
+import { Logger } from '../logger.js';
 import * as Application from '../models/application.js';
 import { createDrainBody } from '../models/drain.js';
-import { Logger } from '../logger.js';
-
-import { getDrains, createDrain, deleteDrain, updateDrainState } from '@clevercloud/client/esm/api/v2/log.js';
 import { sendToApi } from '../models/send-to-api.js';
 
 // TODO: This could be useful in other commands
-async function getAppOrAddonId ({ alias, appIdOrName, addonId }) {
-  return (addonId != null)
-    ? addonId
-    : await Application.resolveId(appIdOrName, alias).then(({ appId }) => appId);
+async function getAppOrAddonId({ alias, appIdOrName, addonId }) {
+  return addonId != null ? addonId : await Application.resolveId(appIdOrName, alias).then(({ appId }) => appId);
 }
 
-export async function list (params) {
+export async function list(params) {
   const { alias, app: appIdOrName, addon: addonId, format } = params.options;
 
   const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
@@ -52,20 +49,35 @@ export async function list (params) {
   }
 }
 
-export async function create (params) {
+export async function create(params) {
   const [drainTargetType, drainTargetURL] = params.args;
-  const { alias, app: appIdOrName, addon: addonId, username, password, 'api-key': apiKey, 'index-prefix': indexPrefix, 'sd-params': structuredDataParameters } = params.options;
+  const {
+    alias,
+    app: appIdOrName,
+    addon: addonId,
+    username,
+    password,
+    'api-key': apiKey,
+    'index-prefix': indexPrefix,
+    'sd-params': structuredDataParameters,
+  } = params.options;
   const drainTargetCredentials = { username, password };
   const drainTargetConfig = { apiKey, indexPrefix, structuredDataParameters };
 
   const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
-  const body = createDrainBody(appIdOrAddonId, drainTargetURL, drainTargetType, drainTargetCredentials, drainTargetConfig);
+  const body = createDrainBody(
+    appIdOrAddonId,
+    drainTargetURL,
+    drainTargetType,
+    drainTargetCredentials,
+    drainTargetConfig,
+  );
   await createDrain({ appId: appIdOrAddonId }, body).then(sendToApi);
 
   Logger.println('Your drain has been successfully saved');
 }
 
-export async function rm (params) {
+export async function rm(params) {
   const [drainId] = params.args;
   const { alias, app: appIdOrName, addon: addonId } = params.options;
 
@@ -75,7 +87,7 @@ export async function rm (params) {
   Logger.println('Your drain has been successfully removed');
 }
 
-export async function enable (params) {
+export async function enable(params) {
   const [drainId] = params.args;
   const { alias, app: appIdOrName, addon: addonId } = params.options;
 
@@ -85,7 +97,7 @@ export async function enable (params) {
   Logger.println('Your drain has been enabled');
 }
 
-export async function disable (params) {
+export async function disable(params) {
   const [drainId] = params.args;
   const { alias, app: appIdOrName, addon: addonId } = params.options;