clever-tools 3.6.1 → 3.8.0

package/src/commands/applications.js

@@ -3,7 +3,11 @@
 const colors = require('colors/safe');
 
 const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
+const Organisation = require('../models/organisation.js');
 const Logger = require('../logger.js');
+const formatTable = require('../format-table.js');
+const { truncateWithEllipsis } = require('../models/utils.js');
 
 async function list (params) {
   const { 'only-aliases': onlyAliases, json } = params.options;
@@ -43,4 +47,82 @@ function formatApps (apps, onlyAliases, json) {
   }
 }
 
-module.exports = { list };
+async function listAll (params) {
+  const { org: orgaIdOrName, format } = params.options;
+
+  const linkedApps = await AppConfig.loadApplicationConf().then((conf) => conf.apps);
+
+  const ownerId = (orgaIdOrName != null && orgaIdOrName.orga_name !== '')
+    ? await Organisation.getId(orgaIdOrName)
+    : null;
+
+  const allAppsPerOrg = await Application.getAllApps(ownerId);
+
+  // For each app, we try to find a corresponding local alias in the configuration file
+  const allAppsWithAliasPerOrg = allAppsPerOrg.map((org) => {
+    const applicationsWithAlias = org.applications.map((app) => {
+      const foundAlias = linkedApps.find((a) => a.app_id === app.app_id)?.alias;
+      return { ...app, alias: foundAlias ?? '' };
+    });
+    return { ...org, applications: applicationsWithAlias };
+  });
+
+  switch (format) {
+    case 'json': {
+      Logger.printJson(allAppsWithAliasPerOrg);
+      break;
+    }
+    case 'human':
+    default: {
+
+      const headers = ['APPLICATION ID', 'NAME', 'TYPE', 'ZONE', 'LOCAL ALIAS'];
+      const appNameWidth = 42;
+
+      // We calculate the maximum width of each column to format the table
+      const allApps = allAppsWithAliasPerOrg.flatMap((org) => org.applications);
+      const columnWidths = [
+        getPropertyMaxWidth(allApps, 'app_id'),
+        appNameWidth,
+        getPropertyMaxWidth(allApps, 'type'),
+        getPropertyMaxWidth(allApps, 'zone'),
+        getPropertyMaxWidth(allApps, 'alias'),
+      ];
+      const formatTableWithColumnWidth = formatTable(columnWidths);
+
+      allAppsWithAliasPerOrg.forEach((org) => {
+
+        Logger.println();
+
+        const applicationsPlural = org.applications.length !== 1 ? 'applications' : 'application';
+        const punctuation = org.applications.length > 0 ? ':' : '';
+
+        Logger.println(colors.blue(`• Organization '${org.name}' (${org.id}) with ${org.applications.length} ${applicationsPlural}${punctuation}`));
+
+        if (org.applications.length > 0) {
+          Logger.println();
+          Logger.println(formatTableWithColumnWidth([
+            headers,
+            ...org.applications.map((app) => [
+              app.app_id,
+              truncateWithEllipsis(appNameWidth, app.name),
+              app.type,
+              app.zone,
+              app.alias,
+            ]),
+          ]));
+        }
+      });
+
+      break;
+    }
+  }
+}
+
+function getPropertyMaxWidth (array, propertyName) {
+  return Math.max(...array.map((o) => o[propertyName].length));
+}
+
+module.exports = {
+  list,
+  listAll,
+};

package/src/commands/cancel-deploy.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 const { getAllDeployments, cancelDeployment } = require('@clevercloud/client/cjs/api/v2/application.js');
 const { sendToApi } = require('../models/send-to-api.js');
 
 async function cancelDeploy (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);
 
   const deployments = await getAllDeployments({ id: ownerId, appId, limit: 1 }).then(sendToApi);
 

package/src/commands/config.js

@@ -2,7 +2,6 @@
 
 const application = require('@clevercloud/client/cjs/api/v2/application.js');
 
-const AppConfig = require('../models/app_configuration.js');
 const Application = require('../models/application.js');
 const ApplicationConfiguration = require('../models/application_configuration.js');
 
