@hubspot/cli 4.1.6 → 4.1.7-beta.1

package/commands/accounts/list.js

@@ -12,7 +12,7 @@ const {
 } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
-const { getSandboxType } = require('../../lib/prompts/sandboxesPrompt');
+const { getSandboxType } = require('../../lib/sandboxes');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
 
 const i18nKey = 'cli.commands.accounts.subcommands.list';

package/commands/sandbox/create.js

@@ -11,101 +11,26 @@ const Spinnies = require('spinnies');
 const { createSandbox } = require('@hubspot/cli-lib/sandboxes');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { createSandboxPrompt } = require('../../lib/prompts/sandboxesPrompt');
+const {
+  getSandboxType,
+  sandboxCreatePersonalAccessKeyFlow,
+} = require('../../lib/sandboxes');
 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,
-  DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
-} = require('@hubspot/cli-lib/lib/constants');
-const {
-  personalAccessKeyPrompt,
-} = require('../../lib/prompts/personalAccessKeyPrompt');
-const {
-  updateConfigWithPersonalAccessKey,
-} = require('@hubspot/cli-lib/personalAccessKey');
+const { ENVIRONMENTS } = require('@hubspot/cli-lib/lib/constants');
 const { EXIT_CODES } = require('../../lib/enums/exitCodes');
-const {
-  getConfig,
-  writeConfig,
-  updateAccountConfig,
-  getAccountConfig,
-} = require('@hubspot/cli-lib');
-const {
-  enterAccountNamePrompt,
-} = require('../../lib/prompts/enterAccountNamePrompt');
-const {
-  setAsDefaultAccountPrompt,
-} = require('../../lib/prompts/setAsDefaultAccountPrompt');
+const { getAccountConfig } = require('@hubspot/cli-lib');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
 const {
   isMissingScopeError,
+  isSpecifiedError,
 } = require('@hubspot/cli-lib/errorHandlers/apiErrors');
-const { uiFeatureHighlight } = require('../../lib/ui');
 
 const i18nKey = 'cli.commands.sandbox.subcommands.create';
 
-const personalAccessKeyFlow = async (env, account, name) => {
-  const configData = await personalAccessKeyPrompt({ env, account });
-  const updatedConfig = await updateConfigWithPersonalAccessKey(configData);
-
-  if (!updatedConfig) {
-    process.exit(EXIT_CODES.SUCCESS);
-  }
-
-  let validName = updatedConfig.name;
-
-  if (!updatedConfig.name) {
-    const nameForConfig = name
-      .toLowerCase()
-      .split(' ')
-      .join('-');
-    const { name: promptName } = await enterAccountNamePrompt(nameForConfig);
-    validName = promptName;
-  }
-
-  updateAccountConfig({
-    ...updatedConfig,
-    environment: updatedConfig.env,
-    tokenInfo: updatedConfig.auth.tokenInfo,
-    name: validName,
-  });
-  writeConfig();
-
-  const setAsDefault = await setAsDefaultAccountPrompt(validName);
-
-  logger.log('');
-  if (setAsDefault) {
-    logger.success(
-      i18n(`cli.lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount`, {
-        accountName: validName,
-      })
-    );
-  } else {
-    const config = getConfig();
-    logger.info(
-      i18n(`cli.lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault`, {
-        accountName: config.defaultPortal,
-      })
-    );
-  }
-  logger.success(
-    i18n(`${i18nKey}.success.configFileUpdated`, {
-      configFilename: DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
-      authMethod: PERSONAL_ACCESS_KEY_AUTH_METHOD.name,
-      account: validName,
-    })
-  );
-  uiFeatureHighlight([
-    'accountsUseCommand',
-    'accountOption',
-    'accountsListCommand',
-  ]);
-};
-
 exports.command = 'create [--name]';
 exports.describe = i18n(`${i18nKey}.describe`);
 
@@ -122,6 +47,21 @@ exports.handler = async options => {
 
   trackCommandUsage('sandbox-create', null, accountId);
 
+  if (
+    accountConfig.sandboxAccountType &&
+    accountConfig.sandboxAccountType !== null
+  ) {
+    trackCommandUsage('sandbox-create', { successful: false }, accountId);
+
+    logger.error(
+      i18n(`${i18nKey}.failure.creatingWithinSandbox`, {
+        sandboxType: getSandboxType(accountConfig.sandboxAccountType),
+      })
+    );
+
+    process.exit(EXIT_CODES.ERROR);
+  }
+
   let namePrompt;
 
   logger.log(i18n(`${i18nKey}.sandboxLimitation`));
@@ -176,13 +116,29 @@ exports.handler = async options => {
           url,
         })
       );
