@hubspot/cli 5.2.1-beta.0 → 5.2.1-beta.2

package/bin/cli.js

@@ -5,6 +5,7 @@ const updateNotifier = require('update-notifier');
 const chalk = require('chalk');
 
 const { logger } = require('@hubspot/local-dev-lib/logger');
+const { addUserAgentHeader } = require('@hubspot/local-dev-lib/http');
 const { logErrorInstance } = require('../lib/errorHandlers/standardErrors');
 const { setLogLevel, getCommandName } = require('../lib/commonOpts');
 const {
@@ -110,9 +111,13 @@ const performChecks = argv => {
   }
 };
 
+const setRequestHeaders = () => {
+  addUserAgentHeader('HubSpot CLI', pkg.version);
+};
+
 const argv = yargs
   .usage('The command line interface to interact with HubSpot.')
-  .middleware([setLogLevel])
+  .middleware([setLogLevel, setRequestHeaders])
   .exitProcess(false)
   .fail(handleFailure)
   .option('debug', {

package/commands/accounts/clean.js

@@ -13,7 +13,6 @@ const {
   addUseEnvironmentOptions,
   addTestingOptions,
 } = require('../../lib/commonOpts');
-const { getAccountName } = require('../../lib/sandboxes');
 const { promptUser } = require('../../lib/prompts/promptUtils');
 const { getTableContents } = require('../../lib/ui/table');
 const SpinniesManager = require('../../lib/ui/SpinniesManager');
@@ -21,6 +20,7 @@ const { getConfig, deleteAccount } = require('@hubspot/local-dev-lib/config');
 const {
   isSpecifiedHubSpotAuthError,
 } = require('@hubspot/local-dev-lib/errors/apiErrors');
+const { uiAccountDescription } = require('../../lib/ui');
 
 const i18nKey = 'cli.commands.accounts.subcommands.clean';
 
@@ -87,7 +87,7 @@ exports.handler = async options => {
     });
     logger.log(
       getTableContents(
-        accountsToRemove.map(p => [getAccountName(p)]),
+        accountsToRemove.map(p => [uiAccountDescription(p)]),
         { border: { bodyLeft: '  ' } }
       )
     );
@@ -111,7 +111,7 @@ exports.handler = async options => {
         await deleteAccount(accountToRemove.name);
         logger.log(
           i18n(`${i18nKey}.removeSuccess`, {
-            accountName: getAccountName(accountToRemove),
+            accountName: uiAccountDescription(accountToRemove),
           })
         );
       }

package/commands/accounts/list.js

@@ -9,8 +9,13 @@ const {
 } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
-const { isSandbox, getSandboxName } = require('../../lib/sandboxes');
-const { isDeveloperTestAccount } = require('../../lib/developerTestAccounts');
+const { getSandboxName } = require('../../lib/sandboxes');
+const {
+  isSandbox,
+  isDeveloperTestAccount,
+  isAppDeveloperAccount,
+} = require('../../lib/accountTypes');
+
 const { i18n } = require('../../lib/lang');
 const {
   HUBSPOT_ACCOUNT_TYPES,
@@ -53,21 +58,28 @@ const sortAndMapPortals = portals => {
 
 const getPortalData = mappedPortalData => {
   const portalData = [];
-  Object.values(mappedPortalData).forEach(set => {
+  Object.entries(mappedPortalData).forEach(([key, set]) => {
+    const hasParentPortal = set.filter(
+      p => p.portalId === parseInt(key, 10)
+    )[0];
     set.forEach(portal => {
       let name = portal.name;
       if (isSandbox(portal)) {
         name = `${portal.name} ${getSandboxName(portal)}`;
-        if (set.length > 1) {
+        if (hasParentPortal && set.length > 1) {
           name = `↳ ${name}`;
         }
       } else if (isDeveloperTestAccount(portal)) {
         name = `${portal.name} [${
           HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]
         }]`;
-        if (set.length > 1) {
+        if (hasParentPortal && set.length > 1) {
           name = `↳ ${name}`;
         }
+      } else if (isAppDeveloperAccount(portal)) {
+        name = `${portal.name} [${
+          HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER]
+        }]`;
       }
       portalData.push([name, portal.portalId, portal.authType]);
     });

package/commands/init.js

@@ -62,7 +62,7 @@ const personalAccessKeyConfigCreationFlow = async (env, account) => {
 
   try {
     const token = await getAccessToken(personalAccessKey, env);
-    const defaultName = toKebabCase(token.hubName);
+    const defaultName = token.hubName ? toKebabCase(token.hubName) : null;
     const { name } = await enterAccountNamePrompt(defaultName);
 
     updatedConfig = updateConfigWithAccessToken(

package/commands/project/dev.js

@@ -5,10 +5,7 @@ const {
   addUseEnvironmentOptions,
   addTestingOptions,
 } = require('../../lib/commonOpts');
-const {
-  trackCommandUsage,
-  trackCommandMetadataUsage,
-} = require('../../lib/usageTracking');
+const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { handleExit } = require('../../lib/process');
 const { i18n } = require('../../lib/lang');
@@ -18,61 +15,40 @@ const {
   getAccountConfig,
   getEnv,
 } = require('@hubspot/local-dev-lib/config');
-const {
-  createProject,
-  fetchProject,
-} = require('@hubspot/local-dev-lib/api/projects');
+const { fetchProject } = require('@hubspot/local-dev-lib/api/projects');
 const {
   getProjectConfig,
   ensureProjectExists,
-  handleProjectUpload,
-  pollProjectBuildAndDeploy,
   validateProjectConfig,
 } = require('../../lib/projects');
 const { EXIT_CODES } = require('../../lib/enums/exitCodes');
-const {
-  uiAccountDescription,
-  uiBetaTag,
-  uiCommandReference,
-  uiLine,
-} = require('../../lib/ui');
-const { confirmPrompt } = require('../../lib/prompts/promptUtils');
-const {
-  selectTargetAccountPrompt,
-  confirmDefaultAccountPrompt,
-} = require('../../lib/prompts/projectDevTargetAccountPrompt');
+const { uiBetaTag } = require('../../lib/ui');
 const SpinniesManager = require('../../lib/ui/SpinniesManager');
 const LocalDevManager = require('../../lib/LocalDevManager');
-const { isSandbox, getSandboxTypeAsString } = require('../../lib/sandboxes');
-const { sandboxNamePrompt } = require('../../lib/prompts/sandboxesPrompt');
 const {
-  validateSandboxUsageLimits,
-  getAvailableSyncTypes,
-} = require('../../lib/sandboxes');
+  isSandbox,
+  isDeveloperTestAccount,
+  isStandardAccount,
+  isAppDeveloperAccount,
+} = require('../../lib/accountTypes');
 const { getValidEnv } = require('@hubspot/local-dev-lib/environment');
+
 const {
-  PROJECT_BUILD_TEXT,
-  PROJECT_DEPLOY_TEXT,
-  PROJECT_ERROR_TYPES,
-} = require('../../lib/constants');
-
-const { buildSandbox } = require('../../lib/sandboxCreate');
-const { syncSandbox } = require('../../lib/sandboxSync');
-const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
-const {
-  logApiErrorInstance,
-  ApiErrorContext,
-} = require('../../lib/errorHandlers/apiErrors');
-const {
-  isMissingScopeError,
-  isSpecifiedError,
-} = require('@hubspot/local-dev-lib/errors/apiErrors');
-const { logErrorInstance } = require('../../lib/errorHandlers/standardErrors');
-const { isDeveloperTestAccount } = require('../../lib/developerTestAccounts');
+  findProjectComponents,
+  getProjectComponentTypes,
+  COMPONENT_TYPES,
+} = require('../../lib/projectStructure');
 const {
-  HUBSPOT_ACCOUNT_TYPES,
-  HUBSPOT_ACCOUNT_TYPE_STRINGS,
-} = require('@hubspot/local-dev-lib/constants/config');
+  confirmDefaultAccountIsTarget,
+  suggestRecommendedNestedAccount,
+  checkIfAppDeveloperAccount,
+  checkIfDeveloperTestAccount,
+  createSandboxForLocalDev,
+  createDeveloperTestAccountForLocalDev,
+  createNewProjectForLocalDev,
+  createInitialBuildForNewProject,
+  useExistingDevTestAccount,
+} = require('../../lib/localDev');
 
 const i18nKey = 'cli.commands.project.subcommands.dev';
 
@@ -98,126 +74,91 @@ exports.handler = async options => {
 
   validateProjectConfig(projectConfig, projectDir);
 
+  const components = await findProjectComponents(projectDir);
+  const componentTypes = getProjectComponentTypes(components);
+  const hasPrivateApps = componentTypes[COMPONENT_TYPES.privateApp];
+  const hasPublicApps = componentTypes[COMPONENT_TYPES.publicApp];
+
+  if (hasPrivateApps && hasPublicApps) {
+    logger.error(i18n(`${i18nKey}.errors.invalidProjectComponents`));
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+
   const accounts = getConfigAccounts();
-  let targetAccountId = options.account ? accountId : null;
-  let createNewSandbox = false;
-  const defaultAccountIsSandbox = isSandbox(accountConfig);
-  const defaultAccountIsDeveloperTestAccount = isDeveloperTestAccount(
-    accountConfig
-  );
 
-  if (
-    !targetAccountId &&
-    (defaultAccountIsSandbox || defaultAccountIsDeveloperTestAccount)
-  ) {
-    logger.log();
-    const useDefaultAccount = await confirmDefaultAccountPrompt(
-      accountConfig.name,
-      defaultAccountIsSandbox
-        ? `${getSandboxTypeAsString(accountConfig.accountType)} sandbox`
-        : HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]
-    );
+  const defaultAccountIsRecommendedType =
+    isDeveloperTestAccount(accountConfig) ||
+    (!hasPublicApps && isSandbox(accountConfig));
 
-    if (useDefaultAccount) {
-      targetAccountId = accountId;
-    } else {
-      logger.log(
-        i18n(`${i18nKey}.logs.declineDefaultAccountExplanation`, {
-          useCommand: uiCommandReference('hs accounts use'),
-          devCommand: uiCommandReference('hs project dev'),
-        })
-      );
-      process.exit(EXIT_CODES.SUCCESS);
-    }
+  // The account that the project must exist in
+  let targetProjectAccountId = options.account ? accountId : null;
+  // The account that we are locally testing against
+  let targetTestingAccountId = options.account ? accountId : null;
+
+  if (options.account && hasPublicApps) {
+    checkIfDeveloperTestAccount(accountConfig);
+    targetProjectAccountId = accountConfig.parentAccountId;
+    targetTestingAccountId = accountId;
   }
 
-  if (!targetAccountId) {
-    logger.log();
-    uiLine();
-    logger.warn(i18n(`${i18nKey}.logs.nonSandboxWarning`));
-    uiLine();
-    logger.log();
+  let createNewSandbox = false;
+  let createNewDeveloperTestAccount = false;
+
+  if (!targetProjectAccountId && defaultAccountIsRecommendedType) {
+    await confirmDefaultAccountIsTarget(accountConfig, hasPublicApps);
+    targetProjectAccountId = hasPublicApps
+      ? accountConfig.parentAccountId
+      : accountId;
+    targetTestingAccountId = accountId;
+  } else if (!targetProjectAccountId && hasPublicApps) {
+    checkIfAppDeveloperAccount(accountConfig);
+  }
 
+  if (!targetProjectAccountId) {
     const {
-      targetAccountId: promptTargetAccountId,
-      createNewSandbox: promptCreateNewSandbox,
-    } = await selectTargetAccountPrompt(accounts, accountConfig);
+      targetAccountId,
+      parentAccountId,
+      createNestedAccount,
+      notInConfigAccount,
+    } = await suggestRecommendedNestedAccount(
+      accounts,
+      accountConfig,
+      hasPublicApps
+    );
+
+    targetProjectAccountId = hasPublicApps ? parentAccountId : targetAccountId;
+    targetTestingAccountId = targetAccountId;
 
-    targetAccountId = promptTargetAccountId;
-    createNewSandbox = promptCreateNewSandbox;
+    // Only used for developer test accounts that are not yet in the config
+    if (notInConfigAccount) {
+      await useExistingDevTestAccount(env, notInConfigAccount);
+    }
+
+    createNewSandbox = isStandardAccount(accountConfig) && createNestedAccount;
+    createNewDeveloperTestAccount =
+      isAppDeveloperAccount(accountConfig) && createNestedAccount;
   }
 
   if (createNewSandbox) {
-    try {
-      await validateSandboxUsageLimits(
-        accountConfig,
-        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-        env
-      );
-    } catch (err) {
-      if (isMissingScopeError(err)) {
-        logger.error(
-          i18n('cli.lib.sandbox.create.failure.scopes.message', {
-            accountName: accountConfig.name || accountId,
-          })
-        );
-        const websiteOrigin = getHubSpotWebsiteOrigin(env);
-        const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-        logger.info(
-          i18n('cli.lib.sandbox.create.failure.scopes.instructions', {
-            accountName: accountConfig.name || accountId,
-            url,
-          })
-        );
-      } else {
-        logErrorInstance(err);
-      }
-      process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-      const { name } = await sandboxNamePrompt(
-        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX
-      );
-
-      trackCommandMetadataUsage(
-        'sandbox-create',
-        { step: 'project-dev' },
-        accountId
-      );
-
-      const { result } = await buildSandbox({
-        name,
-        type: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-        accountConfig,
-        env,
-      });
-
-      targetAccountId = result.sandbox.sandboxHubId;
-
-      const sandboxAccountConfig = getAccountConfig(
-        result.sandbox.sandboxHubId
-      );
-      const syncTasks = await getAvailableSyncTypes(
-        accountConfig,
-        sandboxAccountConfig
-      );
-      await syncSandbox({
-        accountConfig: sandboxAccountConfig,
-        parentAccountConfig: accountConfig,
-        env,
-        syncTasks,
-        allowEarlyTermination: false, // Don't let user terminate early in this flow
-        skipPolling: true, // Skip polling, sync will run and complete in the background
-      });
-    } catch (err) {
-      logErrorInstance(err);
-      process.exit(EXIT_CODES.ERROR);
-    }
+    targetProjectAccountId = await createSandboxForLocalDev(
+      accountId,
+      accountConfig,
+      env
+    );
+    // We will be running our tests against this new sandbox account
+    targetTestingAccountId = targetProjectAccountId;
+  }
+  if (createNewDeveloperTestAccount) {
+    targetTestingAccountId = await createDeveloperTestAccountForLocalDev(
+      accountId,
+      accountConfig,
+      env
+    );
+    targetProjectAccountId = accountId;
   }
 
-  logger.log();
   const projectExists = await ensureProjectExists(
-    targetAccountId,
+    targetProjectAccountId,
     projectConfig.name,
     {
       allowCreate: false,
@@ -230,7 +171,10 @@ exports.handler = async options => {
   let isGithubLinked;
 
   if (projectExists) {
-    const project = await fetchProject(targetAccountId, projectConfig.name);
+    const project = await fetchProject(
+      targetProjectAccountId,
+      projectConfig.name
+    );
     deployedBuild = project.deployedBuild;
     isGithubLinked =
       project.sourceIntegration &&
@@ -240,114 +184,18 @@ exports.handler = async options => {
   SpinniesManager.init();
 
   if (!projectExists) {
-    // Create the project without prompting if this is a newly created sandbox
-    let shouldCreateProject = createNewSandbox;
-
-    if (!shouldCreateProject) {
-      logger.log();
-      uiLine();
-      logger.warn(
-        i18n(`${i18nKey}.logs.projectMustExistExplanation`, {
-          accountIdentifier: uiAccountDescription(targetAccountId),
-          projectName: projectConfig.name,
-        })
-      );
-      uiLine();
-
-      shouldCreateProject = await confirmPrompt(
-        i18n(`${i18nKey}.prompt.createProject`, {
-          accountIdentifier: uiAccountDescription(targetAccountId),
-          projectName: projectConfig.name,
-        })
-      );
-    }
-
-    if (shouldCreateProject) {
-      SpinniesManager.add('createProject', {
-        text: i18n(`${i18nKey}.status.creatingProject`, {
-          accountIdentifier: uiAccountDescription(targetAccountId),
-          projectName: projectConfig.name,
-        }),
-      });
-
-      try {
-        await createProject(targetAccountId, projectConfig.name);
-        SpinniesManager.succeed('createProject', {
-          text: i18n(`${i18nKey}.status.createdProject`, {
-            accountIdentifier: uiAccountDescription(targetAccountId),
-            projectName: projectConfig.name,
-          }),
-          succeedColor: 'white',
-        });
-      } catch (err) {
-        SpinniesManager.fail('createProject');
-        logger.log(i18n(`${i18nKey}.status.failedToCreateProject`));
-        process.exit(EXIT_CODES.ERROR);
-      }
-    } else {
-      // We cannot continue if the project does not exist in the target account
-      logger.log();
-      logger.log(i18n(`${i18nKey}.logs.choseNotToCreateProject`));
-      process.exit(EXIT_CODES.SUCCESS);
-    }
-  }
-
-  let initialUploadResult;
+    await createNewProjectForLocalDev(
+      projectConfig,
+      targetProjectAccountId,
+      createNewSandbox,
+      hasPublicApps
+    );
 
-  // Create an initial build if the project was newly created in the account
-  if (!projectExists) {
-    initialUploadResult = await handleProjectUpload(
-      targetAccountId,
+    deployedBuild = await createInitialBuildForNewProject(
       projectConfig,
       projectDir,
-      (...args) => pollProjectBuildAndDeploy(...args, true),
-      i18n(`${i18nKey}.logs.initialUploadMessage`)
+      targetProjectAccountId
     );
-
-    if (initialUploadResult.uploadError) {
-      if (
-        isSpecifiedError(initialUploadResult.uploadError, {
-          subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
-        })
-      ) {
-        logger.log();
-        logger.error(i18n(`${i18nKey}.errors.projectLockedError`));
-        logger.log();
-      } else {
-        logApiErrorInstance(
-          initialUploadResult.uploadError,
-          new ApiErrorContext({
-            accountId,
-            projectName: projectConfig.name,
-          })
-        );
-      }
-      process.exit(EXIT_CODES.ERROR);
-    }
-
-    if (!initialUploadResult.succeeded) {
-      let subTasks = [];
-
-      if (initialUploadResult.buildResult.status === 'FAILURE') {
-        subTasks =
-          initialUploadResult.buildResult[PROJECT_BUILD_TEXT.SUBTASK_KEY];
-      } else if (initialUploadResult.deployResult.status === 'FAILURE') {
-        subTasks =
-          initialUploadResult.deployResult[PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
-      }
-
-      const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
-
-      logger.log();
-      failedSubTasks.forEach(failedSubTask => {
-        console.error(failedSubTask.errorMessage);
-      });
-      logger.log();
-
-      process.exit(EXIT_CODES.ERROR);
-    }
-
-    deployedBuild = initialUploadResult.buildResult;
   }
 
   const LocalDev = new LocalDevManager({
@@ -355,8 +203,9 @@ exports.handler = async options => {
     deployedBuild,
     projectConfig,
     projectDir,
-    targetAccountId,
+    targetAccountId: targetTestingAccountId,
     isGithubLinked,
+    components,
   });
 
   await LocalDev.start();

package/commands/project/upload.js

@@ -16,6 +16,7 @@ const {
   logFeedbackMessage,
   validateProjectConfig,
   pollProjectBuildAndDeploy,
+  displayWarnLogs,
 } = require('../../lib/projects');
 const { i18n } = require('../../lib/lang');
 const { getAccountConfig } = require('@hubspot/local-dev-lib/config');
@@ -91,6 +92,8 @@ exports.handler = async options => {
       );
       uiLine();
       logFeedbackMessage(result.buildId);
+
+      displayWarnLogs(accountId, projectConfig.name, result.buildId);
       process.exit(EXIT_CODES.SUCCESS);
     }
   } catch (e) {

package/commands/sandbox/sync.js

@@ -14,12 +14,14 @@ const { getAccountConfig, getEnv } = require('@hubspot/local-dev-lib/config');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
 const { promptUser } = require('../../lib/prompts/promptUtils');
 const { uiLine, uiAccountDescription } = require('../../lib/ui');
+const {
+  isSandbox,
+  isStandardSandbox,
+  isDevelopmentSandbox,
+} = require('../../lib/accountTypes');
 const {
   getAvailableSyncTypes,
   getSyncTypesWithContactRecordsPrompt,
-  isDevelopmentSandbox,
-  isStandardSandbox,
-  isSandbox,
 } = require('../../lib/sandboxes');
 const { syncSandbox } = require('../../lib/sandboxSync');
 const { getValidEnv } = require('@hubspot/local-dev-lib/environment');

package/commands/theme/preview.js

@@ -12,19 +12,28 @@ const { preview } = require('@hubspot/theme-preview-dev-server');
 const { getUploadableFileList } = require('../../lib/upload');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
-const { previewPrompt } = require('../../lib/prompts/previewPrompt');
+const {
+  previewPrompt,
+  previewProjectPrompt,
+} = require('../../lib/prompts/previewPrompt');
 const { EXIT_CODES } = require('../../lib/enums/exitCodes');
 const {
   FILE_UPLOAD_RESULT_TYPES,
 } = require('@hubspot/local-dev-lib/constants/files');
-const i18nKey = 'cli.commands.preview';
 const cliProgress = require('cli-progress');
 const {
   ApiErrorContext,
   logApiUploadErrorInstance,
 } = require('../../lib/errorHandlers/apiErrors');
 const { handleExit, handleKeypress } = require('../../lib/process');
+const { getThemeJSONPath } = require('@hubspot/local-dev-lib/cms/themes');
+const { getProjectConfig } = require('../../lib/projects');
+const {
+  findProjectComponents,
+  COMPONENT_TYPES,
+} = require('../../lib/projectStructure');
 
+const i18nKey = 'cli.commands.preview';
 exports.command = 'preview [--src] [--dest]';
 exports.describe = false; // i18n(`${i18nKey}.describe`) - Hiding command
 
@@ -63,6 +72,42 @@ const handleUserInput = () => {
   });
 };
 
+const determineSrcAndDest = async options => {
+  let absoluteSrc;
+  let dest;
+  const { projectDir, projectConfig } = await getProjectConfig();
+  if (!(projectDir && projectConfig)) {
+    // Not in a project, prompt for src and dest of traditional theme
+    const previewPromptAnswers = await previewPrompt(options);
+    const src = options.src || previewPromptAnswers.src;
+    dest = options.dest || previewPromptAnswers.dest;
+    absoluteSrc = path.resolve(getCwd(), src);
+    if (!dest || !validateSrcPath(absoluteSrc)) {
+      process.exit(EXIT_CODES.ERROR);
+    }
+  } else {
+    // In a project
+    let themeJsonPath = getThemeJSONPath();
+    if (!themeJsonPath) {
+      const projectComponents = await findProjectComponents(projectDir);
+      const themeComponents = projectComponents.filter(
+        c => c.type === COMPONENT_TYPES.hublTheme
+      );
+      if (themeComponents.length === 0) {
+        logger.error(i18n(`${i18nKey}.errors.noThemeComponents`));
+        process.exit(EXIT_CODES.ERROR);
+      }
+      const answer = await previewProjectPrompt(themeComponents);
+      themeJsonPath = `${answer.themeComponentPath}/theme.json`;
+    }
+    const { dir: themeDir } = path.parse(themeJsonPath);
+    absoluteSrc = themeDir;
+    const { base: themeName } = path.parse(themeDir);
+    dest = `@projects/${projectConfig.name}/${themeName}`;
+  }
+  return { absoluteSrc, dest };
+};
+
 exports.handler = async options => {
   const { notify, skipUpload, noSsl, port, debug } = options;
 
@@ -70,18 +115,7 @@ exports.handler = async options => {
 
   const accountId = getAccountId(options);
 
-  const previewPromptAnswers = await previewPrompt(options);
-  const src = options.src || previewPromptAnswers.src;
-  let dest = options.dest || previewPromptAnswers.dest;
-  if (!dest) {
-    logger.error(i18n(`${i18nKey}.errors.destinationRequired`));
-    return;
-  }
-
-  const absoluteSrc = path.resolve(getCwd(), src);
-  if (!validateSrcPath(absoluteSrc)) {
-    process.exit(EXIT_CODES.ERROR);
-  }
+  const { absoluteSrc, dest } = await determineSrcAndDest(options);
 
   const filePaths = await getUploadableFileList(absoluteSrc, false);