@hubspot/cli 7.7.21-experimental.0 → 7.7.21-experimental.1

package/commands/project/deploy.js

@@ -1,170 +1,183 @@
-import chalk from 'chalk';
-import { deployProject, fetchProject, } from '@hubspot/local-dev-lib/api/projects';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { useV3Api } from '../../lib/projects/buildAndDeploy.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
-import { getProjectConfig } from '../../lib/projects/config.js';
-import { pollDeployStatus } from '../../lib/projects/buildAndDeploy.js';
-import { getProjectDetailUrl } from '../../lib/projects/urls.js';
-import { projectNamePrompt } from '../../lib/prompts/projectNamePrompt.js';
-import { promptUser } from '../../lib/prompts/promptUtils.js';
-import { i18n } from '../../lib/lang.js';
-import { uiBetaTag, uiLine, uiLink } from '../../lib/ui/index.js';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { uiCommandReference, uiAccountDescription, } from '../../lib/ui/index.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { loadProfile, logProfileFooter, logProfileHeader, exitIfUsingProfiles, } from '../../lib/projectProfiles.js';
-import { PROJECT_ERROR_TYPES } from '../../lib/constants.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const buildAndDeploy_1 = require("../../lib/projects/buildAndDeploy");
+const usageTracking_1 = require("../../lib/usageTracking");
+const index_2 = require("../../lib/errorHandlers/index");
+const config_2 = require("../../lib/projects/config");
+const buildAndDeploy_2 = require("../../lib/projects/buildAndDeploy");
+const projectNamePrompt_1 = require("../../lib/prompts/projectNamePrompt");
+const promptUtils_1 = require("../../lib/prompts/promptUtils");
+const ui_1 = require("../../lib/ui");
+const exitCodes_1 = require("../../lib/enums/exitCodes");
+const logger_1 = require("../../lib/ui/logger");
+const yargsUtils_1 = require("../../lib/yargsUtils");
+const projectProfiles_1 = require("../../lib/projectProfiles");
+const constants_1 = require("../../lib/constants");
+const en_1 = require("../../lang/en");
 const command = 'deploy';