-    } else {
+    } else if (
+      isSpecifiedError(
+        err,
+        400,
+        'VALIDATION_ERROR',
+        'SandboxErrors.NUM_DEVELOPMENT_SANDBOXES_LIMIT_EXCEEDED_ERROR'
+      ) &&
+      err.error &&
+      err.error.message
+    ) {
+      logger.log('');
       logger.error(err.error.message);
+    } else {
+      logErrorInstance(err);
     }
     process.exit(EXIT_CODES.ERROR);
   }
   try {
-    await personalAccessKeyFlow(env, result.sandboxHubId, result.name);
+    await sandboxCreatePersonalAccessKeyFlow(
+      env,
+      result.sandboxHubId,
+      result.name
+    );
     process.exit(EXIT_CODES.SUCCESS);
   } catch (err) {
     logErrorInstance(err);

package/commands/sandbox/delete.js

@@ -11,7 +11,7 @@ const { loadAndValidateOptions } = require('../../lib/validation');
 const {
   debugErrorAndContext,
 } = require('@hubspot/cli-lib/errorHandlers/standardErrors');
-
+const { logErrorInstance } = require('@hubspot/cli-lib/errorHandlers');
 const { deleteSandbox } = require('@hubspot/cli-lib/sandboxes');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
 const { getConfig, getEnv } = require('@hubspot/cli-lib');
@@ -26,12 +26,12 @@ 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 {
+  isSpecifiedError,
+} = require('@hubspot/cli-lib/errorHandlers/apiErrors');
 
 const i18nKey = 'cli.commands.sandbox.subcommands.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`);
 
@@ -147,9 +147,12 @@ exports.handler = async options => {
     );
 
     if (
-      err.error &&
-      err.error.category === OBJECT_NOT_FOUND &&
-      err.error.subCategory === SANDBOX_NOT_FOUND
+      isSpecifiedError(
+        err,
+        404,
+        'OBJECT_NOT_FOUND',
+        'SandboxErrors.SANDBOX_NOT_FOUND'
+      )
     ) {
       logger.log('');
       logger.warn(
@@ -167,7 +170,7 @@ exports.handler = async options => {
       }
       process.exit(EXIT_CODES.SUCCESS);
     } else {
-      logger.error(err.error.message);
+      logErrorInstance(err);
     }
     process.exit(EXIT_CODES.ERROR);
   }

package/commands/sandbox/sync.js

@@ -0,0 +1,300 @@
+const {
+  addAccountOptions,
+  addConfigOptions,
+  getAccountId,
+  addUseEnvironmentOptions,
+  addTestingOptions,
+} = require('../../lib/commonOpts');
+const { trackCommandUsage } = require('../../lib/usageTracking');
+const { logger } = require('@hubspot/cli-lib/logger');
+const Spinnies = require('spinnies');
+const { initiateSync } = require('@hubspot/cli-lib/sandboxes');
+const { loadAndValidateOptions } = require('../../lib/validation');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { logErrorInstance } = require('@hubspot/cli-lib/errorHandlers');
+const { ENVIRONMENTS } = require('@hubspot/cli-lib/lib/constants');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+const { getAccountConfig, getEnv } = require('@hubspot/cli-lib');
+const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
+const { promptUser } = require('../../lib/prompts/promptUtils');
+const { uiLine } = require('../../lib/ui');
+const {
+  getAccountName,
+  getAvailableSyncTypes,
+  pollSyncTaskStatus,
+} = require('../../lib/sandboxes');
+const {
+  isMissingScopeError,
+  isSpecifiedError,
+} = require('@hubspot/cli-lib/errorHandlers/apiErrors');
+
+const i18nKey = 'cli.commands.sandbox.subcommands.sync';
+
+exports.command = 'sync';
+exports.describe = i18n(`${i18nKey}.describe`);
+
+exports.handler = async options => {
+  await loadAndValidateOptions(options);
+
+  const { force } = options; // For scripting purposes
+  const accountId = getAccountId(options);
+  const accountConfig = getAccountConfig(accountId);
+  const spinnies = new Spinnies({
+    succeedColor: 'white',
+  });
+
+  trackCommandUsage('sandbox-sync', null, accountId);
+
+  if (
+    // Check if default account is a sandbox, otherwise exit
+    // sandboxAccountType is null for non-sandbox portals, and one of 'DEVELOPER' or 'STANDARD' for sandbox portals. Undefined is to handle older config entries.
+    accountConfig.sandboxAccountType === undefined ||
+    accountConfig.sandboxAccountType === null
+  ) {
+    trackCommandUsage('sandbox-sync', { successful: false }, accountId);
+
+    logger.error(i18n(`${i18nKey}.failure.notSandbox`));
+
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  // Verify parent account exists in the config
+  let parentAccountId = accountConfig.parentAccountId || undefined;
+  if (!parentAccountId || !getAccountId({ account: parentAccountId })) {
+    logger.log('');
+    logger.error(
+      i18n(`${i18nKey}.failure.missingParentPortal`, {
+        sandboxName: getAccountName(accountConfig),
+      })
+    );
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  const parentAccountConfig = getAccountConfig(parentAccountId);
+  const isDevelopmentSandbox = accountConfig.sandboxAccountType === 'DEVELOPER';
+  const isStandardSandbox = accountConfig.sandboxAccountType === 'STANDARD';
+
+  if (isDevelopmentSandbox) {
+    logger.log(i18n(`${i18nKey}.info.developmentSandbox`));
+    logger.log(
+      i18n(`${i18nKey}.info.sync`, {
+        parentAccountName: getAccountName(parentAccountConfig),
+        sandboxName: getAccountName(accountConfig),
+      })
+    );
+    uiLine();
+    logger.warn(i18n(`${i18nKey}.warning.developmentSandbox`));
+    uiLine();
+    logger.log('');
+
+    if (!force) {
+      // Skip confirmation if force flag is present.
+      const { confirmSandboxSyncPrompt: confirmed } = await promptUser([
+        {
+          name: 'confirmSandboxSyncPrompt',
+          type: 'confirm',
+          message: i18n(`${i18nKey}.confirm.developmentSandbox`, {
+            parentAccountName: getAccountName(parentAccountConfig),
+            sandboxName: getAccountName(accountConfig),
+          }),
+        },
+      ]);
+      if (!confirmed) {
+        process.exit(EXIT_CODES.SUCCESS);
+      }
+    }
+  } else if (isStandardSandbox) {
+    const standardSyncUrl = `${getHubSpotWebsiteOrigin(
+      getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD
+    )}/sandboxes-developer/${parentAccountId}/sync?step=select_sync_path&id=${parentAccountId}_${accountId}`;
+
+    logger.log(
+      i18n(`${i18nKey}.info.standardSandbox`, {
+        url: standardSyncUrl,
+      })
+    );
+    logger.log(
+      i18n(`${i18nKey}.info.sync`, {
+        parentAccountName: getAccountName(parentAccountConfig),
+        sandboxName: getAccountName(accountConfig),
+      })
+    );
+    uiLine();
+    logger.warn(i18n(`${i18nKey}.warning.standardSandbox`));
+    uiLine();
+    logger.log('');
+
+    if (!force) {
+      // Skip confirmation if force flag is present.
+      const { confirmSandboxSyncPrompt: confirmed } = await promptUser([
+        {
+          name: 'confirmSandboxSyncPrompt',
+          type: 'confirm',
+          message: i18n(`${i18nKey}.confirm.standardSandbox`, {
+            parentAccountName: getAccountName(parentAccountConfig),
+            sandboxName: getAccountName(accountConfig),
+          }),
+        },
+      ]);
+      if (!confirmed) {
+        process.exit(EXIT_CODES.SUCCESS);
+      }
+    }
+  } else {
+    logger.error('Sync must be run in a sandbox account.');
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  let initiateSyncResponse;
+
+  const baseUrl = getHubSpotWebsiteOrigin(
+    getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD
+  );
+  const syncStatusUrl = `${baseUrl}/sandboxes-developer/${parentAccountId}/${
+    isDevelopmentSandbox ? 'development' : 'standard'
+  }`;
+
+  try {
+    logger.log('');
+    spinnies.add('sandboxSync', {
+      text: i18n(`${i18nKey}.loading.startSync`),
+    });
+
+    // Fetches sync types based on default account. Parent account required for fetch
+    const tasks = await getAvailableSyncTypes(
+      parentAccountConfig,
+      accountConfig
+    );
+
+    initiateSyncResponse = await initiateSync(
+      parentAccountId,
+      accountId,
+      tasks,
+      accountId
+    );
+
+    logger.log(i18n(`${i18nKey}.info.earlyExit`));
+    logger.log('');
+    spinnies.succeed('sandboxSync', {
+      text: i18n(`${i18nKey}.loading.succeed`),
+    });
+  } catch (err) {
+    trackCommandUsage('sandbox-sync', { successful: false }, accountId);
+
+    spinnies.fail('sandboxSync', {
+      text: i18n(`${i18nKey}.loading.fail`),
+    });
+
+    logger.log('');
+    if (isMissingScopeError(err)) {
+      logger.error(
+        i18n(`${i18nKey}.failure.missingScopes`, {
+          accountName: getAccountName(parentAccountConfig),
+        })
+      );
+    } else if (
+      isSpecifiedError(
+        err,
+        429,
+        'RATE_LIMITS',
+        'sandboxes-sync-api.SYNC_IN_PROGRESS'
+      )
+    ) {
+      logger.error(
+        i18n(`${i18nKey}.failure.syncInProgress`, {
+          url: `${baseUrl}/sandboxes-developer/${parentAccountId}/syncactivitylog`,
+        })
+      );
+    } else if (
+      isSpecifiedError(
+        err,
+        403,
+        'BANNED',
+        'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID'
+      )
+    ) {
+      // This will only trigger if a user is not a super admin of the target account.
+      logger.error(
+        i18n(`${i18nKey}.failure.notSuperAdmin`, {
+          account: getAccountName(accountConfig),
+        })
+      );
+    } else if (
+      isSpecifiedError(
+        err,
+        404,
+        'OBJECT_NOT_FOUND',
+        'SandboxErrors.SANDBOX_NOT_FOUND'
+      )
+    ) {
+      logger.error(
+        i18n(`${i18nKey}.failure.objectNotFound`, {
+          account: getAccountName(accountConfig),
+        })
+      );
+    } else {
+      logErrorInstance(err);
+    }
+    logger.log('');
+
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  try {
+    logger.log('');
+    logger.log('Sync progress:');
+    // Poll sync task status to show progress bars
+    await pollSyncTaskStatus(
+      parentAccountId,
+      initiateSyncResponse.id,
+      syncStatusUrl
+    );
+
+    logger.log('');
+    spinnies.add('syncComplete', {
+      text: i18n(`${i18nKey}.polling.syncing`),
+    });
+    spinnies.succeed('syncComplete', {
+      text: i18n(`${i18nKey}.polling.succeed`),
+    });
+    logger.log('');
+    logger.log(
+      i18n(`${i18nKey}.info.syncStatus`, {
+        url: syncStatusUrl,
+      })
+    );
+
+    process.exit(EXIT_CODES.SUCCESS);
+  } catch (err) {
+    // If polling fails at this point, we do not track a failed sync since it is running in the background.
+    logErrorInstance(err);
+
+    spinnies.add('syncComplete', {
+      text: i18n(`${i18nKey}.polling.syncing`),
+    });
+    spinnies.fail('syncComplete', {
+      text: i18n(`${i18nKey}.polling.fail`, {
+        url: syncStatusUrl,
+      }),
+    });
+
+    process.exit(EXIT_CODES.ERROR);
+  }
+};
+
+exports.builder = yargs => {
+  yargs.option('f', {
+    type: 'boolean',
+    alias: 'force',
+    describe: i18n(`${i18nKey}.examples.force`),
+  });
+
+  yargs.example([['$0 sandbox sync', i18n(`${i18nKey}.examples.default`)]]);
+
+  addConfigOptions(yargs, true);
+  addAccountOptions(yargs, true);
+  addUseEnvironmentOptions(yargs, true);
+  addTestingOptions(yargs, true);
+
+  return yargs;
+};

package/commands/sandbox.js

@@ -1,6 +1,7 @@
 const { addConfigOptions, addAccountOptions } = require('../lib/commonOpts');
 const create = require('./sandbox/create');
 const del = require('./sandbox/delete');
+const sync = require('./sandbox/sync');
 
 // const i18nKey = 'cli.commands.sandbox';
 
@@ -14,6 +15,7 @@ exports.builder = yargs => {
   yargs
     .command(create)
     .command(del)
+    .command(sync)
     .demandCommand(1, '');
 
   return yargs;

package/lib/projects.js

@@ -18,6 +18,8 @@ const {
   PROJECT_BUILD_TEXT,
   PROJECT_DEPLOY_TEXT,
   PROJECT_CONFIG_FILE,
+  PROJECT_TASK_TYPES,
+  SPINNER_STATUS,
 } = require('@hubspot/cli-lib/lib/constants');
 const {
   createProject,
@@ -361,7 +363,7 @@ const handleProjectUpload = async (
   archive.pipe(output);
 
   archive.directory(srcDir, false, file =>
-    shouldIgnoreFile(file.name) ? false : file
+    shouldIgnoreFile(file.name, true) ? false : file
   );
 
   archive.finalize();
@@ -374,6 +376,8 @@ const makePollTaskStatusFunc = ({
   statusStrings,
   linkToHubSpot,
 }) => {
+  const i18nKey = 'cli.commands.project.lib.makePollTaskStatusFunc';
+
   const isTaskComplete = task => {
     if (
       !task[statusText.SUBTASK_KEY].length ||
@@ -410,29 +414,60 @@ const makePollTaskStatusFunc = ({
       structureFn(accountId, taskName, taskId),
     ]);
 
-    const topLevelSubtasks = initialTaskStatus[statusText.SUBTASK_KEY].filter(
-      ({ id }) => !!taskStructure[id]
+    const tasksById = initialTaskStatus[statusText.SUBTASK_KEY].reduce(
+      (acc, task) => {
+        const type = task[statusText.TYPE_KEY];
+        if (type !== 'APP_ID' && type !== 'SERVERLESS_PKG') {
+          acc[task.id] = task;
+        }
+        return acc;
+      },
+      {}
     );
 
-    const numOfComponents = topLevelSubtasks.length;
-    const componentCountText = `\nFound ${numOfComponents} component${
-      numOfComponents !== 1 ? 's' : ''
-    } in this project ...\n`;
+    const structuredTasks = Object.keys(taskStructure).map(key => {
+      return {
+        ...tasksById[key],
+        subtasks: taskStructure[key]
+          .filter(taskId => Boolean(tasksById[taskId]))
+          .map(taskId => tasksById[taskId]),
+      };
+    });
+
+    const numComponents = structuredTasks.length;
+    const componentCountText = i18n(
+      numComponents === 1
+        ? `${i18nKey}.componentCountSingular`
+        : `${i18nKey}.componentCount`,
+      { numComponents }
+    );
 
     spinnies.update('overallTaskStatus', {
-      text: `${statusStrings.INITIALIZE(taskName)}${componentCountText}`,
+      text: `${statusStrings.INITIALIZE(taskName)}\n${componentCountText}\n`,
     });
 
-    for (let subTask of topLevelSubtasks) {
-      const subTaskName = subTask[statusText.SUBTASK_NAME_KEY];
-
-      spinnies.add(subTaskName, {
-        text: `${chalk.bold(subTaskName)} ${
-          statusText.STATUS_TEXT[statusText.STATES.ENQUEUED]
-        }\n`,
-        indent: 2,
+    const addTaskSpinner = (task, indent, newline) => {
+      const taskName = task[statusText.SUBTASK_NAME_KEY];
+      const taskType = task[statusText.TYPE_KEY];
+      const formattedTaskType = PROJECT_TASK_TYPES[taskType]
+        ? `[${PROJECT_TASK_TYPES[taskType]}]`
+        : '';
+      const text = `${statusText.STATUS_TEXT} ${chalk.bold(
+        taskName
+      )} ${formattedTaskType} ...${newline ? '\n' : ''}`;
+
+      spinnies.add(task.id, {
+        text,
+        indent,
       });
-    }
+    };
+
+    structuredTasks.forEach(task => {
+      addTaskSpinner(task, 2, !task.subtasks || task.subtasks.length === 0);
+      task.subtasks.forEach((subtask, i) =>
+        addTaskSpinner(subtask, 4, i === task.subtasks.length - 1)
+      );
+    });
 
     return new Promise((resolve, reject) => {
       const pollInterval = setInterval(async () => {
@@ -444,34 +479,43 @@ const makePollTaskStatusFunc = ({
 
         if (spinnies.hasActiveSpinners()) {
           subTaskStatus.forEach(subTask => {
-            const subTaskName = subTask[statusText.SUBTASK_NAME_KEY];
+            const { id, status } = subTask;
+            const spinner = spinnies.pick(id);
 
-            if (!spinnies.pick(subTaskName)) {
+            if (!spinner || spinner.status !== SPINNER_STATUS.SPINNING) {
               return;
             }
 
-            const updatedText = `${chalk.bold(subTaskName)} ${
-              statusText.STATUS_TEXT[subTask.status]
-            }\n`;
-
-            switch (subTask.status) {
-              case statusText.STATES.SUCCESS:
-                spinnies.succeed(subTaskName, { text: updatedText });
-                break;
-              case statusText.STATES.FAILURE:
-                spinnies.fail(subTaskName, { text: updatedText });
-                break;
-              default:
-                spinnies.update(subTaskName, { text: updatedText });
-                break;
+            const topLevelTask = structuredTasks.find(t => t.id == id);
+
+            if (
+              status === statusText.STATES.SUCCESS ||
+              status === statusText.STATES.FAILURE
+            ) {
+              const taskStatusText =
+                subTask.status === statusText.STATES.SUCCESS
+                  ? i18n(`${i18nKey}.successStatusText`)
+                  : i18n(`${i18nKey}.failedStatusText`);
+              const hasNewline =
+                spinner.text.includes('\n') || Boolean(topLevelTask);
+              const updatedText = `${spinner.text.replace(
+                '\n',
+                ''
+              )} ${taskStatusText}${hasNewline ? '\n' : ''}`;
+
+              status === statusText.STATES.SUCCESS
+                ? spinnies.succeed(id, { text: updatedText })
+                : spinnies.fail(id, { text: updatedText });
+
+              if (topLevelTask) {
+                topLevelTask.subtasks.forEach(currentSubtask =>
+                  spinnies.remove(currentSubtask.id)
+                );
+              }
             }
           });
 
           if (isTaskComplete(taskStatus)) {
-            // subTaskStatus.forEach(subTask => {
-            //   spinnies.remove(subTask[statusText.SUBTASK_NAME_KEY]);
-            // });
-
             if (status === statusText.STATES.SUCCESS) {
               spinnies.succeed('overallTaskStatus', {
                 text: statusStrings.SUCCESS(taskName),
@@ -481,7 +525,7 @@ const makePollTaskStatusFunc = ({
                 text: statusStrings.FAIL(taskName),
               });
 
-              const failedSubtask = subTaskStatus.filter(
+              const failedSubtasks = subTaskStatus.filter(
                 subtask => subtask.status === 'FAILURE'
               );
 
@@ -489,19 +533,19 @@ const makePollTaskStatusFunc = ({
               logger.log(
                 `${statusStrings.SUBTASK_FAIL(
                   displayId,
-                  failedSubtask.length === 1
-                    ? failedSubtask[0][statusText.SUBTASK_NAME_KEY]
-                    : failedSubtask.length + ' components'
+                  failedSubtasks.length === 1
+                    ? failedSubtasks[0][statusText.SUBTASK_NAME_KEY]
+                    : failedSubtasks.length + ' components'
                 )}\n`
               );
               logger.log('See below for a summary of errors.');
               uiLine();
 
-              failedSubtask.forEach(subTask => {
+              failedSubtasks.forEach(subTask => {
                 logger.log(
-                  `\n--- ${chalk.bold(subTask[statusText.SUBTASK_NAME_KEY])} ${
-                    statusText.STATUS_TEXT[subTask.status]
-                  } with the following error ---`
+                  `\n--- ${chalk.bold(
+                    subTask[statusText.SUBTASK_NAME_KEY]
+                  )} failed with the following error ---`
                 );
                 logger.error(subTask.errorMessage);
 

package/lib/prompts/accountsPrompt.js

@@ -1,7 +1,17 @@
 const { updateDefaultAccount } = require('@hubspot/cli-lib/lib/config');
 const { promptUser } = require('./promptUtils');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
-const { mapAccountChoices } = require('./sandboxesPrompt');
+const { getSandboxType } = require('../sandboxes');
+
+const mapAccountChoices = portals =>
+  portals.map(p => {
+    const isSandbox = p.sandboxAccountType && p.sandboxAccountType !== null;
+    const sandboxName = `[${getSandboxType(p.sandboxAccountType)} sandbox] `;
+    return {
+      name: `${p.name} ${isSandbox ? sandboxName : ''}(${p.portalId})`,
+      value: p.name || p.portalId,
+    };
+  });
 
 const i18nKey = 'cli.commands.accounts.subcommands.use';
 

package/lib/prompts/sandboxesPrompt.js

@@ -1,20 +1,19 @@
 const { promptUser } = require('./promptUtils');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { getSandboxType } = require('../sandboxes');
 
 const i18nKey = 'cli.lib.prompts.sandboxesPrompt';
 
-const getSandboxType = type =>
-  type === 'DEVELOPER' ? 'development' : 'standard';
-
-const mapAccountChoices = portals =>
-  portals.map(p => {
-    const isSandbox = p.sandboxAccountType !== null;
-    const sandboxName = `[${getSandboxType(p.sandboxAccountType)} sandbox] `;
-    return {
-      name: `${p.name} ${isSandbox ? sandboxName : ''}(${p.portalId})`,
-      value: p.name || p.portalId,
-    };
-  });
+const mapSandboxAccountChoices = portals =>
+  portals
+    .filter(p => p.sandboxAccountType && p.sandboxAccountType !== null)
+    .map(p => {
+      const sandboxName = `[${getSandboxType(p.sandboxAccountType)} sandbox] `;
+      return {
+        name: `${p.name} ${sandboxName}(${p.portalId})`,
+        value: p.name || p.portalId,
+      };
+    });
 
 const createSandboxPrompt = () => {
   return promptUser([
@@ -44,7 +43,7 @@ const deleteSandboxPrompt = (config, promptParentAccount = false) => {
       type: 'list',
       look: false,
       pageSize: 20,
-      choices: mapAccountChoices(config.portals),
+      choices: mapSandboxAccountChoices(config.portals),
       default: config.defaultPortal,
     },
   ]);
@@ -54,5 +53,4 @@ module.exports = {
   createSandboxPrompt,
   deleteSandboxPrompt,
   getSandboxType,
-  mapAccountChoices,
 };

package/lib/sandboxes.js

@@ -0,0 +1,217 @@
+const cliProgress = require('cli-progress');
+const {
+  getConfig,
+  writeConfig,
+  updateAccountConfig,
+} = require('@hubspot/cli-lib');
+const {
+  DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
+  PERSONAL_ACCESS_KEY_AUTH_METHOD,
+} = require('@hubspot/cli-lib/lib/constants');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { logger } = require('@hubspot/cli-lib/logger');
+const {
+  updateConfigWithPersonalAccessKey,
+} = require('@hubspot/cli-lib/personalAccessKey');
+const { EXIT_CODES } = require('./enums/exitCodes');
+const { enterAccountNamePrompt } = require('./prompts/enterAccountNamePrompt');
+const {
+  personalAccessKeyPrompt,
+} = require('./prompts/personalAccessKeyPrompt');
+const {
+  setAsDefaultAccountPrompt,
+} = require('./prompts/setAsDefaultAccountPrompt');
+const { uiFeatureHighlight } = require('./ui');
+const { fetchTaskStatus, fetchTypes } = require('@hubspot/cli-lib/sandboxes');
+const { handleExit, handleKeypress } = require('@hubspot/cli-lib/lib/process');
+
+const getSandboxType = type =>
+  type === 'DEVELOPER' ? 'development' : 'standard';
+
+function getAccountName(config) {
+  const isSandbox =
+    config.sandboxAccountType && config.sandboxAccountType !== null;
+  const sandboxName = `[${getSandboxType(config.sandboxAccountType)} sandbox] `;
+  return `${config.name} ${isSandbox ? sandboxName : ''}(${config.portalId})`;
+}
+
+// Fetches available sync types for a given sandbox portal
+async function getAvailableSyncTypes(parentAccountConfig, config) {
+  const parentPortalId = parentAccountConfig.portalId;
+  const portalId = config.portalId;
+  const syncTypes = await fetchTypes(parentPortalId, portalId);
+  return syncTypes.map(t => ({ type: t.name }));
+}
+
+const sandboxCreatePersonalAccessKeyFlow = async (env, account, name) => {
+  const configData = await personalAccessKeyPrompt({ env, account });
+  const updatedConfig = await updateConfigWithPersonalAccessKey(configData);
+
+  if (!updatedConfig) {
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+
+  let validName = updatedConfig.name;
+
+  if (!updatedConfig.name) {
+    const nameForConfig = name
+      .toLowerCase()
+      .split(' ')
+      .join('-');
+    const { name: promptName } = await enterAccountNamePrompt(nameForConfig);
+    validName = promptName;
+  }
+
+  updateAccountConfig({
+    ...updatedConfig,
+    environment: updatedConfig.env,
+    tokenInfo: updatedConfig.auth.tokenInfo,
+    name: validName,
+  });
+  writeConfig();
+
+  const setAsDefault = await setAsDefaultAccountPrompt(validName);
+
+  logger.log('');
+  if (setAsDefault) {
+    logger.success(
+      i18n(`cli.lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount`, {
+        accountName: validName,
+      })
+    );
+  } else {
+    const config = getConfig();
+    logger.info(
+      i18n(`cli.lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault`, {
+        accountName: config.defaultPortal,
+      })
+    );
+  }
+  logger.success(
+    i18n('cli.commands.sandbox.subcommands.create.success.configFileUpdated', {
+      configFilename: DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
+      authMethod: PERSONAL_ACCESS_KEY_AUTH_METHOD.name,
+      account: validName,
+    })
+  );
+  uiFeatureHighlight([
+    'accountsUseCommand',
+    'accountOption',
+    'accountsListCommand',
+  ]);
+};
+
+const ACTIVE_TASK_POLL_INTERVAL = 1000;
+
+const isTaskComplete = task => {
+  if (!task) {
+    return false;
+  }
+  return task.status === 'COMPLETE';
+};
+
+// Returns a promise to poll a sync task with taskId. Interval runs until sync task status is equal to 'COMPLETE'
+function pollSyncTaskStatus(accountId, taskId, syncStatusUrl) {
+  const i18nKey = 'cli.commands.sandbox.subcommands.sync.types';
+  const multibar = new cliProgress.MultiBar(
+    {
+      hideCursor: true,
+      format: '[{bar}] {percentage}% | {taskType}',
+      gracefulExit: true,
+    },
+    cliProgress.Presets.rect
+  );
+  const mergeTasks = {
+    'lead-flows': 'forms', // lead-flows are a subset of forms. We combine these in the UI as a single item, so we want to merge here for consistency.
+  };
+  const barInstances = {};
+  let pollInterval;
+  // Handle manual exit for return key and ctrl+c
+  const onTerminate = () => {
+    clearInterval(pollInterval);
+    multibar.stop();
+    logger.log('');
+    logger.log('Exiting, sync will continue in the background.');
+    logger.log('');
+    logger.log(
+      i18n('cli.commands.sandbox.subcommands.sync.info.syncStatus', {
+        url: syncStatusUrl,
+      })
+    );
+    process.exit(EXIT_CODES.SUCCESS);
+  };
+  handleExit(onTerminate);
+  handleKeypress(key => {
+    if (
+      (key && key.ctrl && key.name == 'c') ||
+      key.name === 'enter' ||
+      key.name === 'return'
+    ) {
+      onTerminate();
+    }
+  });
+  return new Promise((resolve, reject) => {
+    pollInterval = setInterval(async () => {
+      const taskResult = await fetchTaskStatus(accountId, taskId).catch(reject);
+      if (taskResult.tasks) {
+        // Array of sync tasks, eg: workflows, pipelines, object-schemas, etc. with each task containing a status of 'PENDING', 'IN_PROGRESS', 'COMPLETE', and 'FAILURE'
+        for (const task of taskResult.tasks) {
+          // For each sync task, show a progress bar and increment bar each time we run this interval until status is 'COMPLETE'
+          const taskType = task.type;
+          if (!barInstances[taskType] && !mergeTasks[taskType]) {
+            // skip creation of lead-flows bar because we're combining lead-flows into the forms bar
+            barInstances[taskType] = multibar.create(100, 0, {
+              taskType: i18n(`${i18nKey}.${taskType}.label`),
+            });
+          } else if (mergeTasks[taskType]) {
+            // If its a lead-flow, merge status into the forms progress bar
+            const formsTask = taskResult.tasks.filter(
+              t => t.type === mergeTasks[taskType]
+            )[0];
+            const formsTaskStatus = formsTask.status;
+            const leadFlowsTaskStatus = task.status;
+            if (
+              formsTaskStatus !== 'COMPLETE' ||
+              leadFlowsTaskStatus !== 'COMPLETE'
+            ) {
+              barInstances[mergeTasks[taskType]].increment(
+                Math.floor(Math.random() * 3),
+                {
+                  taskType: i18n(`${i18nKey}.${mergeTasks[taskType]}.label`),
+                }
+              );
+            }
+          }
+          if (barInstances[taskType] && task.status === 'COMPLETE') {
+            barInstances[taskType].update(100, {
+              taskType: i18n(`${i18nKey}.${taskType}.label`),
+            });
+          } else if (barInstances[taskType] && task.status === 'PROCESSING') {
+            // Do not increment for tasks still in PENDING state
+            barInstances[taskType].increment(Math.floor(Math.random() * 3), {
+              // Randomly increment bar by 0 - 2 while sync is in progress. Sandboxes currently does not have an accurate measurement for progress.
+              taskType: i18n(`${i18nKey}.${taskType}.label`),
+            });
+          }
+        }
+      } else {
+        clearInterval(pollInterval);
+        reject();
+        multibar.stop();
+      }
+      if (isTaskComplete(taskResult)) {
+        clearInterval(pollInterval);
+        resolve(taskResult);
+        multibar.stop();
+      }
+    }, ACTIVE_TASK_POLL_INTERVAL);
+  });
+}
+
+module.exports = {
+  getSandboxType,
+  getAccountName,
+  getAvailableSyncTypes,
+  sandboxCreatePersonalAccessKeyFlow,
+  pollSyncTaskStatus,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/cli",
-  "version": "4.1.6",
+  "version": "4.1.7-beta.1",
   "description": "CLI for working with HubSpot",
   "license": "Apache-2.0",
   "repository": {
@@ -8,10 +8,11 @@
     "url": "https://github.com/HubSpot/hubspot-cms-tools"
   },
   "dependencies": {
-    "@hubspot/cli-lib": "4.1.6",
-    "@hubspot/serverless-dev-runtime": "4.1.6",
+    "@hubspot/cli-lib": "4.1.7-beta.1",
+    "@hubspot/serverless-dev-runtime": "4.1.7-beta.1",
     "archiver": "^5.3.0",
     "chalk": "^4.1.2",
+    "cli-progress": "^3.11.2",
     "express": "^4.17.1",
     "findup-sync": "^4.0.0",
     "fs-extra": "^8.1.0",
@@ -37,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cc2745e695099e23886958d130bed6ae22685215"
+  "gitHead": "f97135fb4b7a43bbe9915191a70f38d509ba1b26"
 }