@@ -10,8 +9,8 @@ const { sendToApi } = require('../models/send-to-api.js');
 
 async function get (params) {
   const [configurationName] = params.args;
-  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);
   const app = await Application.get(ownerId, appId);
 
   if (configurationName == null) {
@@ -24,8 +23,8 @@ async function get (params) {
 
 async function set (params) {
   const [configurationName, configurationValue] = params.args;
-  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);
   const config = ApplicationConfiguration.getById(configurationName);
 
   if (config != null) {
@@ -36,8 +35,8 @@ async function set (params) {
 }
 
 async function update (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);
   const options = ApplicationConfiguration.parseOptions(params.options);
 
   if (Object.keys(options).length === 0) {

package/src/commands/console.js

@@ -1,18 +1,30 @@
 'use strict';
 
+const Application = require('../models/application.js');
 const AppConfig = require('../models/app_configuration.js');
 const Logger = require('../logger.js');
 const openPage = require('open');
 
 async function openConsole (params) {
-  const { alias } = params.options;
+  const { alias, app: appIdOrName } = params.options;
 
-  const { ownerId, appId } = await AppConfig.getAppDetails({ alias });
+  const baseUrl = 'https://console.clever-cloud.com';
 
-  Logger.println('Opening the console in your browser');
+  const { apps } = await AppConfig.loadApplicationConf();
+  // If no app is linked or asked, open the Console without any context
+  if (apps.length === 0 && !appIdOrName) {
+    Logger.println('Opening the Console in your browser');
+    await openPage(baseUrl, { wait: false });
+    return;
+  }
 
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
   const prefixPath = (ownerId.startsWith('user_')) ? 'users/me' : `organisations/${ownerId}`;
-  const url = `https://console.clever-cloud.com/${prefixPath}/applications/${appId}`;
+  const url = `${baseUrl}/${prefixPath}/applications/${appId}`;
+
+  Logger.debug(`URL: ${url}`);
+  Logger.println(`Opening the Console in your browser for application ${appId}`);
+
   await openPage(url, { wait: false });
 }
 

package/src/commands/curl.js

@@ -5,7 +5,7 @@ const { loadOAuthConf, conf } = require('../models/configuration.js');
 const { addOauthHeader } = require('@clevercloud/client/cjs/oauth.js');
 const Logger = require('../logger.js');
 const colors = require('colors/safe');
-const curlParser = require('../../vendors/curlconverter-parse.js');
+const curlconverter = require('curlconverter');
 
 async function loadTokens () {
   const tokens = await loadOAuthConf();
@@ -49,7 +49,12 @@ async function curl () {
     return;
   }
 
-  const requestParams = await parseCurlCommand(['curl', ...curlArgs]);
+  // WARNING: Version 3.x of curlconverter uses a fork of yargs.
+  // For "reasons", when the command has a help param, it stops the parsing and triggers a very short and localized version of some help (WAT?).
+  // That's why we remove the help param before parsing and "reinstate" it before execution.
+  const curlArgsNoHelp = curlArgs.filter((arg) => arg !== '--help' && arg !== '-h');
+  const curlCommand = ['curl', ...curlArgsNoHelp].join(' ');
+  const requestParams = await parseCurlCommand(curlCommand);
 
   // We only allow request to the respective API_HOST
   if (!requestParams.url.startsWith(conf.API_HOST)) {
@@ -78,23 +83,15 @@ async function curl () {
 
 async function parseCurlCommand (curlCommand) {
 
-  const [request] = curlParser.parse(curlCommand);
-  const url = request.urls[0];
+  const jsonString = curlconverter.toJsonString(curlCommand);
+  const curlRequestParams = JSON.parse(jsonString);
 
   return {
-    method: url.method.toString(),
-    url: url.urlWithoutQueryArray.toString(),
-    headers: transformCurlConverterWordsToObject(request.headers.headers),
-    queryParams: transformCurlConverterWordsToObject(url.queryDict),
+    method: curlRequestParams.method,
+    url: curlRequestParams.url,
+    headers: curlRequestParams.headers,
+    queryParams: curlRequestParams.queries,
   };
 }
 
-function transformCurlConverterWordsToObject (words = []) {
-  return Object.fromEntries(
-    words.map(([key, value]) => {
-      return [key.toString(), value.toString()];
-    }),
-  );
-}
-
 module.exports = { curl };

package/src/commands/delete.js

@@ -5,13 +5,23 @@ const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 
 async function deleteApp (params) {
-  const { alias, yes: skipConfirmation } = params.options;
-  const appDetails = await AppConfig.getAppDetails({ alias });
+  const { alias, app: appIdOrName, yes: skipConfirmation } = params.options;
+  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
 
-  await Application.deleteApp(appDetails, skipConfirmation);
-  await Application.unlinkRepo(appDetails.alias);
-
-  Logger.println('The application has been deleted');
+  const app = await Application.get(ownerId, appId);
+  if (app == null) {
+    Logger.println('The application doesn\'t exist');
+  }
+  else {
+    // delete app
+    await Application.deleteApp(app, skipConfirmation);
+    Logger.println('The application has been deleted');
+    // unlink app
+    const wasUnlinked = await AppConfig.removeLinkedApplication({ appId, alias });
+    if (wasUnlinked) {
+      Logger.println('The application has been unlinked');
+    }
+  }
 };
 
 module.exports = { deleteApp };

package/src/commands/deploy.js

@@ -9,11 +9,14 @@ const Log = require('../models/log-v4.js');
 const Logger = require('../logger.js');
 const { getAllDeployments } = require('@clevercloud/client/cjs/api/v2/application.js');
 const { sendToApi } = require('../models/send-to-api.js');
+const ExitStrategy = require('../models/exit-strategy-option.js');
 
 // Once the API call to redeploy() has been triggered successfully,
 // the rest (waiting for deployment state to evolve and displaying logs) is done with auto retry (resilient to network failures)
 async function deploy (params) {
-  const { alias, branch: branchName, tag: tagName, quiet, force, follow, 'same-commit-policy': sameCommitPolicy } = params.options;
+  const { alias, branch: branchName, tag: tagName, quiet, force, follow, 'same-commit-policy': sameCommitPolicy, 'exit-on': exitOnDeploy } = params.options;
+
+  const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
 
   const appData = await AppConfig.getAppDetails({ alias });
   const { ownerId, appId } = appData;
@@ -36,9 +39,9 @@ async function deploy (params) {
         Logger.println(`The clever-cloud application is up-to-date (${colors.green(remoteHeadCommitId)})`);
         return;
       case 'restart':
-        return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, follow, false);
+        return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, false, exitStrategy);
       case 'rebuild':
-        return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, follow, true);
+        return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, true, exitStrategy);
       case 'error':
       default: {
         const upToDateMessage = `The clever-cloud application is up-to-date (${colors.green(remoteHeadCommitId)}).\nYou can set a policy with 'same-commit-policy' to handle differently when remote HEAD has the same commit as the one to push.\nOr try this command to restart the application:`;
@@ -79,12 +82,12 @@ async function deploy (params) {
     });
   Logger.println(colors.bold.green('Your source code has been pushed to Clever Cloud.'));
 
-  return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, commitId: commitIdToPush, knownDeployments, quiet, follow });
+  return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, commitId: commitIdToPush, knownDeployments, quiet, exitStrategy });
 }
 
