@hubspot/cli 8.0.10-experimental.7 → 8.0.11-experimental.1

package/commands/mcp/setup.js

@@ -1,20 +1,19 @@
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { commands } from '../../lang/en.js';
+import { makeYargsHandlerWithUsageTracking } from '../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { addMcpServerToConfig, supportedTools } from '../../lib/mcp/setup.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
 const command = ['setup'];
 const describe = commands.mcp.setup.describe;
 async function handler(args) {
-    const { derivedAccountId } = args;
-    await trackCommandUsage('mcp-setup', {}, derivedAccountId);
+    const { exit } = args;
     try {
         await addMcpServerToConfig(args.client);
     }
     catch (e) {
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    process.exit(EXIT_CODES.SUCCESS);
+    return exit(EXIT_CODES.SUCCESS);
 }
 function setupBuilder(yargs) {
     yargs.option('client', {
@@ -30,7 +29,7 @@ const builder = makeYargsBuilder(setupBuilder, command, describe, {
 const mcpSetupCommand = {
     command,
     describe,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('mcp-setup', handler),
     builder,
 };
 export default mcpSetupCommand;

package/commands/mcp/start.js

@@ -7,14 +7,13 @@ import { uiLogger } from '../../lib/ui/logger.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { commands } from '../../lang/en.js';
 import { handleExit } from '../../lib/process.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { makeYargsHandlerWithUsageTracking } from '../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { fileURLToPath } from 'url';
 const command = 'start';
 const describe = undefined; // Leave hidden for now
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 async function handler(args) {
-    trackCommandUsage('mcp-start', {}, args.derivedAccountId);
     await startMcpServer(args.aiAgent);
 }
 async function startMcpServer(aiAgent) {
@@ -66,7 +65,7 @@ const builder = makeYargsBuilder(startBuilder, command, describe, {
 const mcpStartCommand = {
     command,
     describe,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('mcp-start', handler),
     builder,
 };
 export default mcpStartCommand;

package/commands/open.js

@@ -1,8 +1,8 @@
-import { trackCommandUsage } from '../lib/usageTracking.js';
 import { logSiteLinks, getSiteLinksAsArray, openLink } from '../lib/links.js';
 import { promptUser } from '../lib/prompts/promptUtils.js';
 import { commands } from '../lang/en.js';
 import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { makeYargsHandlerWithUsageTracking } from '../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 const separator = ' => ';
 async function createListPrompt(accountId) {
@@ -22,8 +22,7 @@ async function createListPrompt(accountId) {
 const command = 'open [shortcut]';
 const describe = commands.open.describe;
 async function handler(args) {
-    const { shortcut, list, derivedAccountId } = args;
-    trackCommandUsage('open', undefined, derivedAccountId);
+    const { shortcut, list, derivedAccountId, exit } = args;
     if (shortcut === undefined && !list) {
         const { open } = await createListPrompt(derivedAccountId);
         openLink(derivedAccountId, open);
@@ -34,7 +33,7 @@ async function handler(args) {
     else if (shortcut) {
         openLink(derivedAccountId, shortcut);
     }
-    process.exit(EXIT_CODES.SUCCESS);
+    return exit(EXIT_CODES.SUCCESS);
 }
 function openBuilder(yargs) {
     yargs.positional('[shortcut]', {
@@ -64,7 +63,7 @@ const builder = makeYargsBuilder(openBuilder, command, describe, {
 const openCommand = {
     command,
     describe,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('open', handler),
     builder,
 };
 export default openCommand;

package/commands/project/add.js

@@ -1,6 +1,8 @@
 import { logError } from '../../lib/errorHandlers/index.js';
 import { getProjectConfig } from '../../lib/projects/config.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { isPromptExitError } from '../../lib/errors/PromptExitError.js';
+import { makeYargsHandlerWithUsageTracking } from '../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { commands } from '../../lang/en.js';
 import { isV2Project } from '../../lib/projects/platformVersion.js';
@@ -11,12 +13,12 @@ import { uiLogger } from '../../lib/ui/logger.js';
 const command = 'add';
 const describe = commands.project.add.describe;
 async function handler(args) {
+    const { derivedAccountId, exit } = args;
     try {
-        const { derivedAccountId } = args;
         const { projectConfig, projectDir } = await getProjectConfig();
         if (!projectDir || !projectConfig) {
             uiLogger.error(commands.project.add.error.locationInProject);
-            process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
         const isV2ProjectCreate = isV2Project(projectConfig.platformVersion);
         if (isV2ProjectCreate) {
@@ -27,10 +29,13 @@ async function handler(args) {
         }
     }
     catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
         logError(e);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    process.exit(EXIT_CODES.SUCCESS);
+    return exit(EXIT_CODES.SUCCESS);
 }
 function projectAddBuilder(yargs) {
     yargs.options({
@@ -73,7 +78,7 @@ const builder = makeYargsBuilder(projectAddBuilder, command, describe, {
 const projectAddCommand = {
     command,
     describe,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('project-add', handler),
     builder,
 };
 export default projectAddCommand;

package/commands/project/create.js

@@ -2,7 +2,6 @@ import path from 'path';
 import fs from 'fs-extra';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { getCwd } from '@hubspot/local-dev-lib/path';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { writeProjectConfig, getProjectConfig, } from '../../lib/projects/config.js';
 import { EMPTY_PROJECT_TEMPLATE_NAME } from '../../lib/projects/create/legacy.js';
 import { generateComponentPaths } from '../../lib/projects/create/v2.js';
@@ -10,6 +9,7 @@ import { PROJECT_WITH_APP, EMPTY_PROJECT } from '../../lib/constants.js';
 import { debugError, logError } from '../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { PROJECT_CONFIG_FILE, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, marketplaceDistribution, privateDistribution, oAuth, staticAuth, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../lib/constants.js';
+import { makeYargsHandlerWithUsageTracking } from '../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { PLATFORM_VERSIONS } from '@hubspot/local-dev-lib/constants/projects';
 import { commands } from '../../lang/en.js';
@@ -22,10 +22,10 @@ const command = ['create', 'init'];
 const describe = commands.project.create.describe;
 const { v2025_1, v2025_2, v2026_03_beta, v2026_03 } = PLATFORM_VERSIONS;
 async function handler(args) {
-    const { derivedAccountId, platformVersion, templateSource } = args;
+    const { platformVersion, templateSource, exit, addUsageMetadata } = args;
     if (templateSource && !templateSource.includes('/')) {
         uiLogger.error(commands.project.create.errors.invalidTemplateSource);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
     let handleResult;
@@ -34,16 +34,16 @@ async function handler(args) {
     }
     catch (error) {
         logError(error);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     const { authType, distribution, repoConfig, projectContents, selectProjectTemplatePromptResponse, projectNameAndDestPromptResponse, } = handleResult;
-    trackCommandUsage('project-create', {
+    addUsageMetadata({
         type: selectProjectTemplatePromptResponse.projectTemplate?.name ||
             (selectProjectTemplatePromptResponse.componentTemplates || [])
                 // @ts-expect-error
                 .map((item) => item.type)
                 .join(','),
-    }, derivedAccountId);
+    });
     const projectDest = path.resolve(getCwd(), projectNameAndDestPromptResponse.dest);
     const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDest);
     // Exit if the target destination is within an existing project
@@ -51,7 +51,7 @@ async function handler(args) {
         existingProjectDir &&
         projectDest.startsWith(existingProjectDir)) {
         uiLogger.error(commands.project.create.errors.cannotNestProjects(existingProjectDir));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     const components = generateComponentPaths({
         selectProjectTemplatePromptResponse,
@@ -79,7 +79,7 @@ async function handler(args) {
         });
         debugError(err);
         uiLogger.error(commands.project.create.errors.failedToDownloadProject);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     const projectConfigPath = path.join(projectDest, PROJECT_CONFIG_FILE);
     const parsedConfigFile = JSON.parse(fs.readFileSync(projectConfigPath).toString());
@@ -102,7 +102,7 @@ async function handler(args) {
     if (isProjectEmpty) {
         fs.ensureDirSync(path.join(projectDest, 'src'));
     }
-    process.exit(EXIT_CODES.SUCCESS);
+    return exit(EXIT_CODES.SUCCESS);
 }
 function projectCreateBuilder(yargs) {
     yargs.options({
@@ -169,7 +169,7 @@ const builder = makeYargsBuilder(projectCreateBuilder, command, describe, {
 const projectCreateCommand = {
     command,
     describe,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('project-create', handler),
     builder,
 };
 export default projectCreateCommand;

package/commands/project/delete.d.ts

@@ -0,0 +1,7 @@
+import { AccountArgs, CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type ProjectDeleteArgs = CommonArgs & ConfigArgs & AccountArgs & {
+    projectName?: string;
+    force: boolean;
+};
+declare const projectDeleteCommand: YargsCommandModule<unknown, ProjectDeleteArgs>;
+export default projectDeleteCommand;

package/commands/project/delete.js

@@ -0,0 +1,74 @@
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { makeYargsHandlerWithUsageTracking } from '../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { renderInline } from '../../ui/render.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
+import { commands } from '../../lang/en.js';
+import { isV2Project } from '../../lib/projects/platformVersion.js';
+import { isPromptExitError } from '../../lib/errors/PromptExitError.js';
+import { resolveProjectName, checkDeployedComponents, deleteDeployedComponents, confirmDeletion, handleProjectDeletion, } from '../../lib/projects/delete.js';
+const command = 'delete';
+const describe = commands.project.delete.describe;
+const verboseDescribe = commands.project.delete.verboseDescribe;
+async function handler(args) {
+    const { derivedAccountId, projectName: projectNameArg, force, exit } = args;
+    await renderInline(getWarningBox({
+        title: commands.project.delete.warnings.irreversibleTitle,
+        message: commands.project.delete.warnings.irreversible,
+    }));
+    try {
+        const projectName = await resolveProjectName(derivedAccountId, projectNameArg);
+        const { platformVersion, hasUnifiedComponents, projectId } = await checkDeployedComponents(derivedAccountId, projectName);
+        if (!force) {
+            await confirmDeletion(projectName, derivedAccountId, projectId);
+        }
+        if (isV2Project(platformVersion) && hasUnifiedComponents) {
+            await deleteDeployedComponents(derivedAccountId, projectName);
+        }
+        await handleProjectDeletion(derivedAccountId, projectName);
+    }
+    catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
+        logError(e);
+        return exit(EXIT_CODES.ERROR);
+    }
+    return exit(EXIT_CODES.SUCCESS);
+}
+function projectDeleteBuilder(yargs) {
+    yargs.option('project-name', {
+        describe: commands.project.delete.options.project,
+        type: 'string',
+    });
+    yargs.option('force', {
+        describe: commands.project.delete.options.force,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.example([
+        [
+            '$0 project delete --project-name=my-project',
+            'Delete a project in the current account named "my-project"',
+        ],
+        [
+            '$0 project delete --project-name=my-project --force',
+            'Delete and skip confirmation prompt',
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectDeleteBuilder, command, verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const projectDeleteCommand = {
+    command,
+    describe,
+    handler: makeYargsHandlerWithUsageTracking('project-delete', handler),
+    builder,
+};
+export default projectDeleteCommand;

package/commands/project/deploy.js

@@ -2,56 +2,58 @@ import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import { isV2Project } from '../../lib/projects/platformVersion.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
-import { getProjectConfig } from '../../lib/projects/config.js';
+import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
 import { projectNamePrompt } from '../../lib/prompts/projectNamePrompt.js';
+import { projectProfilePrompt } from '../../lib/prompts/projectProfilePrompt.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiLogger } from '../../lib/ui/logger.js';
+import { makeYargsHandlerWithUsageTracking } from '../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { loadProfile, logProfileFooter, logProfileHeader, enforceProfileUsage, } from '../../lib/projects/projectProfiles.js';
+import { loadProfile } from '../../lib/projects/projectProfiles.js';
 import { PROJECT_DEPLOY_TEXT } from '../../lib/constants.js';
 import { commands } from '../../lang/en.js';
 import { handleProjectDeploy, validateBuildIdForDeploy, logDeployErrors, } from '../../lib/projects/deploy.js';
 const command = 'deploy';
 const describe = commands.project.deploy.describe;
 async function handler(args) {
-    const { derivedAccountId, project: projectOption, buildId: buildIdOption, force: forceOption, deployLatestBuild: deployLatestBuildOption, json: formatOutputAsJson, } = args;
+    const { derivedAccountId, project: projectOption, buildId: buildIdOption, force: forceOption, deployLatestBuild: deployLatestBuildOption, json: formatOutputAsJson, profile: profileOption, useEnv: useEnvOption, exit, addUsageMetadata, } = args;
     const accountConfig = getConfigAccountById(derivedAccountId);
     const accountType = accountConfig && accountConfig.accountType;
     let targetAccountId;
     const jsonOutput = {};
     const { projectConfig, projectDir } = await getProjectConfig();
-    if (isV2Project(projectConfig?.platformVersion)) {
-        if (args.profile) {
-            logProfileHeader(args.profile);
-            let profile;
-            try {
-                profile = loadProfile(projectConfig, projectDir, args.profile);
-            }
-            catch (error) {
-                logError(error);
-                process.exit(EXIT_CODES.ERROR);
+    let isInProjectDirectory = false;
+    // Validate project config, but it's valid to run this command from outside a project dir
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+        isInProjectDirectory = true;
+    }
+    catch (e) { }
+    if (isInProjectDirectory && isV2Project(projectConfig?.platformVersion)) {
+        try {
+            const profileName = await projectProfilePrompt(projectDir, projectConfig, profileOption, !!useEnvOption);
+            if (profileName) {
+                // Use loadProfile instead of loadAndValidateProfile because the local
+                // profile does not need to be valid to successfully deploy
+                const profile = loadProfile(projectConfig, projectDir, profileName);
+                targetAccountId = profile.accountId;
+                uiLogger.log(commands.project.deploy.profileMessage(profileName, targetAccountId));
+                uiLogger.log('');
             }
-            targetAccountId = profile.accountId;
-            logProfileFooter(profile);
         }
-        else {
-            // A profile must be specified if this project has profiles configured
-            try {
-                await enforceProfileUsage(projectConfig, projectDir);
-            }
-            catch (error) {
-                logError(error);
-                process.exit(EXIT_CODES.ERROR);
-            }
+        catch (error) {
+            logError(error);
+            return exit(EXIT_CODES.ERROR);
         }
     }
     if (!targetAccountId) {
         targetAccountId = derivedAccountId;
     }
-    trackCommandUsage('project-deploy', accountType ? { type: accountType } : undefined, targetAccountId);
+    if (accountType) {
+        addUsageMetadata({ type: accountType });
+    }
     let projectName = projectOption;
     if (!projectOption && projectConfig) {
         projectName = projectConfig.name;
@@ -66,13 +68,13 @@ async function handler(args) {
         const { data: { latestBuild, deployedBuildId }, } = await fetchProject(targetAccountId, projectName);
         if (!latestBuild || !latestBuild.buildId) {
             uiLogger.error(commands.project.deploy.errors.noBuilds);
-            return process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
         if (buildIdToDeploy) {
             const validationResult = validateBuildIdForDeploy(buildIdToDeploy, deployedBuildId, latestBuild.buildId, projectName, targetAccountId);
             if (validationResult !== true) {
                 uiLogger.error(validationResult.toString());
-                return process.exit(EXIT_CODES.ERROR);
+                return exit(EXIT_CODES.ERROR);
             }
         }
         else {
@@ -93,11 +95,11 @@ async function handler(args) {
         }
         if (!buildIdToDeploy) {
             uiLogger.error(commands.project.deploy.errors.noBuildId);
-            return process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
         const deployResult = await handleProjectDeploy(targetAccountId, projectName, buildIdToDeploy, isV2Project(projectConfig?.platformVersion), forceOption);
         if (!deployResult) {
-            return process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
         else if (formatOutputAsJson) {
             jsonOutput.deployId = deployResult.deployId;
@@ -124,16 +126,16 @@ async function handler(args) {
                 request: 'project deploy',
             }));
         }
-        return process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     if (formatOutputAsJson) {
         uiLogger.json(jsonOutput);
     }
     if (deploySuccess) {
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     else {
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
 }
 function projectDeployBuilder(yargs) {
@@ -191,6 +193,6 @@ const projectDeployCommand = {
     command,
     describe,
     builder,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('project-deploy', handler),
 };
 export default projectDeployCommand;

package/commands/project/dev/deprecatedFlow.js

@@ -8,10 +8,11 @@ import LocalDevManager_DEPRECATED from '../../../lib/projects/localDev/LocalDevM
 import { confirmDefaultAccountIsTarget, suggestRecommendedNestedAccount, checkIfAccountFlagIsSupported, checkIfDefaultAccountIsSupported, createSandboxForLocalDev, createDeveloperTestAccountForLocalDev, useExistingDevTestAccount, checkIfParentAccountIsAuthed, hasSandboxes, } from '../../../lib/projects/localDev/helpers/account.js';
 import { createInitialBuildForNewProject, createNewProjectForLocalDev, } from '../../../lib/projects/localDev/helpers/project.js';
 import { handleExit } from '../../../lib/process.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 import { isSandbox, isDeveloperTestAccount, } from '../../../lib/accountTypes.js';
 import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
 export async function deprecatedProjectDevFlow({ args, accountId, projectConfig, projectDir, }) {
-    const { userProvidedAccount, derivedAccountId } = args;
+    const { userProvidedAccount, derivedAccountId, exit } = args;
     const env = getConfigAccountEnvironment(derivedAccountId);
     const components = await findProjectComponents(projectDir);
     const runnableComponents = components.filter(component => component.runnable);
@@ -21,20 +22,20 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
     const accountConfig = getConfigAccountById(accountId);
     if (!accountConfig) {
         uiLogger.error(commands.project.dev.errors.noAccount(accountId));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     if (runnableComponents.length === 0) {
         uiLogger.error(commands.project.dev.errors.noRunnableComponents);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     else if (hasPrivateApps && hasPublicApps) {
         uiLogger.error(commands.project.dev.errors.invalidProjectComponents);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     const accounts = getAllConfigAccounts();
     if (!accounts) {
         uiLogger.error(commands.project.dev.errors.noAccountsInConfig);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     let bypassRecommendedAccountPrompt = false;
     if (isDeveloperTestAccount(accountConfig)) {
@@ -54,20 +55,32 @@ 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);
+        try {
+            checkIfAccountFlagIsSupported(accountConfig, hasPublicApps);
+        }
+        catch (e) {
+            uiLogger.error(getErrorMessage(e));
+            return exit(EXIT_CODES.SUCCESS);
+        }
         if (hasPublicApps) {
             targetProjectAccountId = accountConfig.parentAccountId || null;
         }
     }
     else {
-        await checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps);
+        await checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps, exit);
     }
     // The user is targeting an account type that we recommend developing on
     if (!targetProjectAccountId && bypassRecommendedAccountPrompt) {
         targetTestingAccountId = derivedAccountId;
-        await confirmDefaultAccountIsTarget(accountConfig);
+        await confirmDefaultAccountIsTarget(accountConfig, exit);
         if (hasPublicApps) {
-            checkIfParentAccountIsAuthed(accountConfig);
+            try {
+                checkIfParentAccountIsAuthed(accountConfig);
+            }
+            catch (e) {
+                uiLogger.error(getErrorMessage(e));
+                return exit(EXIT_CODES.SUCCESS);
+            }
             targetProjectAccountId = accountConfig.parentAccountId || null;
         }
         else {
@@ -84,23 +97,36 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
         targetTestingAccountId = targetAccountId;
         // Only used for developer test accounts that are not yet in the config
         if (notInConfigAccount) {
-            await useExistingDevTestAccount(env, notInConfigAccount);
+            const accountAdded = await useExistingDevTestAccount(env, notInConfigAccount);
+            if (!accountAdded) {
+                return exit(EXIT_CODES.SUCCESS);
+            }
         }
         createNewSandbox = hasPrivateApps && createNestedAccount;
         createNewDeveloperTestAccount = hasPublicApps && createNestedAccount;
     }
     if (createNewSandbox) {
-        targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
+        try {
+            targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
+        }
+        catch {
+            return exit(EXIT_CODES.ERROR);
+        }
         // We will be running our tests against this new sandbox account
         targetTestingAccountId = targetProjectAccountId;
     }
     if (createNewDeveloperTestAccount) {
-        targetTestingAccountId = await createDeveloperTestAccountForLocalDev(derivedAccountId, accountConfig, env);
+        try {
+            targetTestingAccountId = await createDeveloperTestAccountForLocalDev(derivedAccountId, accountConfig, env, false);
+        }
+        catch {
+            return exit(EXIT_CODES.ERROR);
+        }
         targetProjectAccountId = derivedAccountId;
     }
     if (!targetProjectAccountId || !targetTestingAccountId) {
         uiLogger.error(commands.project.dev.errors.noAccount(accountId));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     // eslint-disable-next-line prefer-const
     let { projectExists, project } = await ensureProjectExists(targetProjectAccountId, projectConfig.name, {
@@ -115,8 +141,8 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
         isGithubLinked = Boolean(project.sourceIntegration && project.sourceIntegration.source === 'GITHUB');
     }
     else {
-        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
-        deployedBuild = await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId);
+        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps, exit);
+        deployedBuild = await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId, exit);
     }
     const LocalDev = new LocalDevManager_DEPRECATED({
         runnableComponents,
@@ -129,6 +155,7 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
         projectId: project.id,
         targetAccountId: targetTestingAccountId,
         env,
+        exit,
     });
     await LocalDev.start();
     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 { Argv } from 'yargs';
+import { ProjectDevArgs, YargsCommandModule } from '../../../types/Yargs.js';
 export declare const builder: (yargs: Argv) => Promise<Argv<ProjectDevArgs>>;
-declare const projectDevCommand: CommandModule<unknown, ProjectDevArgs>;
+declare const projectDevCommand: YargsCommandModule<unknown, ProjectDevArgs>;
 export default projectDevCommand;