@hubspot/cli 4.1.7-beta.0 → 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

@@ -10,105 +10,27 @@ 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 {
-  createSandboxPrompt,
   getSandboxType,
-} = require('../../lib/prompts/sandboxesPrompt');
+  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`);
 
@@ -194,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/prompts/accountsPrompt.js

@@ -1,9 +1,7 @@
 const { updateDefaultAccount } = require('@hubspot/cli-lib/lib/config');
 const { promptUser } = require('./promptUtils');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
-
-const getSandboxType = type =>
-  type === 'DEVELOPER' ? 'development' : 'standard';
+const { getSandboxType } = require('../sandboxes');
 
 const mapAccountChoices = portals =>
   portals.map(p => {

package/lib/prompts/sandboxesPrompt.js

@@ -1,11 +1,9 @@
 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 mapSandboxAccountChoices = portals =>
   portals
     .filter(p => p.sandboxAccountType && p.sandboxAccountType !== null)

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.7-beta.0",
+  "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.7-beta.0",
-    "@hubspot/serverless-dev-runtime": "4.1.7-beta.0",
+    "@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": "2f99be18415403ff6bbd48faba96cf5315f220ab"
+  "gitHead": "f97135fb4b7a43bbe9915191a70f38d509ba1b26"
 }