@hubspot/cli 8.0.11-experimental.0 → 8.0.11-experimental.2

package/commands/project/deploy.js

@@ -1,57 +1,60 @@
 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 { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 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 &&
+        !isLegacyProject(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 +69,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 +96,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);
+        const deployResult = await handleProjectDeploy(targetAccountId, projectName, buildIdToDeploy, isLegacyProject(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 +127,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 +194,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;

package/commands/project/dev/index.js

@@ -1,49 +1,51 @@
-import { trackCommandUsage } from '../../../lib/usageTracking.js';
 import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { getAllHsProfiles, } from '@hubspot/project-parsing-lib/profiles';
 import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
 import { uiLine } from '../../../lib/ui/index.js';
+import { makeYargsHandlerWithUsageTracking } from '../../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { deprecatedProjectDevFlow } from './deprecatedFlow.js';
 import { unifiedProjectDevFlow } from './unifiedFlow.js';
-import { isV2Project } from '../../../lib/projects/platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
-import { loadProfile } from '../../../lib/projects/projectProfiles.js';
+import { loadAndValidateProfile } from '../../../lib/projects/projectProfiles.js';
 import { commands } from '../../../lang/en.js';
 import { uiLogger } from '../../../lib/ui/logger.js';
 import { logError } from '../../../lib/errorHandlers/index.js';
-import { PromptExitError } from '../../../lib/errors/PromptExitError.js';
-import path from 'path';
-import { listPrompt } from '../../../lib/prompts/promptUtils.js';
+import { projectProfilePrompt } from '../../../lib/prompts/projectProfilePrompt.js';
+import { isPromptExitError } from '../../../lib/errors/PromptExitError.js';
 const command = 'dev';
 const describe = commands.project.dev.describe;
 function validateAccountFlags(testingAccount, projectAccount, userProvidedAccount, useV2) {
     // Legacy projects do not support targetTestingAccount and targetProjectAccount
     if (testingAccount && projectAccount && !useV2) {
-        uiLogger.error(commands.project.dev.errors.unsupportedAccountFlagLegacy);
-        process.exit(EXIT_CODES.ERROR);
+        throw new Error(commands.project.dev.errors.unsupportedAccountFlagLegacy);
     }
     if (userProvidedAccount && useV2) {
-        uiLogger.error(commands.project.dev.errors.unsupportedAccountFlagV2);
-        process.exit(EXIT_CODES.ERROR);
+        throw new Error(commands.project.dev.errors.unsupportedAccountFlagV2);
     }
 }
 async function handler(args) {
-    const { derivedAccountId, userProvidedAccount, testingAccount, projectAccount, } = args;
+    const { derivedAccountId, userProvidedAccount, testingAccount, projectAccount, profile: profileOption, exit, addUsageMetadata, } = args;
     const { projectConfig, projectDir } = await getProjectConfig();
     try {
         validateProjectConfig(projectConfig, projectDir);
     }
     catch (error) {
         logError(error);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    const useV2Projects = isV2Project(projectConfig.platformVersion);
+    const useV2Projects = !isLegacyProject(projectConfig.platformVersion);
     if (!projectDir) {
         uiLogger.error(commands.project.dev.errors.noProjectConfig);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
+    }
+    try {
+        validateAccountFlags(testingAccount, projectAccount, userProvidedAccount, useV2Projects);
+    }
+    catch (error) {
+        logError(error);
+        return exit(EXIT_CODES.ERROR);
     }
-    validateAccountFlags(testingAccount, projectAccount, userProvidedAccount, useV2Projects);
     uiLogger.log(commands.project.dev.logs.header);
     if (useV2Projects) {
         uiLogger.log(commands.project.dev.logs.learnMoreMessageV2);
@@ -67,19 +69,12 @@ async function handler(args) {
         targetProjectAccountId = derivedAccountId;
     }
     // Determine profile name: from flag or prompt
-    if (!targetProjectAccountId && isV2Project(projectConfig.platformVersion)) {
-        let profileName = args.profile;
-        if (!profileName) {
-            const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
-            if (existingProfiles.length !== 0) {
-                profileName = await listPrompt(commands.project.dev.prompts.selectProfile, {
-                    choices: existingProfiles,
-                });
-            }
-        }
+    if (!targetProjectAccountId &&
+        !isLegacyProject(projectConfig.platformVersion)) {
+        const profileName = await projectProfilePrompt(projectDir, projectConfig, profileOption);
         if (profileName) {
             try {
-                profile = loadProfile(projectConfig, projectDir, profileName);
+                profile = await loadAndValidateProfile(projectConfig, projectDir, profileName);
                 targetProjectAccountId = profile.accountId;
                 uiLogger.log('');
                 uiLogger.log(commands.project.dev.logs.profileProjectAccountExplanation(targetProjectAccountId, profileName));
@@ -87,7 +82,7 @@ async function handler(args) {
             catch (error) {
                 logError(error);
                 uiLine();
-                process.exit(EXIT_CODES.ERROR);
+                return exit(EXIT_CODES.ERROR);
             }
         }
     }
@@ -99,9 +94,9 @@ async function handler(args) {
             uiLogger.log(commands.project.dev.logs.defaultProjectAccountExplanation(targetProjectAccountId));
         }
     }
-    trackCommandUsage('project-dev', {}, targetProjectAccountId);
+    addUsageMetadata({ accountId: targetProjectAccountId ?? undefined });
     try {
-        if (isV2Project(projectConfig.platformVersion)) {
+        if (!isLegacyProject(projectConfig.platformVersion)) {
             const targetTestingAccountId = testingAccount
                 ? getConfigAccountIfExists(testingAccount)?.accountId
                 : undefined;
@@ -124,11 +119,11 @@ async function handler(args) {
         }
     }
     catch (e) {
-        if (e instanceof PromptExitError) {
-            process.exit(e.exitCode);
+        if (isPromptExitError(e)) {
+            throw e;
         }
         logError(e);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
 }
 function projectDevBuilder(yargs) {
@@ -168,7 +163,7 @@ export const builder = makeYargsBuilder(projectDevBuilder, command, describe, {
 const projectDevCommand = {
     command,
     describe,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('project-dev', handler),
     builder,
 };
 export default projectDevCommand;

package/commands/project/dev/unifiedFlow.js

@@ -17,9 +17,13 @@ import { isTestAccountOrSandbox, isUnifiedAccount, } from '../../../lib/accountT
 import { uiLogger } from '../../../lib/ui/logger.js';
 import { commands } from '../../../lang/en.js';
 import LocalDevWebsocketServer from '../../../lib/projects/localDev/LocalDevWebsocketServer.js';
-import { confirmLocalDevIsNotRunning } from '../../../lib/projects/localDev/helpers/process.js';
+import { isLocalDevRunning } from '../../../lib/projects/localDev/helpers/process.js';
 export async function unifiedProjectDevFlow({ args, targetProjectAccountId, providedTargetTestingAccountId, projectConfig, projectDir, }) {
-    await confirmLocalDevIsNotRunning();
+    const { exit } = args;
+    if (await isLocalDevRunning()) {
+        uiLogger.error(commands.project.dev.errors.localDevAlreadyRunning);
+        return exit(EXIT_CODES.ERROR);
+    }
     const env = getConfigAccountEnvironment(targetProjectAccountId);
     let projectNodes;
     let projectProfileData;
@@ -41,23 +45,23 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         else {
             logError(e);
         }
-        return process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     if (!Object.keys(projectNodes).length) {
         uiLogger.error(commands.project.dev.errors.noRunnableComponents);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     const targetProjectAccountConfig = getConfigAccountById(targetProjectAccountId);
     if (!targetProjectAccountConfig) {
         uiLogger.error(commands.project.dev.errors.noAccount(targetProjectAccountId));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     const accounts = getAllConfigAccounts();
     const accountIsCombined = await isUnifiedAccount(targetProjectAccountConfig);
     const targetProjectAccountIsTestAccountOrSandbox = isTestAccountOrSandbox(targetProjectAccountConfig);
     if (!accountIsCombined) {
         uiLogger.error(commands.project.dev.errors.accountNotCombined);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     let targetTestingAccountId = providedTargetTestingAccountId;
     // Temporarily removing logic to use profile account as testing account
@@ -82,11 +86,19 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
             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 useExistingDevTestAccount(env, devAccountPromptResponse.notInConfigAccount);
+                const accountAdded = await useExistingDevTestAccount(env, devAccountPromptResponse.notInConfigAccount);
+                if (!accountAdded) {
+                    return exit(EXIT_CODES.SUCCESS);
+                }
             }
             else if (devAccountPromptResponse.createNestedAccount) {
                 // Create a new developer test account and automatically add it to the CLI config
-                targetTestingAccountId = await createDeveloperTestAccountForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env, true);
+                try {
+                    targetTestingAccountId = await createDeveloperTestAccountForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env, true);
+                }
+                catch {
+                    return exit(EXIT_CODES.ERROR);
+                }
             }
         }
         else if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
@@ -94,7 +106,12 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
             targetTestingAccountId =
                 sandboxAccountPromptResponse.targetAccountId || undefined;
             if (sandboxAccountPromptResponse.createNestedAccount) {
-                targetTestingAccountId = await createSandboxForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env);
+                try {
+                    targetTestingAccountId = await createSandboxForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env);
+                }
+                catch {
+                    return exit(EXIT_CODES.ERROR);
+                }
             }
         }
         else {
@@ -111,21 +128,26 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
     });
     let project = uploadedProject;
     if (projectExists && project) {
-        await compareLocalProjectToDeployed(projectConfig, targetProjectAccountId, project.deployedBuild?.buildId, projectNodes, args.profile);
+        await compareLocalProjectToDeployed(projectConfig, targetProjectAccountId, project.deployedBuild?.buildId, projectNodes, exit, args.profile);
     }
     else {
-        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, false, false);
-        await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId, true, args.profile);
+        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, false, false, exit);
+        await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId, exit, true, args.profile);
     }
     // Check for missing/outdated dependencies
-    await checkAndInstallDependencies();
+    try {
+        await checkAndInstallDependencies();
+    }
+    catch {
+        return exit(EXIT_CODES.ERROR);
+    }
     // End setup, start local dev process
     try {
         await startPortManagerServer();
     }
     catch (e) {
         logError(e);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     const localDevProcess = new LocalDevProcess({
         initialProjectNodes: projectNodes,
@@ -138,6 +160,7 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         projectDir,
         projectData: project,
         env,
+        actions: { exit },
     });
     const websocketServer = new LocalDevWebsocketServer(localDevProcess, args.debug);
     const watcher = new LocalDevWatcher(localDevProcess);

package/commands/project/download.js

@@ -3,25 +3,24 @@ import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
 import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
 import { downloadProject, fetchProjectBuilds, } from '@hubspot/local-dev-lib/api/projects';
 import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
-import { PromptExitError } from '../../lib/errors/PromptExitError.js';
+import { isPromptExitError } from '../../lib/errors/PromptExitError.js';
 import { getProjectConfig } from '../../lib/projects/config.js';
 import { downloadProjectPrompt } from '../../lib/prompts/downloadProjectPrompt.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsHandlerWithUsageTracking } from '../../lib/yargs/makeYargsHandlerWithUsageTracking.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 const command = 'download';
 const describe = commands.project.download.describe;
 async function handler(args) {
+    const { dest, build, derivedAccountId, exit } = args;
     const { projectConfig } = await getProjectConfig();
     if (projectConfig) {
         uiLogger.error(commands.project.download.warnings.cannotDownloadWithinProject);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    const { dest, build, derivedAccountId } = args;
     let buildNumberToDownload = build;
-    trackCommandUsage('project-download', undefined, derivedAccountId);
     try {
         const { project: projectName } = await downloadProjectPrompt(args);
         if (!buildNumberToDownload) {
@@ -34,7 +33,7 @@ async function handler(args) {
         }
         if (!buildNumberToDownload) {
             uiLogger.error(commands.project.download.errors.noBuildIdToDownload);
-            process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
         const sanitizedProjectName = sanitizeFileName(projectName);
         const absoluteDestPath = dest
@@ -43,17 +42,17 @@ async function handler(args) {
         const { data: zippedProject } = await downloadProject(derivedAccountId, projectName, buildNumberToDownload);
         await extractZipArchive(zippedProject, sanitizeFileName(projectName), path.resolve(absoluteDestPath));
         uiLogger.log(commands.project.download.logs.downloadSucceeded(buildNumberToDownload, projectName));
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     catch (e) {
-        if (e instanceof PromptExitError) {
-            process.exit(e.exitCode);
+        if (isPromptExitError(e)) {
+            throw e;
         }
         logError(e, new ApiErrorContext({
             accountId: derivedAccountId,
             request: 'project download',
         }));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
 }
 function projectDownloadBuilder(yargs) {
@@ -89,7 +88,7 @@ const builder = makeYargsBuilder(projectDownloadBuilder, command, describe, {
 const projectDownloadCommand = {
     command,
     describe,
-    handler,
+    handler: makeYargsHandlerWithUsageTracking('project-download', handler),
     builder,
 };
 export default projectDownloadCommand;