@hubspot/cli 7.1.1 → 7.2.0-experimental.0

package/commands/project/add.js

@@ -1,42 +1,88 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
+const path = require('path');
 const { logger } = require('@hubspot/local-dev-lib/logger');
-const { logError } = require('../../lib/errorHandlers/index');
-const { fetchReleaseData } = require('@hubspot/local-dev-lib/github');
+const { cloneGithubRepo, fetchReleaseData, } = require('@hubspot/local-dev-lib/github');
+const { debugError } = require('../../lib/errorHandlers');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { i18n } = require('../../lib/lang');
 const { projectAddPrompt } = require('../../lib/prompts/projectAddPrompt');
-const { createProjectComponent, getProjectComponentsByVersion, } = require('../../lib/projects');
+const { getProjectConfig } = require('../../lib/projects');
+const { getProjectComponentListFromRepo, } = require('../../lib/projects/create');
+const { findProjectComponents } = require('../../lib/projects/structure');
+const { ComponentTypes } = require('../../types/Projects');
 const { uiBetaTag } = require('../../lib/ui');
 const { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } = require('../../lib/constants');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
 const i18nKey = 'commands.project.subcommands.add';
 exports.command = 'add';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     const { derivedAccountId } = options;
+    trackCommandUsage('project-add', null, derivedAccountId);
+    const { projectConfig, projectDir } = await getProjectConfig();
+    if (!projectDir || !projectConfig) {
+        logger.error(i18n(`${i18nKey}.error.locationInProject`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // We currently only support adding private apps to projects
+    let projectContainsPublicApp = false;
+    try {
+        const components = await findProjectComponents(projectDir);
+        projectContainsPublicApp = components.some(c => c.type === ComponentTypes.PublicApp);
+    }
+    catch (err) {
+        debugError(err);
+    }
+    if (projectContainsPublicApp) {
+        logger.error(i18n(`${i18nKey}.error.projectContainsPublicApp`));
+        process.exit(EXIT_CODES.ERROR);
+    }
     logger.log('');
-    logger.log(i18n(`${i18nKey}.creatingComponent.message`));
+    logger.log(i18n(`${i18nKey}.creatingComponent`, {
+        projectName: projectConfig.name,
+    }));
     logger.log('');
-    const releaseData = await fetchReleaseData(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH);
-    const projectComponentsVersion = releaseData.tag_name;
-    const components = await getProjectComponentsByVersion(projectComponentsVersion);
-    let { component, name } = await projectAddPrompt(components, options);
-    name = name || options.name;
-    if (!component) {
-        component = components.find(t => t.path === options.type);
+    let latestRepoReleaseTag;
+    try {
+        // We want the tag_name from the latest release of the components repo
+        const repoReleaseData = await fetchReleaseData(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH);
+        if (repoReleaseData) {
+            latestRepoReleaseTag = repoReleaseData.tag_name;
+        }
     }
-    trackCommandUsage('project-add', null, derivedAccountId);
+    catch (err) {
+        debugError(err);
+    }
+    if (!latestRepoReleaseTag) {
+        logger.error(i18n(`${i18nKey}.error.failedToFetchComponentList`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const components = await getProjectComponentListFromRepo(latestRepoReleaseTag);
+    if (!components.length) {
+        logger.error(i18n(`${i18nKey}.error.failedToFetchComponentList`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const projectAddPromptResponse = await projectAddPrompt(components, options);
     try {
-        await createProjectComponent(component, name, projectComponentsVersion);
+        const componentPath = path.join(projectDir, projectConfig.srcDir, projectAddPromptResponse.componentTemplate.insertPath, projectAddPromptResponse.name);
+        await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {
+            sourceDir: projectAddPromptResponse.componentTemplate.path,
+            tag: latestRepoReleaseTag,
+            hideLogs: true,
+        });
         logger.log('');
-        logger.log(i18n(`${i18nKey}.success.message`, {
-            componentName: name,
+        logger.success(i18n(`${i18nKey}.success`, {
+            componentName: projectAddPromptResponse.name,
         }));
     }
     catch (error) {
-        logError(error);
+        debugError(error);
+        logger.error(i18n(`${i18nKey}.error.failedToDownloadComponent`));
+        process.exit(EXIT_CODES.ERROR);
     }
+    process.exit(EXIT_CODES.SUCCESS);
 };
 exports.builder = yargs => {
     yargs.options({

package/commands/project/cloneApp.js

@@ -53,9 +53,9 @@ exports.handler = async (options) => {
             });
             appId = appIdResponse.appId;
         }
-        const { name, dest } = await createProjectPrompt('', options, true);
-        projectName = name;
-        projectDest = options.dest || dest;
+        const createProjectPromptResponse = await createProjectPrompt(options);
+        projectName = createProjectPromptResponse.name;
+        projectDest = createProjectPromptResponse.dest;
     }
     catch (error) {
         logError(error, new ApiErrorContext({ accountId: derivedAccountId }));

package/commands/project/create.js

@@ -1,32 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
-const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
-const { trackCommandUsage } = require('../../lib/usageTracking');
-const { getCwd } = require('@hubspot/local-dev-lib/path');
 const path = require('path');
+const fs = require('fs-extra');
 const chalk = require('chalk');
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const { fetchReleaseData, cloneGithubRepo, } = require('@hubspot/local-dev-lib/github');
+const { getCwd } = require('@hubspot/local-dev-lib/path');
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
+const { trackCommandUsage } = require('../../lib/usageTracking');
 const { createProjectPrompt, } = require('../../lib/prompts/createProjectPrompt');
-const { createProjectConfig } = require('../../lib/projects');
+const { writeProjectConfig, getProjectConfig } = require('../../lib/projects');
+const { getProjectTemplateListFromRepo, EMPTY_PROJECT_TEMPLATE_NAME, } = require('../../lib/projects/create');
 const { i18n } = require('../../lib/lang');
 const { uiBetaTag, uiFeatureHighlight } = require('../../lib/ui');
-const { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } = require('../../lib/constants');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { fetchReleaseData } = require('@hubspot/local-dev-lib/github');
+const { debugError } = require('../../lib/errorHandlers');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+const { PROJECT_CONFIG_FILE, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } = require('../../lib/constants');
 const i18nKey = 'commands.project.subcommands.create';
 exports.command = 'create';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     const { derivedAccountId } = options;
-    const hasCustomTemplateSource = Boolean(options.templateSource);
-    let githubRef = '';
-    if (!hasCustomTemplateSource) {
-        const releaseData = await fetchReleaseData(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH);
-        githubRef = releaseData.tag_name;
+    let latestRepoReleaseTag;
+    let templateSource = options.templateSource;
+    if (!templateSource) {
+        templateSource = HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+        try {
+            const releaseData = await fetchReleaseData(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH);
+            if (releaseData) {
+                latestRepoReleaseTag = releaseData.tag_name;
+            }
+        }
+        catch (err) {
+            logger.error(i18n(`${i18nKey}.error.failedToFetchProjectList`));
+            process.exit(EXIT_CODES.ERROR);
+        }
     }
-    const { name, template, dest } = await createProjectPrompt(githubRef, options);
-    trackCommandUsage('project-create', { type: template.name }, derivedAccountId);
-    await createProjectConfig(path.resolve(getCwd(), options.dest || dest), options.name || name, template, options.templateSource, githubRef);
+    const projectTemplates = await getProjectTemplateListFromRepo(templateSource, latestRepoReleaseTag || DEFAULT_PROJECT_TEMPLATE_BRANCH);
+    if (!projectTemplates.length) {
+        logger.error(i18n(`${i18nKey}.error.failedToFetchProjectList`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const createProjectPromptResponse = await createProjectPrompt(options, projectTemplates);
+    const projectDest = path.resolve(getCwd(), createProjectPromptResponse.dest);
+    trackCommandUsage('project-create', { type: createProjectPromptResponse.projectTemplate.name }, derivedAccountId);
+    const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDest);
+    // Exit if the target destination is within an existing project
+    if (existingProjectConfig && projectDest.startsWith(existingProjectDir)) {
+        logger.error(i18n(`${i18nKey}.errors.cannotNestProjects`, {
+            projectDir: existingProjectDir,
+        }));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        await cloneGithubRepo(templateSource, projectDest, {
+            sourceDir: createProjectPromptResponse.projectTemplate.path,
+            tag: latestRepoReleaseTag,
+            hideLogs: true,
+        });
+    }
+    catch (err) {
+        debugError(err);
+        logger.error(i18n(`${i18nKey}.errors.failedToDownloadProject`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const projectConfigPath = path.join(projectDest, PROJECT_CONFIG_FILE);
+    const parsedConfigFile = JSON.parse(fs.readFileSync(projectConfigPath).toString());
+    writeProjectConfig(projectConfigPath, {
+        ...parsedConfigFile,
+        name: createProjectPromptResponse.name,
+    });
+    // If the template is 'no-template', we need to manually create a src directory
+    if (createProjectPromptResponse.projectTemplate.name ===
+        EMPTY_PROJECT_TEMPLATE_NAME) {
+        fs.ensureDirSync(path.join(projectDest, 'src'));
+    }
+    logger.log('');
+    logger.success(i18n(`${i18nKey}.logs.success`, {
+        projectName: createProjectPromptResponse.name,
+        projectDest,
+    }));
     logger.log('');
     logger.log(chalk.bold(i18n(`${i18nKey}.logs.welcomeMessage`)));
     uiFeatureHighlight([
@@ -35,6 +89,7 @@ exports.handler = async (options) => {
         'feedbackCommand',
         'sampleProjects',
     ]);
+    process.exit(EXIT_CODES.SUCCESS);
 };
 exports.builder = yargs => {
     yargs.options({

package/commands/project/dev.d.ts

@@ -1 +1,8 @@
+import { ArgumentsCamelCase, Argv } from 'yargs';
+import { CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs';
+export declare const command = "dev";
+export declare const describe: string | undefined;
+type ProjectDevArgs = CommonArgs & ConfigArgs & EnvironmentArgs;
+export declare function handler(args: ArgumentsCamelCase<ProjectDevArgs>): Promise<void>;
+export declare function builder(yargs: Argv): Argv<ProjectDevArgs>;
 export {};

package/commands/project/dev.js

@@ -1,57 +1,75 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } = require('../../lib/commonOpts');
-const { trackCommandUsage } = require('../../lib/usageTracking');
-const { handleExit } = require('../../lib/process');
-const { i18n } = require('../../lib/lang');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { getConfigAccounts, getAccountConfig, getEnv, } = require('@hubspot/local-dev-lib/config');
-const { getProjectConfig, ensureProjectExists, validateProjectConfig, } = require('../../lib/projects');
-const { EXIT_CODES } = require('../../lib/enums/exitCodes');
-const { uiBetaTag, uiCommandReference, uiLink } = require('../../lib/ui');
-const SpinniesManager = require('../../lib/ui/SpinniesManager');
-const LocalDevManager = require('../../lib/LocalDevManager');
-const { isSandbox, isDeveloperTestAccount, isStandardAccount, isAppDeveloperAccount, } = require('../../lib/accountTypes');
-const { getValidEnv } = require('@hubspot/local-dev-lib/environment');
-const { ComponentTypes } = require('../../types/Projects');
-const { findProjectComponents, getProjectComponentTypes, } = require('../../lib/projects/structure');
-const { confirmDefaultAccountIsTarget, suggestRecommendedNestedAccount, checkIfDefaultAccountIsSupported, createSandboxForLocalDev, createDeveloperTestAccountForLocalDev, createNewProjectForLocalDev, createInitialBuildForNewProject, useExistingDevTestAccount, checkIfAccountFlagIsSupported, checkIfParentAccountIsAuthed, } = require('../../lib/localDev');
+exports.describe = exports.command = void 0;
+exports.handler = handler;
+exports.builder = builder;
+const commonOpts_1 = require("../../lib/commonOpts");
+const usageTracking_1 = require("../../lib/usageTracking");
+const process_1 = require("../../lib/process");
+const lang_1 = require("../../lib/lang");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const projects_1 = require("../../lib/projects");
+const exitCodes_1 = require("../../lib/enums/exitCodes");
+const ui_1 = require("../../lib/ui");
+const SpinniesManager_1 = __importDefault(require("../../lib/ui/SpinniesManager"));
+const LocalDevManager_1 = __importDefault(require("../../lib/LocalDevManager"));
+const accountTypes_1 = require("../../lib/accountTypes");
+const environment_1 = require("@hubspot/local-dev-lib/environment");
+const Projects_1 = require("../../types/Projects");
+const structure_1 = require("../../lib/projects/structure");
+const localDev_1 = require("../../lib/localDev");
 const i18nKey = 'commands.project.subcommands.dev';
 exports.command = 'dev';
-exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
-exports.handler = async (options) => {
-    const { derivedAccountId, providedAccountId } = options;
-    const accountConfig = getAccountConfig(derivedAccountId);
-    const env = getValidEnv(getEnv(derivedAccountId));
-    trackCommandUsage('project-dev', null, derivedAccountId);
-    const { projectConfig, projectDir } = await getProjectConfig();
-    uiBetaTag(i18n(`${i18nKey}.logs.betaMessage`));
-    logger.log(uiLink(i18n(`${i18nKey}.logs.learnMoreLocalDevServer`), 'https://developers.hubspot.com/docs/platform/project-cli-commands#start-a-local-development-server'));
-    if (!projectConfig) {
-        logger.error(i18n(`${i18nKey}.errors.noProjectConfig`));
-        process.exit(EXIT_CODES.ERROR);
+exports.describe = (0, ui_1.uiBetaTag)((0, lang_1.i18n)(`${i18nKey}.describe`), false);
+async function handler(args) {
+    const { derivedAccountId, providedAccountId } = args;
+    const accountConfig = (0, config_1.getAccountConfig)(derivedAccountId);
+    const env = (0, environment_1.getValidEnv)((0, config_1.getEnv)(derivedAccountId));
+    (0, usageTracking_1.trackCommandUsage)('project-dev', {}, derivedAccountId);
+    const { projectConfig, projectDir } = await (0, projects_1.getProjectConfig)();
+    (0, ui_1.uiBetaTag)((0, lang_1.i18n)(`${i18nKey}.logs.betaMessage`));
+    logger_1.logger.log((0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.logs.learnMoreLocalDevServer`), 'https://developers.hubspot.com/docs/platform/project-cli-commands#start-a-local-development-server'));
+    if (!projectConfig || !projectDir) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectConfig`, {
+            accountId: derivedAccountId,
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-    validateProjectConfig(projectConfig, projectDir);
-    const components = await findProjectComponents(projectDir);
+    if (!accountConfig) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noAccount`));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    (0, projects_1.validateProjectConfig)(projectConfig, projectDir);
+    const components = await (0, structure_1.findProjectComponents)(projectDir);
     const runnableComponents = components.filter(component => component.runnable);
-    const componentTypes = getProjectComponentTypes(runnableComponents);
-    const hasPrivateApps = !!componentTypes[ComponentTypes.PrivateApp];
-    const hasPublicApps = !!componentTypes[ComponentTypes.PublicApp];
+    const componentTypes = (0, structure_1.getProjectComponentTypes)(runnableComponents);
+    const hasPrivateApps = !!componentTypes[Projects_1.ComponentTypes.PrivateApp];
+    const hasPublicApps = !!componentTypes[Projects_1.ComponentTypes.PublicApp];
     if (runnableComponents.length === 0) {
-        logger.error(i18n(`${i18nKey}.errors.noRunnableComponents`, {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noRunnableComponents`, {
             projectDir,
-            command: uiCommandReference('hs project add'),
+            command: (0, ui_1.uiCommandReference)('hs project add'),
         }));
-        process.exit(EXIT_CODES.SUCCESS);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
     else if (hasPrivateApps && hasPublicApps) {
-        logger.error(i18n(`${i18nKey}.errors.invalidProjectComponents`));
-        process.exit(EXIT_CODES.SUCCESS);
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.invalidProjectComponents`));
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    const accounts = (0, config_1.getConfigAccounts)();
+    if (!accounts) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noAccountsInConfig`, {
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-    const accounts = getConfigAccounts();
-    const defaultAccountIsRecommendedType = isDeveloperTestAccount(accountConfig) ||
-        (!hasPublicApps && isSandbox(accountConfig));
+    const defaultAccountIsRecommendedType = (0, accountTypes_1.isDeveloperTestAccount)(accountConfig) ||
+        (!hasPublicApps && (0, accountTypes_1.isSandbox)(accountConfig));
     // targetProjectAccountId and targetTestingAccountId are set to null if --account flag is not provided.
     // By setting them to null, we can later check if they need to be assigned based on the default account configuration and the type of app.
     let targetProjectAccountId = providedAccountId ? derivedAccountId : null;
@@ -59,21 +77,21 @@ exports.handler = async (options) => {
     let targetTestingAccountId = providedAccountId ? derivedAccountId : null;
     // Check that the default account or flag option is valid for the type of app in this project
     if (providedAccountId) {
-        checkIfAccountFlagIsSupported(accountConfig, hasPublicApps);
+        (0, localDev_1.checkIfAccountFlagIsSupported)(accountConfig, hasPublicApps);
         if (hasPublicApps) {
-            targetProjectAccountId = accountConfig.parentAccountId;
+            targetProjectAccountId = accountConfig.parentAccountId || null;
         }
     }
     else {
-        checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps);
+        (0, localDev_1.checkIfDefaultAccountIsSupported)(accountConfig, hasPublicApps);
     }
     // The user is targeting an account type that we recommend developing on
     if (!targetProjectAccountId && defaultAccountIsRecommendedType) {
         targetTestingAccountId = derivedAccountId;
-        await confirmDefaultAccountIsTarget(accountConfig, hasPublicApps);
+        await (0, localDev_1.confirmDefaultAccountIsTarget)(accountConfig);
         if (hasPublicApps) {
-            checkIfParentAccountIsAuthed(accountConfig);
-            targetProjectAccountId = accountConfig.parentAccountId;
+            (0, localDev_1.checkIfParentAccountIsAuthed)(accountConfig);
+            targetProjectAccountId = accountConfig.parentAccountId || null;
         }
         else {
             targetProjectAccountId = derivedAccountId;
@@ -82,48 +100,52 @@ exports.handler = async (options) => {
     let createNewSandbox = false;
     let createNewDeveloperTestAccount = false;
     if (!targetProjectAccountId) {
-        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps);
-        targetProjectAccountId = hasPublicApps ? parentAccountId : targetAccountId;
+        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await (0, localDev_1.suggestRecommendedNestedAccount)(accounts, accountConfig, hasPublicApps);
+        targetProjectAccountId = hasPublicApps
+            ? parentAccountId || null
+            : targetAccountId;
         targetTestingAccountId = targetAccountId;
         // Only used for developer test accounts that are not yet in the config
         if (notInConfigAccount) {
-            await useExistingDevTestAccount(env, notInConfigAccount);
+            await (0, localDev_1.useExistingDevTestAccount)(env, notInConfigAccount);
         }
-        createNewSandbox = isStandardAccount(accountConfig) && createNestedAccount;
+        createNewSandbox = (0, accountTypes_1.isStandardAccount)(accountConfig) && createNestedAccount;
         createNewDeveloperTestAccount =
-            isAppDeveloperAccount(accountConfig) && createNestedAccount;
+            (0, accountTypes_1.isAppDeveloperAccount)(accountConfig) && createNestedAccount;
     }
     if (createNewSandbox) {
-        targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
+        targetProjectAccountId = await (0, localDev_1.createSandboxForLocalDev)(derivedAccountId, accountConfig, env);
         // We will be running our tests against this new sandbox account
         targetTestingAccountId = targetProjectAccountId;
     }
     if (createNewDeveloperTestAccount) {
-        targetTestingAccountId = await createDeveloperTestAccountForLocalDev(derivedAccountId, accountConfig, env);
+        targetTestingAccountId = await (0, localDev_1.createDeveloperTestAccountForLocalDev)(derivedAccountId, accountConfig, env);
         targetProjectAccountId = derivedAccountId;
     }
+    if (!targetProjectAccountId || !targetTestingAccountId) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noAccount`));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
     // eslint-disable-next-line prefer-const
-    let { projectExists, project } = await ensureProjectExists(targetProjectAccountId, projectConfig.name, {
+    let { projectExists, project } = await (0, projects_1.ensureProjectExists)(targetProjectAccountId, projectConfig.name, {
         allowCreate: false,
         noLogs: true,
         withPolling: createNewSandbox,
     });
     let deployedBuild;
-    let isGithubLinked;
-    SpinniesManager.init();
-    if (projectExists) {
+    let isGithubLinked = false;
+    SpinniesManager_1.default.init();
+    if (projectExists && project) {
         deployedBuild = project.deployedBuild;
-        isGithubLinked =
-            project.sourceIntegration &&
-                project.sourceIntegration.source === 'GITHUB';
+        isGithubLinked = Boolean(project.sourceIntegration && project.sourceIntegration.source === 'GITHUB');
     }
     else {
-        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
-        deployedBuild = await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId);
+        project = await (0, localDev_1.createNewProjectForLocalDev)(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
+        deployedBuild = await (0, localDev_1.createInitialBuildForNewProject)(projectConfig, projectDir, targetProjectAccountId);
     }
-    const LocalDev = new LocalDevManager({
+    const LocalDev = new LocalDevManager_1.default({
         runnableComponents,
-        debug: options.debug,
+        debug: args.debug,
         deployedBuild,
         isGithubLinked,
         parentAccountId: targetProjectAccountId,
@@ -134,13 +156,12 @@ exports.handler = async (options) => {
         env,
     });
     await LocalDev.start();
-    handleExit(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
-};
-exports.builder = yargs => {
-    addConfigOptions(yargs);
-    addAccountOptions(yargs);
-    addUseEnvironmentOptions(yargs);
-    addTestingOptions(yargs);
-    yargs.example([['$0 project dev', i18n(`${i18nKey}.examples.default`)]]);
+    (0, process_1.handleExit)(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
+}
+function builder(yargs) {
+    (0, commonOpts_1.addConfigOptions)(yargs);
+    (0, commonOpts_1.addAccountOptions)(yargs);
+    (0, commonOpts_1.addUseEnvironmentOptions)(yargs);
+    yargs.example([['$0 project dev', (0, lang_1.i18n)(`${i18nKey}.examples.default`)]]);
     return yargs;
-};
+}

package/commands/project/migrateApp.js

@@ -71,9 +71,9 @@ exports.handler = async (options) => {
     let projectName;
     let projectDest;
     try {
-        const { name, dest } = await createProjectPrompt('', options, true);
-        projectName = options.name || name;
-        projectDest = options.dest || dest;
+        const createProjectPromptResponse = await createProjectPrompt(options);
+        projectName = createProjectPromptResponse.name;
+        projectDest = createProjectPromptResponse.dest;
         const { projectExists } = await ensureProjectExists(derivedAccountId, projectName, {
             allowCreate: false,
             noLogs: true,

package/commands/project/upload.js

@@ -20,7 +20,7 @@ const i18nKey = 'commands.project.subcommands.upload';
 exports.command = 'upload';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
-    const { forceCreate, message, derivedAccountId } = options;
+    const { forceCreate, message, derivedAccountId, skipValidation } = options;
     const accountConfig = getAccountConfig(derivedAccountId);
     const accountType = accountConfig && accountConfig.accountType;
     const { projectConfig, projectDir } = await getProjectConfig();
@@ -31,7 +31,7 @@ exports.handler = async (options) => {
         uploadCommand: true,
     });
     try {
-        const { result, uploadError } = await handleProjectUpload(derivedAccountId, projectConfig, projectDir, pollProjectBuildAndDeploy, message, useV3Api(projectConfig?.platformVersion));
+        const { result, uploadError } = await handleProjectUpload(derivedAccountId, projectConfig, projectDir, pollProjectBuildAndDeploy, message, useV3Api(projectConfig?.platformVersion), skipValidation);
         if (uploadError) {
             if (isSpecifiedError(uploadError, {
                 subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
@@ -81,6 +81,11 @@ exports.builder = yargs => {
             type: 'string',
             default: '',
         },
+        'skip-validation': {
+            type: 'boolean',
+            hidden: true,
+            default: false,
+        },
     });
     yargs.example([['$0 project upload', i18n(`${i18nKey}.examples.default`)]]);
     addConfigOptions(yargs);

package/commands/sandbox/create.d.ts

@@ -1 +1,13 @@
+import { Argv, ArgumentsCamelCase } from 'yargs';
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, TestingArgs } from '../../types/Yargs';
+export declare const command = "create";
+export declare const describe: string | undefined;
+type CombinedArgs = ConfigArgs & AccountArgs & EnvironmentArgs & TestingArgs;
+type SandboxCreateArgs = CommonArgs & CombinedArgs & {
+    name?: string;
+    force?: boolean;
+    type?: string;
+};
+export declare function handler(args: ArgumentsCamelCase<SandboxCreateArgs>): Promise<void>;
+export declare function builder(yargs: Argv): Argv<SandboxCreateArgs>;
 export {};