@hubspot/cli 4.0.1-beta.3 → 4.0.1

package/bin/cli.js

@@ -35,6 +35,7 @@ const moduleCommand = require('../commands/module');
 const configCommand = require('../commands/config');
 const accountsCommand = require('../commands/accounts');
 const sandboxesCommand = require('../commands/sandbox');
+const cmsCommand = require('../commands/cms');
 const { EXIT_CODES } = require('../lib/enums/exitCodes');
 
 const notifier = updateNotifier({ pkg: { ...pkg, name: '@hubspot/cli' } });
@@ -129,6 +130,7 @@ const argv = yargs
   .command(authCommand)
   .command(initCommand)
   .command(logsCommand)
+  .command(cmsCommand)
   .command(lintCommand)
   .command(hubdbCommand)
   .command(watchCommand)

package/commands/accounts/use.js

@@ -5,47 +5,24 @@ const {
   updateDefaultAccount,
   getAccountId: getAccountIdFromConfig,
 } = require('@hubspot/cli-lib/lib/config');
-const { loadAndValidateOptions } = require('../../lib/validation');
 
-const { getAccountId } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
-const { promptUser } = require('../../lib/prompts/promptUtils');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { selectAccountFromConfig } = require('../../lib/prompts/accountsPrompt');
+const { loadAndValidateOptions } = require('../../lib/validation');
 
 const i18nKey = 'cli.commands.accounts.subcommands.use';
 