-const describe = uiBetaTag(i18n(`commands.project.subcommands.deploy.describe`), false);
+const describe = (0, ui_1.uiBetaTag)(en_1.commands.project.deploy.describe, false);
 function validateBuildId(buildId, deployedBuildId, latestBuildId, projectName, accountId) {
     if (Number(buildId) > latestBuildId) {
-        return i18n(`commands.project.subcommands.deploy.errors.buildIdDoesNotExist`, {
-            buildId: buildId,
-            projectName: projectName,
-            linkToProject: uiLink(i18n(`commands.project.subcommands.deploy.errors.viewProjectsBuilds`), getProjectDetailUrl(projectName, accountId)),
-        });
+        return en_1.commands.project.deploy.errors.buildIdDoesNotExist(accountId, buildId, projectName);
     }
     if (Number(buildId) === deployedBuildId) {
-        return i18n(`commands.project.subcommands.deploy.errors.buildAlreadyDeployed`, {
-            buildId: buildId,
-            linkToProject: uiLink(i18n(`commands.project.subcommands.deploy.errors.viewProjectsBuilds`), getProjectDetailUrl(projectName, accountId)),
-        });
+        return en_1.commands.project.deploy.errors.buildAlreadyDeployed(accountId, buildId, projectName);
     }
     return true;
 }
 function logDeployErrors(errorData) {
-    logger.error(errorData.message);
+    logger_1.uiLogger.error(errorData.message);
     errorData.errors.forEach(err => {
-        if (err.subCategory === PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS) {
-            logger.log(i18n(`commands.project.subcommands.deploy.errors.deployContainsRemovals`, {
-                componentName: err.context.COMPONENT_NAME,
-                forceFlag: uiCommandReference('--force'),
-            }));
+        if (err.subCategory === constants_1.PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS) {
+            logger_1.uiLogger.log(en_1.commands.project.deploy.errors.deployContainsRemovals(err.context.COMPONENT_NAME));
         }
         else {
-            logger.log(err.message);
+            logger_1.uiLogger.log(err.message);
         }
     });
 }
 async function handler(args) {
-    const { derivedAccountId, project: projectOption, buildId: buildIdOption, force: forceOption, } = args;
-    const accountConfig = getAccountConfig(derivedAccountId);
+    const { derivedAccountId, project: projectOption, buildId: buildIdOption, force: forceOption, deployLatestBuild: deployLatestBuildOption, json: formatOutputAsJson, } = args;
+    const accountConfig = (0, config_1.getAccountConfig)(derivedAccountId);
     const accountType = accountConfig && accountConfig.accountType;
     let targetAccountId;
-    const { projectConfig, projectDir } = await getProjectConfig();
-    if (useV3Api(projectConfig?.platformVersion)) {
+    const jsonOutput = {};
+    const { projectConfig, projectDir } = await (0, config_2.getProjectConfig)();
+    if ((0, buildAndDeploy_1.useV3Api)(projectConfig?.platformVersion)) {
         if (args.profile) {
-            logProfileHeader(args.profile);
-            const profile = loadProfile(projectConfig, projectDir, args.profile);
+            (0, projectProfiles_1.logProfileHeader)(args.profile);
+            const profile = (0, projectProfiles_1.loadProfile)(projectConfig, projectDir, args.profile);
             if (!profile) {
-                uiLine();
-                process.exit(EXIT_CODES.ERROR);
+                (0, ui_1.uiLine)();
+                process.exit(exitCodes_1.EXIT_CODES.ERROR);
             }
             targetAccountId = profile.accountId;
-            logProfileFooter(profile);
+            (0, projectProfiles_1.logProfileFooter)(profile);
         }
         else {
             // A profile must be specified if this project has profiles configured
-            await exitIfUsingProfiles(projectConfig, projectDir);
+            await (0, projectProfiles_1.exitIfUsingProfiles)(projectConfig, projectDir);
         }
     }
     if (!targetAccountId) {
         targetAccountId = derivedAccountId;
     }
-    trackCommandUsage('project-deploy', accountType ? { type: accountType } : undefined, targetAccountId);
+    (0, usageTracking_1.trackCommandUsage)('project-deploy', accountType ? { type: accountType } : undefined, targetAccountId);
     let projectName = projectOption;
     if (!projectOption && projectConfig) {
         projectName = projectConfig.name;
     }
-    const namePromptResponse = await projectNamePrompt(targetAccountId, {
+    const namePromptResponse = await (0, projectNamePrompt_1.projectNamePrompt)(targetAccountId, {
         project: projectName,
     });
     projectName = namePromptResponse.projectName;
     let buildIdToDeploy = buildIdOption;
+    let deploySuccess = false;
     try {
-        const { data: { latestBuild, deployedBuildId }, } = await fetchProject(targetAccountId, projectName);
+        const { data: { latestBuild, deployedBuildId }, } = await (0, projects_1.fetchProject)(targetAccountId, projectName);
         if (!latestBuild || !latestBuild.buildId) {
-            logger.error(i18n(`commands.project.subcommands.deploy.errors.noBuilds`));
-            return process.exit(EXIT_CODES.ERROR);
+            logger_1.uiLogger.error(en_1.commands.project.deploy.errors.noBuilds);
+            return process.exit(exitCodes_1.EXIT_CODES.ERROR);
         }
         if (buildIdToDeploy) {
             const validationResult = validateBuildId(buildIdToDeploy, deployedBuildId, latestBuild.buildId, projectName, targetAccountId);
             if (validationResult !== true) {
-                logger.error(validationResult);
-                return process.exit(EXIT_CODES.ERROR);
+                logger_1.uiLogger.error(validationResult.toString());
+                return process.exit(exitCodes_1.EXIT_CODES.ERROR);
             }
         }
         else {
-            const deployBuildIdPromptResponse = await promptUser({
-                name: 'buildId',
-                message: i18n(`commands.project.subcommands.deploy.deployBuildIdPrompt`),
-                default: latestBuild.buildId === deployedBuildId
-                    ? undefined
-                    : latestBuild.buildId,
-                validate: (buildId) => validateBuildId(buildId, deployedBuildId, latestBuild.buildId, projectName, targetAccountId),
-            });
-            buildIdToDeploy = deployBuildIdPromptResponse.buildId;
+            if (deployLatestBuildOption) {
+                buildIdToDeploy = latestBuild.buildId;
+            }
+            else {
+                const deployBuildIdPromptResponse = await (0, promptUtils_1.promptUser)({
+                    name: 'buildId',
+                    message: en_1.commands.project.deploy.deployBuildIdPrompt,
+                    default: latestBuild.buildId === deployedBuildId
+                        ? undefined
+                        : latestBuild.buildId,
+                    validate: buildId => validateBuildId(buildId, deployedBuildId, latestBuild.buildId, projectName, targetAccountId),
+                });
+                buildIdToDeploy = deployBuildIdPromptResponse.buildId;
+            }
         }
         if (!buildIdToDeploy) {
-            logger.error(i18n(`commands.project.subcommands.deploy.errors.noBuildId`));
-            return process.exit(EXIT_CODES.ERROR);
+            logger_1.uiLogger.error(en_1.commands.project.deploy.errors.noBuildId);
+            return process.exit(exitCodes_1.EXIT_CODES.ERROR);
         }
-        const { data: deployResp } = await deployProject(targetAccountId, projectName, buildIdToDeploy, useV3Api(projectConfig?.platformVersion), forceOption);
-        if (!deployResp) {
-            logger.error(i18n(`commands.project.subcommands.deploy.errors.deploy`));
-            return process.exit(EXIT_CODES.ERROR);
+        const { data: deployResp } = await (0, projects_1.deployProject)(targetAccountId, projectName, buildIdToDeploy, (0, buildAndDeploy_1.useV3Api)(projectConfig?.platformVersion), forceOption);
+        if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
+            logger_1.uiLogger.error(en_1.commands.project.deploy.errors.deploy);
+            return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        else if (formatOutputAsJson) {
+            jsonOutput.deployId = Number(deployResp.id);
+        }
+        const deployResult = await (0, buildAndDeploy_2.pollDeployStatus)(targetAccountId, projectName, Number(deployResp.id), buildIdToDeploy);
+        if (deployResult.status === constants_1.PROJECT_DEPLOY_TEXT.STATES.SUCCESS) {
+            deploySuccess = true;
         }
-        await pollDeployStatus(targetAccountId, projectName, Number(deployResp.id), buildIdToDeploy);
     }
     catch (e) {
-        if (isHubSpotHttpError(e) && e.status === 404) {
-            logger.error(i18n(`commands.project.subcommands.deploy.errors.projectNotFound`, {
-                projectName: chalk.bold(projectName),
-                accountIdentifier: uiAccountDescription(targetAccountId),
-                command: uiCommandReference('hs project upload'),
-            }));
+        if ((0, index_1.isHubSpotHttpError)(e) && e.status === 404) {
+            logger_1.uiLogger.error(en_1.commands.project.deploy.errors.projectNotFound(targetAccountId, projectName));
         }
-        else if (isHubSpotHttpError(e) && e.status === 400) {
+        else if ((0, index_1.isHubSpotHttpError)(e) && e.status === 400) {
             if (e.data?.message && e.data?.errors) {
                 logDeployErrors(e.data);
             }
             else {
-                logger.error(e.message);
+                logger_1.uiLogger.error(e.message);
             }
         }
         else {
-            logError(e, new ApiErrorContext({
+            (0, index_2.logError)(e, new index_2.ApiErrorContext({
                 accountId: targetAccountId,
                 request: 'project deploy',
             }));
         }
-        return process.exit(EXIT_CODES.ERROR);
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    if (formatOutputAsJson) {
+        logger_1.uiLogger.json(jsonOutput);
+    }
+    if (deploySuccess) {
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    else {
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
 function projectDeployBuilder(yargs) {
     yargs.options({
         project: {
-            describe: i18n(`commands.project.subcommands.deploy.options.project.describe`),
+            describe: en_1.commands.project.deploy.options.project,
             type: 'string',
         },
         build: {
             alias: ['build-id'],
-            describe: i18n(`commands.project.subcommands.deploy.options.build.describe`),
+            describe: en_1.commands.project.deploy.options.build,
             type: 'number',
         },
+        deployLatestBuild: {
+            alias: ['deploy-latest-build'],
+            describe: en_1.commands.project.deploy.options.deployLatestBuild,
+            default: false,
+            type: 'boolean',
+        },
         profile: {
             alias: ['p'],
-            describe: i18n(`commands.project.subcommands.deploy.options.profile.describe`),
+            describe: en_1.commands.project.deploy.options.profile,
             type: 'string',
             hidden: true,
         },
         force: {
             alias: ['f'],
-            describe: i18n(`commands.project.subcommands.deploy.options.force.describe`),
+            describe: en_1.commands.project.deploy.options.force,
             default: false,
             type: 'boolean',
         },
@@ -172,22 +185,20 @@ function projectDeployBuilder(yargs) {
     yargs.conflicts('profile', 'project');
     yargs.conflicts('profile', 'account');
     yargs.example([
-        [
-            '$0 project deploy',
-            i18n(`commands.project.subcommands.deploy.examples.default`),
-        ],
+        ['$0 project deploy', en_1.commands.project.deploy.examples.default],
         [
             '$0 project deploy --project="my-project" --build=5',
-            i18n(`commands.project.subcommands.deploy.examples.withOptions`),
+            en_1.commands.project.deploy.examples.withOptions,
         ],
     ]);
     return yargs;
 }
-const builder = makeYargsBuilder(projectDeployBuilder, command, describe, {
+const builder = (0, yargsUtils_1.makeYargsBuilder)(projectDeployBuilder, command, describe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
     useEnvironmentOptions: true,
+    useJSONOutputOptions: true,
 });
 const projectDeployCommand = {
     command,
@@ -195,4 +206,4 @@ const projectDeployCommand = {
     builder,
     handler,
 };
-export default projectDeployCommand;
+exports.default = projectDeployCommand;

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

@@ -1,6 +1,6 @@
 import { ArgumentsCamelCase } from 'yargs';
-import { ProjectConfig } from '../../../types/Projects.js';
-import { ProjectDevArgs } from '../../../types/Yargs.js';
+import { ProjectConfig } from '../../../types/Projects';
+import { ProjectDevArgs } from '../../../types/Yargs';
 type DeprecatedProjectDevFlowArgs = {
     args: ArgumentsCamelCase<ProjectDevArgs>;
     accountId: number;

package/commands/project/dev/deprecatedFlow.js

@@ -1,60 +1,66 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { getAccountConfig, getConfigAccounts, getEnv, } from '@hubspot/local-dev-lib/config';
-import { getValidEnv } from '@hubspot/local-dev-lib/environment';
-import { findProjectComponents, getProjectComponentTypes, } from '../../../lib/projects/structure.js';
-import { ComponentTypes } from '../../../types/Projects.js';
-import { i18n } from '../../../lib/lang.js';
-import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import { uiCommandReference } from '../../../lib/ui/index.js';
-import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
-import LocalDevManager from '../../../lib/projects/localDev/LocalDevManager.js';
-import { confirmDefaultAccountIsTarget, suggestRecommendedNestedAccount, checkIfAccountFlagIsSupported, checkIfDefaultAccountIsSupported, createSandboxForLocalDev, createDeveloperTestAccountForLocalDev, createNewProjectForLocalDev, createInitialBuildForNewProject, useExistingDevTestAccount, checkIfParentAccountIsAuthed, hasSandboxes, } from '../../../lib/projects/localDev/helpers.js';
-import { handleExit } from '../../../lib/process.js';
-import { isSandbox, isDeveloperTestAccount, } from '../../../lib/accountTypes.js';
-import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
-export async function deprecatedProjectDevFlow({ args, accountId, projectConfig, projectDir, }) {
+"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/projects/localDev/LocalDevManager"));
+const helpers_1 = require("../../../lib/projects/localDev/helpers");
+const process_1 = require("../../../lib/process");
+const accountTypes_1 = require("../../../lib/accountTypes");
+const ensureProjectExists_1 = require("../../../lib/projects/ensureProjectExists");
+async function deprecatedProjectDevFlow({ args, accountId, projectConfig, projectDir, }) {
     const { userProvidedAccount, derivedAccountId } = args;
-    const env = getValidEnv(getEnv(derivedAccountId));
-    const components = await findProjectComponents(projectDir);
+    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 = getProjectComponentTypes(runnableComponents);
-    const hasPrivateApps = !!componentTypes[ComponentTypes.PrivateApp];
-    const hasPublicApps = !!componentTypes[ComponentTypes.PublicApp];
-    const accountConfig = getAccountConfig(accountId);
+    const componentTypes = (0, structure_1.getProjectComponentTypes)(runnableComponents);
+    const hasPrivateApps = !!componentTypes[Projects_1.ComponentTypes.PrivateApp];
+    const hasPublicApps = !!componentTypes[Projects_1.ComponentTypes.PublicApp];
+    const accountConfig = (0, config_1.getAccountConfig)(accountId);
     if (!accountConfig) {
-        logger.error(i18n('commands.project.subcommands.dev.errors.noAccount', {
+        logger_1.logger.error((0, lang_1.i18n)('commands.project.subcommands.dev.errors.noAccount', {
             accountId: accountId,
-            authCommand: uiCommandReference('hs auth'),
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
         }));
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     if (runnableComponents.length === 0) {
-        logger.error(i18n(`commands.project.subcommands.dev.errors.noRunnableComponents`, {
+        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.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(`commands.project.subcommands.dev.errors.invalidProjectComponents`));
-        process.exit(EXIT_CODES.SUCCESS);
+        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.invalidProjectComponents`));
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-    const accounts = getConfigAccounts();
+    const accounts = (0, config_1.getConfigAccounts)();
     if (!accounts) {
-        logger.error(i18n(`commands.project.subcommands.dev.errors.noAccountsInConfig`, {
-            authCommand: uiCommandReference('hs auth'),
+        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.noAccountsInConfig`, {
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
         }));
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     let bypassRecommendedAccountPrompt = false;
-    if (isDeveloperTestAccount(accountConfig)) {
+    if ((0, accountTypes_1.isDeveloperTestAccount)(accountConfig)) {
         bypassRecommendedAccountPrompt = true;
     }
-    else if (!hasPublicApps && isSandbox(accountConfig)) {
+    else if (!hasPublicApps && (0, accountTypes_1.isSandbox)(accountConfig)) {
         bypassRecommendedAccountPrompt = true;
     }
     else if (!hasPublicApps) {
-        const defaultAccountHasSandboxes = await hasSandboxes(accountConfig);
+        const defaultAccountHasSandboxes = await (0, helpers_1.hasSandboxes)(accountConfig);
         bypassRecommendedAccountPrompt = !defaultAccountHasSandboxes;
     }
     // targetProjectAccountId and targetTestingAccountId are set to null if --account flag is not provided.
@@ -64,20 +70,20 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
     let targetTestingAccountId = userProvidedAccount ? derivedAccountId : null;
     // Check that the default account or flag option is valid for the type of app in this project
     if (userProvidedAccount) {
-        checkIfAccountFlagIsSupported(accountConfig, hasPublicApps);
+        (0, helpers_1.checkIfAccountFlagIsSupported)(accountConfig, hasPublicApps);
         if (hasPublicApps) {
             targetProjectAccountId = accountConfig.parentAccountId || null;
         }
     }
     else {
-        await checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps);
+        await (0, helpers_1.checkIfDefaultAccountIsSupported)(accountConfig, hasPublicApps);
     }
     // The user is targeting an account type that we recommend developing on
     if (!targetProjectAccountId && bypassRecommendedAccountPrompt) {
         targetTestingAccountId = derivedAccountId;
-        await confirmDefaultAccountIsTarget(accountConfig);
+        await (0, helpers_1.confirmDefaultAccountIsTarget)(accountConfig);
         if (hasPublicApps) {
-            checkIfParentAccountIsAuthed(accountConfig);
+            (0, helpers_1.checkIfParentAccountIsAuthed)(accountConfig);
             targetProjectAccountId = accountConfig.parentAccountId || null;
         }
         else {
@@ -87,49 +93,49 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
     let createNewSandbox = false;
     let createNewDeveloperTestAccount = false;
     if (!targetProjectAccountId) {
-        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps);
+        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await (0, helpers_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, helpers_1.useExistingDevTestAccount)(env, notInConfigAccount);
         }
         createNewSandbox = hasPrivateApps && createNestedAccount;
         createNewDeveloperTestAccount = hasPublicApps && createNestedAccount;
     }
     if (createNewSandbox) {
-        targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
+        targetProjectAccountId = await (0, helpers_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, helpers_1.createDeveloperTestAccountForLocalDev)(derivedAccountId, accountConfig, env);
         targetProjectAccountId = derivedAccountId;
     }
     if (!targetProjectAccountId || !targetTestingAccountId) {
-        logger.error(i18n(`commands.project.subcommands.dev.errors.noAccount`));
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.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, ensureProjectExists_1.ensureProjectExists)(targetProjectAccountId, projectConfig.name, {
         allowCreate: false,
         noLogs: true,
         withPolling: createNewSandbox,
     });
     let deployedBuild;
     let isGithubLinked = false;
-    SpinniesManager.init();
+    SpinniesManager_1.default.init();
     if (projectExists && project) {
         deployedBuild = project.deployedBuild;
         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, helpers_1.createNewProjectForLocalDev)(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
+        deployedBuild = await (0, helpers_1.createInitialBuildForNewProject)(projectConfig, projectDir, targetProjectAccountId);
     }
-    const LocalDev = new LocalDevManager({
+    const LocalDev = new LocalDevManager_1.default({
         runnableComponents,
         debug: args.debug,
         deployedBuild,
@@ -142,5 +148,5 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
         env,
     });
     await LocalDev.start();
-    handleExit(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
+    (0, process_1.handleExit)(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
 }

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

@@ -1,5 +1,5 @@
 import { Argv, CommandModule } from 'yargs';
-import { ProjectDevArgs } from '../../../types/Yargs.js';
+import { ProjectDevArgs } from '../../../types/Yargs';
 export declare const builder: (yargs: Argv) => Promise<Argv<ProjectDevArgs>>;
 declare const projectDevCommand: CommandModule<unknown, ProjectDevArgs>;
 export default projectDevCommand;