@hubspot/cli 7.1.1 → 7.2.0-beta.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/deprecatedFlow.d.ts

@@ -0,0 +1,5 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { ProjectConfig } from '../../../types/Projects';
+import { ProjectDevArgs } from '../../../types/Yargs';
+export declare function deprecatedProjectDevFlow(args: ArgumentsCamelCase<ProjectDevArgs>, accountConfig: CLIAccount, projectConfig: ProjectConfig, projectDir: string): Promise<void>;

package/commands/project/dev/deprecatedFlow.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecatedProjectDevFlow = deprecatedProjectDevFlow;
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const environment_1 = require("@hubspot/local-dev-lib/environment");
+const structure_1 = require("../../../lib/projects/structure");
+const Projects_1 = require("../../../types/Projects");
+const lang_1 = require("../../../lib/lang");
+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 localDev_1 = require("../../../lib/localDev");
+const process_1 = require("../../../lib/process");
+const accountTypes_1 = require("../../../lib/accountTypes");
+const projects_1 = require("../../../lib/projects");
+const i18nKey = 'commands.project.subcommands.dev';
+async function deprecatedProjectDevFlow(args, accountConfig, projectConfig, projectDir) {
+    const { providedAccountId, derivedAccountId } = args;
+    const env = (0, environment_1.getValidEnv)((0, config_1.getEnv)(derivedAccountId));
+    const components = await (0, structure_1.findProjectComponents)(projectDir);
+    const runnableComponents = components.filter(component => component.runnable);
+    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_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noRunnableComponents`, {
+            projectDir,
+            command: (0, ui_1.uiCommandReference)('hs project add'),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    else if (hasPrivateApps && hasPublicApps) {
+        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 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;
+    // The account that we are locally testing against
+    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) {
+        (0, localDev_1.checkIfAccountFlagIsSupported)(accountConfig, hasPublicApps);
+        if (hasPublicApps) {
+            targetProjectAccountId = accountConfig.parentAccountId || null;
+        }
+    }
+    else {
+        (0, localDev_1.checkIfDefaultAccountIsSupported)(accountConfig, hasPublicApps);
+    }
+    // The user is targeting an account type that we recommend developing on
+    if (!targetProjectAccountId && defaultAccountIsRecommendedType) {
+        targetTestingAccountId = derivedAccountId;
+        await (0, localDev_1.confirmDefaultAccountIsTarget)(accountConfig);
+        if (hasPublicApps) {
+            (0, localDev_1.checkIfParentAccountIsAuthed)(accountConfig);
+            targetProjectAccountId = accountConfig.parentAccountId || null;
+        }
+        else {
+            targetProjectAccountId = derivedAccountId;
+        }
+    }
+    let createNewSandbox = false;
+    let createNewDeveloperTestAccount = false;
+    if (!targetProjectAccountId) {
+        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 (0, localDev_1.useExistingDevTestAccount)(env, notInConfigAccount);
+        }
+        createNewSandbox = (0, accountTypes_1.isStandardAccount)(accountConfig) && createNestedAccount;
+        createNewDeveloperTestAccount =
+            (0, accountTypes_1.isAppDeveloperAccount)(accountConfig) && createNestedAccount;
+    }
+    if (createNewSandbox) {
+        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 (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 (0, projects_1.ensureProjectExists)(targetProjectAccountId, projectConfig.name, {
+        allowCreate: false,
+        noLogs: true,
+        withPolling: createNewSandbox,
+    });
+    let deployedBuild;
+    let isGithubLinked = false;
+    SpinniesManager_1.default.init();
+    if (projectExists && project) {
+        deployedBuild = project.deployedBuild;
+        isGithubLinked = Boolean(project.sourceIntegration && project.sourceIntegration.source === 'GITHUB');
+    }
+    else {
+        project = await (0, localDev_1.createNewProjectForLocalDev)(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
+        deployedBuild = await (0, localDev_1.createInitialBuildForNewProject)(projectConfig, projectDir, targetProjectAccountId);
+    }
+    const LocalDev = new LocalDevManager_1.default({
+        runnableComponents,
+        debug: args.debug,
+        deployedBuild,
+        isGithubLinked,
+        parentAccountId: targetProjectAccountId,
+        projectConfig,
+        projectDir,
+        projectId: project.id,
+        targetAccountId: targetTestingAccountId,
+        env,
+    });
+    await LocalDev.start();
+    (0, process_1.handleExit)(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
+}

package/commands/project/dev/index.d.ts

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

package/commands/project/dev/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 deprecatedFlow_1 = require("./deprecatedFlow");
+const unifiedFlow_1 = require("./unifiedFlow");
+const buildAndDeploy_1 = require("../../../lib/projects/buildAndDeploy");
+const i18nKey = 'commands.project.subcommands.dev';
+exports.command = 'dev';
+exports.describe = (0, ui_1.uiBetaTag)((0, lang_1.i18n)(`${i18nKey}.describe`), false);
+async function handler(args) {
+    const { derivedAccountId } = args;
+    const accountConfig = (0, config_1.getAccountConfig)(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);
+    }
+    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);
+    if ((0, buildAndDeploy_1.useV3Api)(projectConfig?.platformVersion)) {
+        await (0, unifiedFlow_1.unifiedProjectDevFlow)(args, accountConfig, projectConfig, projectDir);
+    }
+    else {
+        await (0, deprecatedFlow_1.deprecatedProjectDevFlow)(args, accountConfig, projectConfig, projectDir);
+    }
+}
+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/dev/unifiedFlow.d.ts

@@ -0,0 +1,5 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { ProjectDevArgs } from '../../../types/Yargs';
+import { ProjectConfig } from '../../../types/Projects';
+export declare function unifiedProjectDevFlow(args: ArgumentsCamelCase<ProjectDevArgs>, accountConfig: CLIAccount, projectConfig: ProjectConfig, projectDir: string): Promise<void>;

package/commands/project/dev/unifiedFlow.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unifiedProjectDevFlow = unifiedProjectDevFlow;
+const path_1 = __importDefault(require("path"));
+const util_1 = __importDefault(require("util"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const errors_1 = require("@hubspot/project-parsing-lib/src/lib/errors");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const environment_1 = require("@hubspot/local-dev-lib/environment");
+const errorHandlers_1 = require("../../../lib/errorHandlers");
+const exitCodes_1 = require("../../../lib/enums/exitCodes");
+const projects_1 = require("../../../lib/projects");
+const localDev_1 = require("../../../lib/localDev");
+const projectDevTargetAccountPrompt_1 = require("../../../lib/prompts/projectDevTargetAccountPrompt");
+const SpinniesManager_1 = __importDefault(require("../../../lib/ui/SpinniesManager"));
+const LocalDevManagerV2_1 = __importDefault(require("../../../lib/LocalDevManagerV2"));
+const process_1 = require("../../../lib/process");
+const accountTypes_1 = require("../../../lib/accountTypes");
+const ui_1 = require("../../../lib/ui");
+const lang_1 = require("../../../lib/lang");
+const i18nKey = 'commands.project.subcommands.dev';
+async function unifiedProjectDevFlow(args, accountConfig, projectConfig, projectDir) {
+    logger_1.logger.log('Unified Apps Local Dev');
+    const targetProjectAccountId = args.derivedAccountId;
+    const env = (0, environment_1.getValidEnv)((0, config_1.getEnv)(targetProjectAccountId));
+    let projectNodes;
+    // Get IR
+    try {
+        const intermediateRepresentation = await (0, project_parsing_lib_1.translateForLocalDev)({
+            projectSourceDir: path_1.default.join(projectDir, projectConfig.srcDir),
+            platformVersion: projectConfig.platformVersion,
+            accountId: targetProjectAccountId,
+        });
+        projectNodes = intermediateRepresentation.intermediateNodesIndexedByUid;
+        logger_1.logger.debug(util_1.default.inspect(projectNodes, false, null, true));
+    }
+    catch (e) {
+        if ((0, errors_1.isTranslationError)(e)) {
+            logger_1.logger.error(e.toString());
+        }
+        else {
+            (0, errorHandlers_1.logError)(e);
+        }
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    // @TODO Do we need to do more than this or leave it to the dev servers?
+    if (!Object.keys(projectNodes).length) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noRunnableComponents`, {
+            projectDir,
+            command: (0, ui_1.uiCommandReference)('hs project add'),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    // @TODO Validate component types (i.e. previously you could not have both private and public apps)
+    const accounts = (0, config_1.getConfigAccounts)();
+    // TODO Ideally this should require the user to target a Combined account
+    // For now, check if the account is either developer or standard
+    const derivedAccountIsRecommendedType = (0, accountTypes_1.isAppDeveloperAccount)(accountConfig) || (0, accountTypes_1.isStandardAccount)(accountConfig);
+    if (!derivedAccountIsRecommendedType) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.invalidUnifiedAppsAccount`), {
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+        });
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    let targetTestingAccountId = null;
+    const devAccountPromptResponse = await (0, projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt)(accounts, accountConfig);
+    targetTestingAccountId = devAccountPromptResponse.targetAccountId;
+    if (!!devAccountPromptResponse.notInConfigAccount) {
+        // When the developer test account isn't configured in the CLI config yet
+        // Walk the user through adding the account's PAK to the config
+        await (0, localDev_1.useExistingDevTestAccount)(env, devAccountPromptResponse.notInConfigAccount);
+    }
+    else if (devAccountPromptResponse.createNestedAccount) {
+        // Create a new developer test account and automatically add it to the CLI config
+        targetTestingAccountId = await (0, localDev_1.createDeveloperTestAccountForLocalDev)(targetProjectAccountId, accountConfig, env);
+    }
+    // Check if project exists in HubSpot
+    const { projectExists, project: uploadedProject } = await (0, projects_1.ensureProjectExists)(targetProjectAccountId, projectConfig.name, {
+        allowCreate: false,
+        noLogs: true,
+    });
+    let deployedBuild;
+    let isGithubLinked = false;
+    let project = uploadedProject;
+    SpinniesManager_1.default.init();
+    if (projectExists && project) {
+        deployedBuild = project.deployedBuild;
+        isGithubLinked = Boolean(project.sourceIntegration && project.sourceIntegration.source === 'GITHUB');
+    }
+    else {
+        project = await (0, localDev_1.createNewProjectForLocalDev)(projectConfig, targetProjectAccountId, false, false);
+        deployedBuild = await (0, localDev_1.createInitialBuildForNewProject)(projectConfig, projectDir, targetProjectAccountId, true);
+    }
+    const LocalDev = new LocalDevManagerV2_1.default({
+        projectNodes,
+        debug: args.debug,
+        deployedBuild,
+        isGithubLinked,
+        targetProjectAccountId,
+        targetTestingAccountId: targetTestingAccountId,
+        projectConfig,
+        projectDir,
+        projectId: project.id,
+        env,
+    });
+    await LocalDev.start();
+    (0, process_1.handleExit)(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
+}

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 {};