-const selectAccountFromConfig = async config => {
-  const { default: selectedDefault } = await promptUser([
-    {
-      type: 'list',
-      look: false,
-      name: 'default',
-      pageSize: 20,
-      message: i18n(`${i18nKey}.promptMessage`),
-      choices: config.portals.map(p => ({
-        name: `${p.name} (${p.portalId})`,
-        value: p.name || p.portalId,
-      })),
-      default: config.defaultPortal,
-    },
-  ]);
-
-  return selectedDefault;
-};
-
 exports.command = 'use [--account]';
 exports.describe = i18n(`${i18nKey}.describe`);
 
 exports.handler = async options => {
-  await loadAndValidateOptions({ debug: options.debug });
+  await loadAndValidateOptions(options, false);
 
-  const accountId = getAccountId(options);
   const config = getConfig();
 
   let newDefaultAccount = options.account;
 
-  trackCommandUsage('accounts-use', {}, accountId);
-
   if (!newDefaultAccount) {
     newDefaultAccount = await selectAccountFromConfig(config);
   } else if (!getAccountIdFromConfig(newDefaultAccount)) {
@@ -58,6 +35,12 @@ exports.handler = async options => {
     newDefaultAccount = await selectAccountFromConfig(config);
   }
 
+  trackCommandUsage(
+    'accounts-use',
+    {},
+    getAccountIdFromConfig(newDefaultAccount)
+  );
+
   updateDefaultAccount(newDefaultAccount);
 
   return logger.success(

package/commands/cms/lighthouseScore.js

@@ -0,0 +1,325 @@
+//const chalk = require('chalk');
+const Spinnies = require('spinnies');
+const {
+  addAccountOptions,
+  addConfigOptions,
+  addUseEnvironmentOptions,
+  getAccountId,
+} = require('../../lib/commonOpts');
+const { logger } = require('@hubspot/cli-lib/logger');
+const {
+  getTableContents,
+  getTableHeader,
+} = require('@hubspot/cli-lib/lib/table');
+const { loadAndValidateOptions } = require('../../lib/validation');
+const { promptUser } = require('../../lib/prompts/promptUtils');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { fetchThemes } = require('@hubspot/cli-lib/api/designManager');
+const {
+  requestLighthouseScore,
+  getLighthouseScoreStatus,
+  getLighthouseScore,
+} = require('@hubspot/cli-lib/api/lighthouseScore');
+const {
+  HUBSPOT_FOLDER,
+  MARKETPLACE_FOLDER,
+} = require('@hubspot/cli-lib/lib/constants');
+const { uiLink } = require('../../lib/ui');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+
+const i18nKey = 'cli.commands.cms.subcommands.lighthouseScore';
+
+const DEFAULT_TABLE_HEADER = [
+  'Accessibility',
+  'Best practices',
+  'Performace',
+  'PWA',
+  'SEO',
+];
+
+exports.command = 'lighthouse-score [--theme]';
+exports.describe = i18n(`${i18nKey}.describe`);
+
+const selectTheme = async accountId => {
+  const { theme: selectedTheme } = await promptUser([
+    {
+      type: 'list',
+      look: false,
+      name: 'theme',
+      message: i18n(`${i18nKey}.info.promptMessage`),
+      choices: async () => {
+        try {
+          const result = await fetchThemes(accountId, {
+            limit: 500,
+            sorting: 'MOST_USED',
+          });
+          if (result && result.objects) {
+            return result.objects
+              .map(({ theme }) => theme.path)
+              .filter(
+                themePath =>
+                  !themePath.startsWith(HUBSPOT_FOLDER) &&
+                  !themePath.startsWith(MARKETPLACE_FOLDER)
+              );
+          }
+        } catch (err) {
+          logger.error(i18n(`${i18nKey}.errors.failedToFetchThemes`));
+          process.exit(EXIT_CODES.ERROR);
+        }
+      },
+    },
+  ]);
+
+  return selectedTheme;
+};
+
+exports.handler = async options => {
+  await loadAndValidateOptions(options);
+  const accountId = getAccountId(options);
+
+  const includeDesktopScore = options.target === 'desktop' || !options.verbose;
+  const includeMobileScore = options.target === 'mobile' || !options.verbose;
+  let themeToCheck = options.theme;
+
+  if (themeToCheck) {
+    let isValidTheme = true;
+    try {
+      const result = await fetchThemes(accountId, {
+        name: encodeURIComponent(themeToCheck),
+      });
+      isValidTheme = result && result.total;
+    } catch (err) {
+      isValidTheme = false;
+    }
+    if (!isValidTheme) {
+      logger.error(
+        i18n(`${i18nKey}.errors.themeNotFound`, { theme: themeToCheck })
+      );
+      process.exit(EXIT_CODES.ERROR);
+    }
+  } else {
+    themeToCheck = await selectTheme(accountId);
+    logger.log();
+  }
+
+  // Kick off the scoring
+  let requestResult;
+  try {
+    requestResult = await requestLighthouseScore(accountId, {
+      themePath: themeToCheck,
+    });
+  } catch (err) {
+    logger.debug(err);
+  }
+
+  if (!requestResult || !requestResult.mobileId || !requestResult.desktopId) {
+    logger.error(i18n(`${i18nKey}.errors.failedToGetLighthouseScore`));
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  // Poll till scoring is finished
+  try {
+    const spinnies = new Spinnies();
+
+    spinnies.add('lighthouseScore', {
+      text: i18n(`${i18nKey}.info.generatingScore`, { theme: themeToCheck }),
+    });
+
+    const checkScoreStatus = async () => {
+      const desktopScoreStatus = includeDesktopScore
+        ? await getLighthouseScoreStatus(accountId, {
+            themeId: requestResult.desktopId,
+          })
+        : 'COMPLETED';
+      const mobileScoreStatus = includeMobileScore
+        ? await getLighthouseScoreStatus(accountId, {
+            themeId: requestResult.mobileId,
+          })
+        : 'COMPLETED';
+
+      if (
+        desktopScoreStatus === 'REQUESTED' ||
+        mobileScoreStatus === 'REQUESTED'
+      ) {
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        await checkScoreStatus();
+      }
+    };
+
+    await checkScoreStatus();
+
+    spinnies.remove('lighthouseScore');
+  } catch (err) {
+    logger.debug(err);
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  // Fetch the scoring results
+  let desktopScoreResult;
+  let mobileScoreResult;
+  let verboseViewAverageScoreResult;
+  try {
+    const params = { isAverage: !options.verbose };
+    desktopScoreResult = includeDesktopScore
+      ? await getLighthouseScore(accountId, {
+          ...params,
+          desktopId: requestResult.desktopId,
+        })
+      : {};
+    mobileScoreResult = includeMobileScore
+      ? await getLighthouseScore(accountId, {
+          ...params,
+          mobileId: requestResult.mobileId,
+        })
+      : {};
+    // This is needed to show the average scores above the verbose output
+    verboseViewAverageScoreResult = options.verbose
+      ? await getLighthouseScore(accountId, {
+          ...params,
+          isAverage: true,
+          desktopId: includeDesktopScore ? requestResult.desktopId : null,
+          mobileId: includeMobileScore ? requestResult.mobileId : null,
+        })
+      : {};
+  } catch (err) {
+    logger.error(i18n(`${i18nKey}.errors.failedToGetLighthouseScore`));
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  if (options.verbose) {
+    logger.log(`${themeToCheck} ${options.target} scores`);
+
+    const tableHeader = getTableHeader(DEFAULT_TABLE_HEADER);
+
+    const scores = verboseViewAverageScoreResult.scores
+      ? verboseViewAverageScoreResult.scores[0]
+      : {};
+
+    const averageTableData = [
+      scores.accessibilityScore,
+      scores.bestPracticesScore,
+      scores.performanceScore,
+      scores.pwaScore,
+      scores.seoScore,
+    ];
+
+    logger.log(
+      getTableContents([tableHeader, averageTableData], {
+        border: { bodyLeft: '  ' },
+      })
+    );
+    logger.log(i18n(`${i18nKey}.info.pageTemplateScoreTitle`));
+
+    const table2Header = getTableHeader([
+      'Template path',
+      ...DEFAULT_TABLE_HEADER,
+    ]);
+
+    const scoreResult =
+      options.target === 'desktop' ? desktopScoreResult : mobileScoreResult;
+
+    const templateTableData = scoreResult.scores.map(score => {
+      return [
+        score.templatePath,
+        score.accessibilityScore,
+        score.bestPracticesScore,
+        score.performanceScore,
+        score.pwaScore,
+        score.seoScore,
+      ];
+    });
+
+    logger.log(
+      getTableContents([table2Header, ...templateTableData], {
+        border: { bodyLeft: '  ' },
+      })
+    );
+
+    logger.log(i18n(`${i18nKey}.info.lighthouseLinksTitle`));
+
+    scoreResult.scores.forEach(score => {
+      logger.log(' ', uiLink(score.templatePath, score.link));
+    });
+
+    if (scoreResult.failedTemplatePaths.length) {
+      logger.log();
+      logger.error(i18n(`${i18nKey}.info.failedTemplatePathsTitle`));
+      scoreResult.failedTemplatePaths.forEach(failedTemplatePath => {
+        logger.log(' ', failedTemplatePath);
+      });
+    }
+
+    logger.log();
+    logger.info(
+      i18n(`${i18nKey}.info.targetDeviceNote`, { target: options.target })
+    );
+  } else {
+    logger.log(`Theme: ${themeToCheck}`);
+    const tableHeader = getTableHeader(['Target', ...DEFAULT_TABLE_HEADER]);
+
+    const getTableData = (target, scoreResult) => {
+      const scores = scoreResult.scores ? scoreResult.scores[0] : {};
+      return [
+        target,
+        scores.accessibilityScore,
+        scores.bestPracticesScore,
+        scores.performanceScore,
+        scores.pwaScore,
+        scores.seoScore,
+      ];
+    };
+
+    const tableData = [
+      getTableData('desktop', desktopScoreResult),
+      getTableData('mobile', mobileScoreResult),
+    ];
+
+    logger.log(
+      getTableContents([tableHeader, ...tableData], {
+        border: { bodyLeft: '  ' },
+      })
+    );
+
+    logger.info(i18n(`${i18nKey}.info.verboseOptionNote`));
+  }
+
+  logger.log();
+  logger.log(
+    `Powered by ${uiLink(
+      'Google Lighthouse',
+      'https://developer.chrome.com/docs/lighthouse/overview/'
+    )}.`
+  );
+
+  process.exit();
+};
+
+exports.builder = yargs => {
+  yargs.option('theme', {
+    describe: i18n(`${i18nKey}.options.theme.describe`),
+    type: 'string',
+  });
+  yargs.option('target', {
+    describe: i18n(`${i18nKey}.options.target.describe`),
+    type: 'string',
+    choices: ['desktop', 'mobile'],
+    default: 'desktop',
+  });
+  yargs.option('verbose', {
+    describe: i18n(`${i18nKey}.options.verbose.describe`),
+    boolean: true,
+    default: false,
+  });
+  yargs.example([
+    [
+      '$0 cms lighthouse-score --theme=my-theme',
+      i18n(`${i18nKey}.examples.default`),
+    ],
+  ]);
+
+  addConfigOptions(yargs, true);
+  addAccountOptions(yargs, true);
+  addUseEnvironmentOptions(yargs, true);
+
+  return yargs;
+};

package/commands/cms.js

@@ -0,0 +1,16 @@
+const { addConfigOptions, addAccountOptions } = require('../lib/commonOpts');
+const lighthouseScore = require('./cms/lighthouseScore');
+
+// const i18nKey = 'cli.commands.cms';
+
+exports.command = 'cms';
+exports.describe = false; // i18n(`${i18nKey}.describe`);
+
+exports.builder = yargs => {
+  addConfigOptions(yargs, true);
+  addAccountOptions(yargs, true);
+
+  yargs.command(lighthouseScore).demandCommand(1, '');
+
+  return yargs;
+};

package/commands/fetch.js

@@ -76,5 +76,12 @@ exports.builder = yargs => {
     },
   });
 
+  yargs.options({
+    assetVersion: {
+      type: 'number',
+      describe: i18n(`${i18nKey}.options.assetVersion.describe`),
+    },
+  });
+
   return yargs;
 };

package/commands/init.js

@@ -8,6 +8,7 @@ const {
 } = require('@hubspot/cli-lib/lib/config');
 const { addConfigOptions } = require('../lib/commonOpts');
 const { handleExit } = require('@hubspot/cli-lib/lib/process');
+const { checkAndUpdateGitignore } = require('@hubspot/cli-lib/lib/git');
 const { logErrorInstance } = require('@hubspot/cli-lib/errorHandlers');
 const {
   DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
@@ -116,6 +117,8 @@ exports.handler = async options => {
     );
     const configPath = getConfigPath();
 
+    checkAndUpdateGitignore(configPath);
+
     logger.log('');
     logger.success(
       i18n(`${i18nKey}.success.configFileCreated`, {

package/commands/sandbox/create.js

@@ -7,12 +7,15 @@ const {
 } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { logger } = require('@hubspot/cli-lib/logger');
-
+const Spinnies = require('spinnies');
 const { createSandbox } = require('@hubspot/cli-lib/sandboxes');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { createSandboxPrompt } = require('../../lib/prompts/sandboxesPrompt');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
 const { logErrorInstance } = require('@hubspot/cli-lib/errorHandlers');
+const {
+  debugErrorAndContext,
+} = require('@hubspot/cli-lib/errorHandlers/standardErrors');
 const {
   ENVIRONMENTS,
   PERSONAL_ACCESS_KEY_AUTH_METHOD,
@@ -103,7 +106,7 @@ const personalAccessKeyFlow = async (env, account, name) => {
   ]);
 };
 
-exports.command = 'create [name]';
+exports.command = 'create [--name]';
 exports.describe = i18n(`${i18nKey}.describe`);
 
 exports.handler = async options => {
@@ -113,36 +116,49 @@ exports.handler = async options => {
   const accountId = getAccountId(options);
   const accountConfig = getAccountConfig(accountId);
   const env = options.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD;
-  let namePrompt;
+  const spinnies = new Spinnies({
+    succeedColor: 'white',
+  });
 
   trackCommandUsage('sandbox-create', {}, accountId);
 
+  let namePrompt;
+
   if (!name) {
     namePrompt = await createSandboxPrompt();
   }
 
   const sandboxName = name || namePrompt.name;
 
-  logger.debug(
-    i18n(`${i18nKey}.debug.creating`, {
-      name: sandboxName,
-    })
-  );
   let result;
+
   try {
-    result = await createSandbox(accountId, sandboxName).then(
-      ({ name, sandboxHubId }) => {
-        logger.log('');
-        logger.success(
-          i18n(`${i18nKey}.success.create`, {
-            name,
-            sandboxHubId,
-          })
-        );
-        return { name, sandboxHubId };
-      }
-    );
+    spinnies.add('sandboxCreate', {
+      text: i18n(`${i18nKey}.loading.add`, {
+        sandboxName,
+      }),
+    });
+
+    result = await createSandbox(accountId, sandboxName);
+
+    logger.log('');
+    spinnies.succeed('sandboxCreate', {
+      text: i18n(`${i18nKey}.loading.succeed`, {
+        name: result.name,
+        sandboxHubId: result.sandboxHubId,
+      }),
+    });
   } catch (err) {
+    debugErrorAndContext(err);
+
+    trackCommandUsage('sandbox-create', { success: false }, accountId);
+
+    spinnies.fail('sandboxCreate', {
+      text: i18n(`${i18nKey}.loading.fail`, {
+        sandboxName,
+      }),
+    });
+
     if (isMissingScopeError(err)) {
       logger.error(
         i18n(`${i18nKey}.failure.scopes.message`, {
@@ -167,17 +183,21 @@ exports.handler = async options => {
     process.exit(EXIT_CODES.SUCCESS);
   } catch (err) {
     logErrorInstance(err);
+    process.exit(EXIT_CODES.ERROR);
   }
 };
 
 exports.builder = yargs => {
-  yargs.positional('name', {
-    describe: i18n(`${i18nKey}.positionals.name.describe`),
+  yargs.option('name', {
+    describe: i18n(`${i18nKey}.options.name.describe`),
     type: 'string',
   });
 
   yargs.example([
-    ['$0 sandbox create MySandboxAccount', i18n(`${i18nKey}.examples.default`)],
+    [
+      '$0 sandbox create --name=MySandboxAccount',
+      i18n(`${i18nKey}.examples.default`),
+    ],
   ]);
 
   addConfigOptions(yargs, true);

package/commands/sandbox/delete.js

@@ -2,22 +2,157 @@ const {
   addAccountOptions,
   addConfigOptions,
   addUseEnvironmentOptions,
+  getAccountId,
+  addTestingOptions,
 } = require('../../lib/commonOpts');
 const { logger } = require('@hubspot/cli-lib/logger');
-
+const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
+const {
+  debugErrorAndContext,
+} = require('@hubspot/cli-lib/errorHandlers/standardErrors');
+
+const { deleteSandbox } = require('@hubspot/cli-lib/sandboxes');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { getConfig, getEnv } = require('@hubspot/cli-lib');
+const { deleteSandboxPrompt } = require('../../lib/prompts/sandboxesPrompt');
+const {
+  removeSandboxAccountFromConfig,
+} = require('@hubspot/cli-lib/lib/config');
+const {
+  selectAndSetAsDefaultAccountPrompt,
+} = require('../../lib/prompts/accountsPrompt');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+const { promptUser } = require('../../lib/prompts/promptUtils');
+const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
+const { ENVIRONMENTS } = require('@hubspot/cli-lib/lib/constants');
 
 const i18nKey = 'cli.commands.sandbox.subcommands.delete';
 
-exports.command = 'delete';
+const SANDBOX_NOT_FOUND = 'SandboxErrors.SANDBOX_NOT_FOUND';
+const OBJECT_NOT_FOUND = 'OBJECT_NOT_FOUND';
+
+exports.command = 'delete [--account]';
 exports.describe = i18n(`${i18nKey}.describe`);
 
 exports.handler = async options => {
-  await loadAndValidateOptions(options);
+  await loadAndValidateOptions(options, false);
+
+  const { account } = options;
+  const config = getConfig();
+
+  let accountPrompt;
+  if (!account) {
+    accountPrompt = await deleteSandboxPrompt(config);
+  }
+  const sandboxAccountId = getAccountId({
+    account: account || accountPrompt.account,
+  });
+
+  trackCommandUsage('sandbox-delete', {}, sandboxAccountId);
+
+  let parentAccountId;
+  for (const portal of config.portals) {
+    if (portal.portalId === sandboxAccountId) {
+      if (portal.parentAccountId) {
+        parentAccountId = portal.parentAccountId;
+      } else {
+        const parentAccountPrompt = await deleteSandboxPrompt(config, true);
+        parentAccountId = getAccountId({
+          account: parentAccountPrompt.account,
+        });
+      }
+    }
+  }
+
+  if (!getAccountId({ account: parentAccountId })) {
+    const baseUrl = getHubSpotWebsiteOrigin(
+      getEnv(sandboxAccountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD
+    );
+    const url = `${baseUrl}/sandboxes/${parentAccountId}`;
+    const command = `hs auth ${
+      getEnv(sandboxAccountId) === 'qa' ? '--qa' : ''
+    } --account=${parentAccountId}`;
+    logger.log('');
+    logger.error(
+      i18n(`${i18nKey}.noParentPortalAvailable`, {
+        parentAccountId,
+        url,
+        command,
+      })
+    );
+    logger.log('');
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  logger.debug(
+    i18n(`${i18nKey}.debug.deleting`, {
+      account: account || accountPrompt.account,
+    })
+  );
+
+  try {
+    const { confirmSandboxDeletePrompt: confirmed } = await promptUser([
+      {
+        name: 'confirmSandboxDeletePrompt',
+        type: 'confirm',
+        message: i18n(`${i18nKey}.confirm`, {
+          account: account || accountPrompt.account,
+        }),
+      },
+    ]);
+    if (!confirmed) {
+      process.exit(EXIT_CODES.SUCCESS);
+    }
+
+    await deleteSandbox(parentAccountId, sandboxAccountId);
+
+    logger.log('');
+    logger.success(
+      i18n(`${i18nKey}.success.delete`, {
+        account: account || accountPrompt.account,
+        sandboxHubId: sandboxAccountId,
+      })
+    );
+    logger.log('');
+
+    const promptDefaultAccount = removeSandboxAccountFromConfig(
+      sandboxAccountId
+    );
+    if (promptDefaultAccount) {
+      await selectAndSetAsDefaultAccountPrompt(config);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+  } catch (err) {
+    debugErrorAndContext(err);
+
+    trackCommandUsage('sandbox-delete', { success: false }, sandboxAccountId);
+
+    if (
+      err.error &&
+      err.error.category === OBJECT_NOT_FOUND &&
+      err.error.subCategory === SANDBOX_NOT_FOUND
+    ) {
+      logger.log('');
+      logger.warn(
+        i18n(`${i18nKey}.objectNotFound`, {
+          account: account || accountPrompt.account,
+        })
+      );
+      logger.log('');
 
-  logger.log('');
-  logger.log(i18n(`${i18nKey}.temporaryMessage`));
+      const promptDefaultAccount = removeSandboxAccountFromConfig(
+        sandboxAccountId
+      );
+      if (promptDefaultAccount) {
+        await selectAndSetAsDefaultAccountPrompt(config);
+      }
+      process.exit(EXIT_CODES.SUCCESS);
+    } else {
+      logger.error(err.error.message);
+    }
+    process.exit(EXIT_CODES.ERROR);
+  }
 };
 
 exports.builder = yargs => {
@@ -36,6 +171,7 @@ exports.builder = yargs => {
   addConfigOptions(yargs, true);
   addAccountOptions(yargs, true);
   addUseEnvironmentOptions(yargs, true);
+  addTestingOptions(yargs, true);
 
   return yargs;
 };

package/lib/projects.js

@@ -224,6 +224,13 @@ const getProjectBuildDetailUrl = (projectName, buildId, accountId) => {
   return `${getProjectDetailUrl(projectName, accountId)}/build/${buildId}`;
 };
 
+const getProjectDeployDetailUrl = (projectName, deployId, accountId) => {
+  if (!projectName || !deployId || !accountId) return;
+  return `${getProjectDetailUrl(
+    projectName,
+    accountId
+  )}/activity/deploy/${deployId}`;
+};
 const uploadProjectFiles = async (accountId, projectName, filePath) => {
   const i18nKey = 'cli.commands.project.subcommands.upload';
   const spinnies = new Spinnies({
@@ -343,10 +350,13 @@ const makePollTaskStatusFunc = ({
     }
   };
 
-  return async (accountId, taskName, taskId) => {
-    let hubspotLinkText = '';
+  return async (accountId, taskName, taskId, deployedBuildId = null) => {
+    const displayId = deployedBuildId || taskId;
+
     if (linkToHubSpot) {
-      logger.log(`\n${linkToHubSpot(taskName, taskId, accountId)}\n`);
+      logger.log(
+        `\n${linkToHubSpot(accountId, taskName, taskId, deployedBuildId)}\n`
+      );
     }
 
     const spinnies = new Spinnies({
@@ -372,7 +382,7 @@ const makePollTaskStatusFunc = ({
       const subTaskName = subTask[statusText.SUBTASK_NAME_KEY];
 
       spinnies.add(subTaskName, {
-        text: `${chalk.bold(subTaskName)} #${taskId} ${
+        text: `${chalk.bold(subTaskName)} #${displayId} ${
           statusText.STATUS_TEXT[statusText.STATES.ENQUEUED]
         }\n`,
         indent: 2,
@@ -395,7 +405,7 @@ const makePollTaskStatusFunc = ({
               return;
             }
 
-            const updatedText = `${chalk.bold(subTaskName)} #${taskId} ${
+            const updatedText = `${chalk.bold(subTaskName)} #${displayId} ${
               statusText.STATUS_TEXT[subTask.status]
             }\n`;
 
@@ -413,17 +423,17 @@ const makePollTaskStatusFunc = ({
           });
 
           if (isTaskComplete(taskStatus)) {
-            subTaskStatus.forEach(subTask => {
-              spinnies.remove(subTask[statusText.SUBTASK_NAME_KEY]);
-            });
+            // subTaskStatus.forEach(subTask => {
+            //   spinnies.remove(subTask[statusText.SUBTASK_NAME_KEY]);
+            // });
 
             if (status === statusText.STATES.SUCCESS) {
               spinnies.succeed('overallTaskStatus', {
-                text: `${statusStrings.SUCCESS(taskName)}${hubspotLinkText}`,
+                text: statusStrings.SUCCESS(taskName),
               });
             } else if (status === statusText.STATES.FAILURE) {
               spinnies.fail('overallTaskStatus', {
-                text: `${statusStrings.FAIL(taskName)}${hubspotLinkText}`,
+                text: statusStrings.FAIL(taskName),
               });
 
               const failedSubtask = subTaskStatus.filter(
@@ -433,7 +443,7 @@ const makePollTaskStatusFunc = ({
               uiLine();
               logger.log(
                 `${statusStrings.SUBTASK_FAIL(
-                  taskId,
+                  displayId,
                   failedSubtask.length === 1
                     ? failedSubtask[0][statusText.SUBTASK_NAME_KEY]
                     : failedSubtask.length + ' components'
@@ -470,10 +480,10 @@ const makePollTaskStatusFunc = ({
 };
 
 const pollBuildStatus = makePollTaskStatusFunc({
-  linkToHubSpot: (projectName, buildId, accountId) =>
+  linkToHubSpot: (accountId, taskName, taskId) =>
     uiLink(
-      `View build #${buildId} in HubSpot`,
-      getProjectBuildDetailUrl(projectName, buildId, accountId)
+      `View build #${taskId} in HubSpot`,
+      getProjectBuildDetailUrl(taskName, taskId, accountId)
     ),
   statusFn: getBuildStatus,
   statusText: PROJECT_BUILD_TEXT,
@@ -481,22 +491,27 @@ const pollBuildStatus = makePollTaskStatusFunc({
     INITIALIZE: name => `Building ${chalk.bold(name)}`,
     SUCCESS: name => `Built ${chalk.bold(name)}`,
     FAIL: name => `Failed to build ${chalk.bold(name)}`,
-    SUBTASK_FAIL: (taskId, name) =>
-      `Build #${taskId} failed because there was a problem\nbuilding ${chalk.bold(
+    SUBTASK_FAIL: (buildId, name) =>
+      `Build #${buildId} failed because there was a problem\nbuilding ${chalk.bold(
         name
       )}`,
   },
 });
 
 const pollDeployStatus = makePollTaskStatusFunc({
+  linkToHubSpot: (accountId, taskName, taskId, deployedBuildId) =>
+    uiLink(
+      `View deploy of build #${deployedBuildId} in HubSpot`,
+      getProjectDeployDetailUrl(taskName, taskId, accountId)
+    ),
   statusFn: getDeployStatus,
   statusText: PROJECT_DEPLOY_TEXT,
   statusStrings: {
     INITIALIZE: name => `Deploying ${chalk.bold(name)}`,
     SUCCESS: name => `Deployed ${chalk.bold(name)}`,
     FAIL: name => `Failed to deploy ${chalk.bold(name)}`,
-    SUBTASK_FAIL: (taskId, name) =>
-      `Deploy for build #${taskId} failed because there was a\nproblem deploying ${chalk.bold(
+    SUBTASK_FAIL: (deployedBuildId, name) =>
+      `Deploy for build #${deployedBuildId} failed because there was a\nproblem deploying ${chalk.bold(
         name
       )}`,
   },

package/lib/prompts/accountsPrompt.js

@@ -0,0 +1,47 @@
+const { updateDefaultAccount } = require('@hubspot/cli-lib/lib/config');
+const { promptUser } = require('./promptUtils');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+
+const i18nKey = 'cli.commands.accounts.subcommands.use';
+
+const selectAccountFromConfig = async config => {
+  const { default: selectedDefault } = await promptUser([
+    {
+      type: 'list',
+      look: false,
+      name: 'default',
+      pageSize: 20,
+      message: i18n(`${i18nKey}.promptMessage`),
+      choices: config.portals.map(p => ({
+        name: `${p.name} (${p.portalId})`,
+        value: p.name || p.portalId,
+      })),
+      default: config.defaultPortal,
+    },
+  ]);
+
+  return selectedDefault;
+};
+
+const selectAndSetAsDefaultAccountPrompt = async config => {
+  const { default: selectedDefault } = await promptUser([
+    {
+      type: 'list',
+      look: false,
+      name: 'default',
+      pageSize: 20,
+      message: i18n(`${i18nKey}.promptMessage`),
+      choices: config.portals.map(p => ({
+        name: `${p.name} (${p.portalId})`,
+        value: p.name || p.portalId,
+      })),
+      default: config.defaultPortal,
+    },
+  ]);
+  updateDefaultAccount(selectedDefault);
+};
+
+module.exports = {
+  selectAndSetAsDefaultAccountPrompt,
+  selectAccountFromConfig,
+};

package/lib/prompts/sandboxesPrompt.js

@@ -19,6 +19,25 @@ const createSandboxPrompt = () => {
   ]);
 };
 
+const deleteSandboxPrompt = (config, promptParentAccount = false) => {
+  return promptUser([
+    {
+      name: 'account',
+      message: i18n(
+        promptParentAccount
+          ? `${i18nKey}.selectParentAccountName`
+          : `${i18nKey}.selectAccountName`
+      ),
+      type: 'list',
+      look: false,
+      pageSize: 20,
+      choices: config.portals.map(p => p.name || p.portalId),
+      default: config.defaultPortal,
+    },
+  ]);
+};
+
 module.exports = {
   createSandboxPrompt,
+  deleteSandboxPrompt,
 };

package/lib/validation.js

@@ -26,14 +26,19 @@ const fs = require('fs');
 const path = require('path');
 const { EXIT_CODES } = require('./enums/exitCodes');
 
-async function loadAndValidateOptions(options) {
+async function loadAndValidateOptions(options, shouldValidateAccount = true) {
   setLogLevel(options);
   logDebugInfo(options);
   const { config: configPath } = options;
   loadConfig(configPath, options);
   checkAndWarnGitInclusion(getConfigPath());
 
-  if (!(validateConfig() && (await validateAccount(options)))) {
+  let validAccount = true;
+  if (shouldValidateAccount) {
+    validAccount = await validateAccount(options);
+  }
+
+  if (!(validateConfig() && validAccount)) {
     process.exit(EXIT_CODES.ERROR);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/cli",
-  "version": "4.0.1-beta.3",
+  "version": "4.0.1",
   "description": "CLI for working with HubSpot",
   "license": "Apache-2.0",
   "repository": {
@@ -8,8 +8,8 @@
     "url": "https://github.com/HubSpot/hubspot-cms-tools"
   },
   "dependencies": {
-    "@hubspot/cli-lib": "4.0.1-beta.3",
-    "@hubspot/serverless-dev-runtime": "4.0.1-beta.3",
+    "@hubspot/cli-lib": "4.0.1",
+    "@hubspot/serverless-dev-runtime": "4.0.1",
     "archiver": "^5.3.0",
     "chalk": "^4.1.2",
     "express": "^4.17.1",
@@ -37,5 +37,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e2fac76a5ea9f51f69dfb786a5f285ffcf88a47a"
+  "gitHead": "416585f18c9b856b4da3ef502d1eccaded9281d5"
 }