-async function restartOnSameCommit (ownerId, appId, commitIdToPush, quiet, follow, withoutCache) {
+async function restartOnSameCommit (ownerId, appId, commitIdToPush, quiet, withoutCache, exitStrategy) {
   const restart = await Application.redeploy(ownerId, appId, commitIdToPush, withoutCache);
-  return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, deploymentId: restart.deploymentId, quiet, follow });
+  return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, deploymentId: restart.deploymentId, quiet, exitStrategy });
 }
 
 async function getBranchToDeploy (branchName, tagName) {

package/src/commands/diag.js

@@ -10,47 +10,87 @@ const pkg = require('../../package.json');
 const User = require('../models/user.js');
 const { conf, loadOAuthConf } = require('../models/configuration.js');
 
-async function diag () {
+async function diag (params) {
+  const { format } = params.options;
 
+  /** @type {string} */
   const userId = await User.getCurrentId().catch(() => null);
   const authDetails = await loadOAuthConf();
 
-  Logger.println('clever-tools  ' + colors.green(pkg.version));
-  Logger.println('Node.js       ' + colors.green(process.version));
+  function getAuthState () {
+    if (authDetails.token == null) {
+      return 'not connected';
+    }
+
+    if (userId == null) {
+      return 'authentication failed';
+    }
+
+    return 'authenticated';
+  }
 
-  Logger.println('Platform      ' + colors.green(os.platform()));
-  Logger.println('Release       ' + colors.green(os.release()));
-  Logger.println('Architecture  ' + colors.green(process.arch));
+  const formattedDiag = {
+    version: pkg.version,
+    nodeVersion: process.version,
+    platform: os.platform(),
+    release: os.release(),
+    arch: process.arch,
+    shell: process.env.SHELL,
+    isPackaged: process.pkg != null,
+    execPath: process.execPath,
+    configFile: conf.CONFIGURATION_FILE,
+    authSource: authDetails.source,
+    oAuthToken: authDetails.token,
+    authState: getAuthState(),
+    userId,
+  };
 
-  // Linux specific
-  const linuxInfos = await getLinuxInfos().then(({ pretty_name, name, id }) => pretty_name || name || id).catch(() => null);
+  const linuxInfos = await getLinuxInfos()
+    .then(({ pretty_name, name, id }) => pretty_name || name || id)
+    .catch(() => null);
   if (linuxInfos != null) {
-    Logger.println('Linux         ' + colors.green(linuxInfos));
+    formattedDiag.linuxInfos = linuxInfos;
   }
 
-  Logger.println('Shell         ' + colors.green(process.env.SHELL));
+  switch (format) {
+    case 'json': {
+      Logger.printJson(formattedDiag);
+      break;
+    }
+    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));
+      if (formattedDiag.linuxInfos != null) {
+        Logger.println('Linux         ' + colors.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));
 
-  const isPackaged = (process.pkg != null);
-  Logger.println('Packaged      ' + colors.green(isPackaged));
-  Logger.println('Exec path     ' + colors.green(process.execPath));
-  Logger.println('Config file   ' + colors.green(conf.CONFIGURATION_FILE));
-  Logger.println('Auth source   ' + colors.green(authDetails.source));
+      Logger.println('Auth source   ' + colors.green(formattedDiag.authSource));
 
-  const oauthToken = (authDetails.token != null)
-    ? colors.green(authDetails.token)
-    : colors.red('(none)');
-  Logger.println('oAuth token   ' + oauthToken);
+      const token = formattedDiag.oAuthToken == null ? colors.red('(none)') : colors.green(formattedDiag.oAuthToken);
+      Logger.println('oAuth token   ' + token);
 
-  if (authDetails.token != null) {
-    if (userId != null) {
-      Logger.println('User ID       ' + colors.green(userId));
+      switch (formattedDiag.authState) {
+        case 'authenticated': {
+          Logger.println('User ID       ' + colors.green(formattedDiag.userId));
+          break;
+        }
+        case 'authentication failed': {
+          Logger.println('User ID       ' + colors.red('Authentication failed'));
+          break;
+        }
+        case 'not connected': {
+          Logger.println('User ID       ' + colors.red('Not connected'));
+        }
+      }
     }
-    else {
-      Logger.println('User ID       ' + colors.red('Authentication failed'));
-    }
-  }
-  else {
-    Logger.println('User ID       ' + colors.red('Not connected'));
   }
 }
 

package/src/commands/domain.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const Logger = require('../logger.js');
 const {
   get: getApp,
@@ -26,8 +26,8 @@ function getFavouriteDomain ({ ownerId, appId }) {
 }
 
 async function list (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);
 
   const app = await getApp({ id: ownerId, appId }).then(sendToApi);
   const favouriteDomain = await getFavouriteDomain({ ownerId, appId });
@@ -41,8 +41,8 @@ async function list (params) {
 
 async function add (params) {
   const [fqdn] = params.args;
-  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);
   const encodedFqdn = encodeURIComponent(fqdn);
 
   await addDomain({ id: ownerId, appId, domain: encodedFqdn }).then(sendToApi);
@@ -50,8 +50,8 @@ async function add (params) {
 }
 
 async function getFavourite (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);
 
   const favouriteDomain = await getFavouriteDomain({ ownerId, appId });
 
@@ -64,16 +64,16 @@ async function getFavourite (params) {
 
 async function setFavourite (params) {
   const [fqdn] = params.args;
-  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 markFavouriteDomain({ id: ownerId, appId }, { fqdn }).then(sendToApi);
   Logger.println('Your favourite domain has been successfully set');
 }
 
 async function unsetFavourite (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 unmarkFavouriteDomain({ id: ownerId, appId }).then(sendToApi);
   Logger.println('Favourite domain has been successfully unset');
@@ -81,8 +81,8 @@ async function unsetFavourite (params) {
 
 async function rm (params) {
   const [fqdn] = params.args;
-  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);
   const encodedFqdn = encodeURIComponent(fqdn);
 
   await removeDomain({ id: ownerId, appId, domain: encodedFqdn }).then(sendToApi);

package/src/commands/drain.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const AppConfig = require('../models/app_configuration.js');
+const Application = require('../models/application.js');
 const { createDrainBody } = require('../models/drain.js');
 const Logger = require('../logger.js');
 
@@ -8,44 +8,59 @@ const { getDrains, createDrain, deleteDrain, updateDrainState } = require('@clev
 const { sendToApi } = require('../models/send-to-api.js');
 
 // TODO: This could be useful in other commands
-async function getAppOrAddonId ({ alias, addonId }) {
+async function getAppOrAddonId ({ alias, appIdOrName, addonId }) {
   return (addonId != null)
     ? addonId
-    : AppConfig.getAppDetails({ alias }).then(({ appId }) => appId);
+    : await Application.resolveId(appIdOrName, alias).then(({ appId }) => appId);
 }
 
 async function list (params) {
-  const { alias, addon: addonId } = params.options;
+  const { alias, app: appIdOrName, addon: addonId, format } = params.options;
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, addonId });
+  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
   const drains = await getDrains({ appId: appIdOrAddonId }).then(sendToApi);
 
-  if (drains.length === 0) {
-    Logger.println(`There are no drains for ${appIdOrAddonId}`);
-  }
-
-  drains.forEach((drain) => {
-    const { id, state, target } = drain;
-    const { url, drainType, indexPrefix, structuredDataParameters } = target;
+  switch (format) {
+    case 'json': {
+      const formattedDrains = drains.map((drain) => ({
+        id: drain.id,
+        target: drain.target,
+        state: drain.state,
+      }));
 
-    let drainView = `${id} -> ${state} for ${url} as ${drainType}`;
-    if (indexPrefix != null) {
-      drainView += `, index: '${indexPrefix}-<YYYY-MM-DD>'`;
+      Logger.printJson(formattedDrains);
+      break;
     }
-    if (structuredDataParameters != null) {
-      drainView += `, sd-parameters: '${structuredDataParameters}'`;
+    case 'human':
+    default: {
+      if (drains.length === 0) {
+        Logger.println(`There are no drains for ${appIdOrAddonId}`);
+      }
+
+      drains.forEach((drain) => {
+        const { id, state, target } = drain;
+        const { url, drainType, indexPrefix, structuredDataParameters } = target;
+
+        let drainView = `${id} -> ${state} for ${url} as ${drainType}`;
+        if (indexPrefix != null) {
+          drainView += `, index: '${indexPrefix}-<YYYY-MM-DD>'`;
+        }
+        if (structuredDataParameters != null) {
+          drainView += `, sd-params: '${structuredDataParameters}'`;
+        }
+        Logger.println(drainView);
+      });
     }
-    Logger.println(drainView);
-  });
+  }
 }
 
 async function create (params) {
   const [drainTargetType, drainTargetURL] = params.args;
-  const { alias, addon: addonId, username, password, 'api-key': apiKey, 'index-prefix': indexPrefix, 'sd-parameters': 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, addonId });
+  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
   const body = createDrainBody(appIdOrAddonId, drainTargetURL, drainTargetType, drainTargetCredentials, drainTargetConfig);
   await createDrain({ appId: appIdOrAddonId }, body).then(sendToApi);
 
@@ -54,9 +69,9 @@ async function create (params) {
 
 async function rm (params) {
   const [drainId] = params.args;
-  const { alias, addon: addonId } = params.options;
+  const { alias, app: appIdOrName, addon: addonId } = params.options;
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, addonId });
+  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
   await deleteDrain({ appId: appIdOrAddonId, drainId }).then(sendToApi);
 
   Logger.println('Your drain has been successfully removed');
@@ -64,9 +79,9 @@ async function rm (params) {
 
 async function enable (params) {
   const [drainId] = params.args;
-  const { alias, addon: addonId } = params.options;
+  const { alias, app: appIdOrName, addon: addonId } = params.options;
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, addonId });
+  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
   await updateDrainState({ appId: appIdOrAddonId, drainId }, { state: 'ENABLED' }).then(sendToApi);
 
   Logger.println('Your drain has been enabled');
@@ -74,9 +89,9 @@ async function enable (params) {
 
 async function disable (params) {
   const [drainId] = params.args;
-  const { alias, addon: addonId } = params.options;
+  const { alias, app: appIdOrName, addon: addonId } = params.options;
 
-  const appIdOrAddonId = await getAppOrAddonId({ alias, addonId });
+  const appIdOrAddonId = await getAppOrAddonId({ alias, appIdOrName, addonId });
   await updateDrainState({ appId: appIdOrAddonId, drainId }, { state: 'DISABLED' }).then(sendToApi);
 
   Logger.println('Your drain has been disabled');