@hubspot/cli 8.1.0 → 8.1.1-experimental.0

package/lib/projects/localDev/DevSessionManager.js

@@ -7,18 +7,20 @@ import { getErrorMessage } from '../../errorHandlers/index.js';
 class DevSessionManager {
     localDevLogger;
     targetTestingAccountId;
-    _devSessionId;
-    _heartbeatInterval;
-    _heartbeatRetries;
+    devSessionId;
+    heartbeatInterval;
+    heartbeatRetries;
+    exit;
     constructor(options) {
         this.targetTestingAccountId = options.targetTestingAccountId;
         this.localDevLogger = options.localDevLogger;
-        this._devSessionId = undefined;
-        this._heartbeatInterval = undefined;
-        this._heartbeatRetries = 0;
+        this.exit = options.exit;
+        this.devSessionId = undefined;
+        this.heartbeatInterval = undefined;
+        this.heartbeatRetries = 0;
     }
     validateSessionIdExists() {
-        if (!this._devSessionId) {
+        if (!this.devSessionId) {
             if (this.localDevLogger) {
                 this.localDevLogger.devSessionMissingSessionIdError();
             }
@@ -26,7 +28,7 @@ class DevSessionManager {
                 // Fallback for deprecated local dev manager
                 uiLogger.error(lib.LocalDevManager.devSession.missingSessionIdError);
             }
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.LocalDevManager.devSession.missingSessionIdError);
         }
     }
     async registerSession() {
@@ -34,7 +36,7 @@ class DevSessionManager {
             const activeServers = await getActiveServers();
             const portData = Object.entries(activeServers).map(([serverId, port]) => ({ serverId, port }));
             const registerDevSessionResponse = await registerDevSession(this.targetTestingAccountId, portData);
-            this._devSessionId = registerDevSessionResponse.data.sessionId;
+            this.devSessionId = registerDevSessionResponse.data.sessionId;
         }
         catch (e) {
             if (this.localDevLogger) {
@@ -46,19 +48,29 @@ class DevSessionManager {
             }
             return false;
         }
-        this.validateSessionIdExists();
+        try {
+            this.validateSessionIdExists();
+        }
+        catch {
+            return this.exit(EXIT_CODES.ERROR);
+        }
         this.initializeHeartbeat();
         return true;
     }
     initializeHeartbeat() {
-        this._heartbeatInterval = setInterval(async () => {
-            this.validateSessionIdExists();
+        this.heartbeatInterval = setInterval(async () => {
+            try {
+                this.validateSessionIdExists();
+            }
+            catch {
+                return this.exit(EXIT_CODES.ERROR);
+            }
             try {
-                await devSessionHeartbeat(this.targetTestingAccountId, this._devSessionId);
+                await devSessionHeartbeat(this.targetTestingAccountId, this.devSessionId);
             }
             catch (e) {
-                if (this._heartbeatRetries < 3) {
-                    this._heartbeatRetries++;
+                if (this.heartbeatRetries < 3) {
+                    this.heartbeatRetries++;
                     return;
                 }
                 if (this.localDevLogger) {
@@ -68,15 +80,15 @@ class DevSessionManager {
                     // Fallback for deprecated local dev manager
                     uiLogger.error(lib.LocalDevManager.devSession.heartbeatError(getErrorMessage(e)));
                 }
-                process.exit(EXIT_CODES.ERROR);
+                return this.exit(EXIT_CODES.ERROR);
             }
         }, 30000);
     }
     async deleteDevSession() {
-        if (this._devSessionId) {
-            clearInterval(this._heartbeatInterval);
+        if (this.devSessionId) {
+            clearInterval(this.heartbeatInterval);
             try {
-                await deleteDevSession(this.targetTestingAccountId, this._devSessionId);
+                await deleteDevSession(this.targetTestingAccountId, this.devSessionId);
             }
             catch (e) {
                 if (this.localDevLogger) {

package/lib/projects/localDev/LocalDevManager_DEPRECATED.d.ts

@@ -3,6 +3,7 @@ import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { Component, ProjectConfig } from '../../../types/Projects.js';
+import { ExitFunction } from '../../../types/Yargs.js';
 type LocalDevManagerConstructorOptions = {
     targetAccountId: number;
     parentAccountId: number;
@@ -14,6 +15,8 @@ type LocalDevManagerConstructorOptions = {
     isGithubLinked: boolean;
     runnableComponents: Component[];
     env: Environment;
+    exit: ExitFunction;
+    port?: number;
 };
 declare class LocalDevManager_DEPRECATED {
     targetAccountId: number;
@@ -36,6 +39,8 @@ declare class LocalDevManager_DEPRECATED {
     projectSourceDir: string;
     mostRecentUploadWarning: string | null;
     private devSessionManager;
+    private exit;
+    private port?;
     constructor(options: LocalDevManagerConstructorOptions);
     setActiveApp(appUid?: string): Promise<void>;
     setActivePublicAppData(): Promise<void>;

package/lib/projects/localDev/LocalDevManager_DEPRECATED.js

@@ -15,6 +15,7 @@ import { componentIsApp, componentIsPublicApp, CONFIG_FILES, getAppCardConfigs,
 import { ComponentTypes, } from '../../../types/Projects.js';
 import { UI_COLORS, uiCommandReference, uiAccountDescription, uiLink, uiLine, } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
+import { isPromptExitError } from '../../errors/PromptExitError.js';
 import { installAppBrowserPrompt } from '../../prompts/installAppPrompt.js';
 import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { handleKeypress } from '../../process.js';
@@ -46,6 +47,8 @@ class LocalDevManager_DEPRECATED {
     projectSourceDir;
     mostRecentUploadWarning;
     devSessionManager;
+    exit;
+    port;
     constructor(options) {
         this.targetAccountId = options.targetAccountId;
         // The account that the project exists in. This is not always the targetAccountId
@@ -64,19 +67,22 @@ class LocalDevManager_DEPRECATED {
         this.env = options.env;
         this.publicAppActiveInstalls = null;
         this.mostRecentUploadWarning = null;
+        this.exit = options.exit;
+        this.port = options.port;
         this.projectSourceDir = path.join(this.projectDir, this.projectConfig.srcDir);
         if (!this.targetAccountId || !this.projectConfig || !this.projectDir) {
-            uiLogger.log(lib.LocalDevManager.failedToInitialize);
-            process.exit(EXIT_CODES.ERROR);
+            uiLogger.error(lib.LocalDevManager.failedToInitialize);
+            throw new Error(lib.LocalDevManager.failedToInitialize);
         }
         this.devSessionManager = new DevSessionManager({
             targetTestingAccountId: this.targetAccountId,
+            exit: this.exit,
         });
     }
     async setActiveApp(appUid) {
         if (!appUid) {
             uiLogger.error(lib.LocalDevManager.missingUid);
-            process.exit(EXIT_CODES.ERROR);
+            return this.exit(EXIT_CODES.ERROR);
         }
         this.activeApp =
             this.runnableComponents.find(component => {
@@ -89,6 +95,9 @@ class LocalDevManager_DEPRECATED {
                 await this.checkPublicAppInstallation();
             }
             catch (e) {
+                if (isPromptExitError(e)) {
+                    throw e;
+                }
                 logError(e);
             }
         }
@@ -118,7 +127,7 @@ class LocalDevManager_DEPRECATED {
         uiLine();
         const proceed = await confirmPrompt(lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
         if (!proceed) {
-            process.exit(EXIT_CODES.SUCCESS);
+            return this.exit(EXIT_CODES.SUCCESS);
         }
     }
     async start() {
@@ -128,11 +137,11 @@ class LocalDevManager_DEPRECATED {
         if (!this.deployedBuild) {
             uiLogger.error(lib.LocalDevManager.noDeployedBuild(this.projectConfig.name, uiAccountDescription(this.targetProjectAccountId), this.getUploadCommand()));
             uiLogger.log('');
-            process.exit(EXIT_CODES.SUCCESS);
+            return this.exit(EXIT_CODES.SUCCESS);
         }
         const setupSucceeded = await this.devServerSetup();
         if (!setupSucceeded) {
-            process.exit(EXIT_CODES.ERROR);
+            return this.exit(EXIT_CODES.ERROR);
         }
         else if (!this.debug) {
             console.clear();
@@ -152,7 +161,7 @@ class LocalDevManager_DEPRECATED {
         await this.devServerStart();
         const devSessionRegistered = await this.devSessionManager.registerSession();
         if (!devSessionRegistered) {
-            process.exit(EXIT_CODES.ERROR);
+            return this.exit(EXIT_CODES.ERROR);
         }
         // Initialize project file watcher to detect configuration file changes
         this.startWatching();
@@ -177,14 +186,14 @@ class LocalDevManager_DEPRECATED {
                     text: lib.LocalDevManager.exitingFail,
                 });
             }
-            process.exit(EXIT_CODES.ERROR);
+            return this.exit(EXIT_CODES.ERROR);
         }
         if (showProgress) {
             SpinniesManager.succeed('cleanupMessage', {
                 text: lib.LocalDevManager.exitingSucceed,
             });
         }
-        process.exit(EXIT_CODES.SUCCESS);
+        return this.exit(EXIT_CODES.SUCCESS);
     }
     async checkPublicAppInstallation() {
         if (!componentIsPublicApp(this.activeApp) || !this.activePublicAppData) {
@@ -329,6 +338,8 @@ class LocalDevManager_DEPRECATED {
                 onUploadRequired: this.logUploadWarning.bind(this),
                 accountId: this.targetAccountId,
                 setActiveApp: this.setActiveApp.bind(this),
+                exit: this.exit,
+                port: this.port,
             });
             return true;
         }
@@ -352,7 +363,7 @@ class LocalDevManager_DEPRECATED {
                 uiLogger.error(getErrorMessage(e));
             }
             uiLogger.error(lib.LocalDevManager.devServer.startError(getErrorMessage(e)));
-            process.exit(EXIT_CODES.ERROR);
+            return this.exit(EXIT_CODES.ERROR);
         }
     }
     devServerFileChange(filePath, event) {

package/lib/projects/localDev/LocalDevProcess.js

@@ -32,6 +32,7 @@ class LocalDevProcess {
         this.devSessionManager = new DevSessionManager({
             targetTestingAccountId: this.state.targetTestingAccountId,
             localDevLogger: this._logger,
+            exit: this.state.actions.exit,
         });
     }
     get projectDir() {
@@ -68,7 +69,7 @@ class LocalDevProcess {
         }
         catch (e) {
             this.logger.devServerStartError(e);
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
         }
     }
     async cleanupDevServers() {
@@ -148,7 +149,7 @@ class LocalDevProcess {
         this.logger.resetSpinnies();
         const setupSucceeded = await this.setupDevServers();
         if (!setupSucceeded) {
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
         }
         this.logger.startupMessage();
         if (isConfigFlagEnabled(CONFIG_FLAGS.AUTO_OPEN_BROWSER, true)) {
@@ -157,7 +158,7 @@ class LocalDevProcess {
         await this.startDevServers();
         const devSessionRegistered = await this.devSessionManager.registerSession();
         if (!devSessionRegistered) {
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
         }
         this.state.devServersStarted = true;
         this.logger.monitorConsoleOutput();
@@ -172,12 +173,12 @@ class LocalDevProcess {
             if (showProgress) {
                 this.logger.cleanupError();
             }
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
         }
         if (showProgress) {
             this.logger.cleanupSuccess();
         }
-        process.exit(EXIT_CODES.SUCCESS);
+        return this.state.actions.exit(EXIT_CODES.SUCCESS);
     }
     async uploadProject() {
         this.logger.uploadInitiated();

package/lib/projects/localDev/LocalDevState.d.ts

@@ -3,7 +3,7 @@ import type { HSProfileVariables } from '@hubspot/project-parsing-lib/profiles';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { ProjectConfig } from '../../../types/Projects.js';
-import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev.js';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevActions, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev.js';
 declare class LocalDevState {
     private _targetProjectAccountId;
     private _targetTestingAccountId;
@@ -21,7 +21,8 @@ declare class LocalDevState {
     private _devServerMessage;
     private _uploadWarnings;
     private _devServersStarted;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
+    actions: LocalDevActions;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, actions, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;

package/lib/projects/localDev/LocalDevState.js

@@ -16,7 +16,8 @@ class LocalDevState {
     _devServerMessage;
     _uploadWarnings;
     _devServersStarted;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
+    actions;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, actions, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._profile = profile;
@@ -32,6 +33,7 @@ class LocalDevState {
         this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
         this._uploadWarnings = new Set();
         this._devServersStarted = false;
+        this.actions = actions;
         this._listeners = {};
     }
     runListeners(key) {

package/lib/projects/localDev/helpers/account.d.ts

@@ -2,13 +2,14 @@ import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
 import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
-export declare function confirmDefaultAccountIsTarget(accountConfig: HubSpotConfigAccount): Promise<void>;
-export declare function checkIfDefaultAccountIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<void>;
+import { ExitFunction } from '../../../../types/Yargs.js';
+export declare function confirmDefaultAccountIsTarget(accountConfig: HubSpotConfigAccount, exit: ExitFunction): Promise<void>;
+export declare function checkIfDefaultAccountIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean, exit: ExitFunction): Promise<void>;
 export declare function checkIfParentAccountIsAuthed(accountConfig: HubSpotConfigAccount): void;
 export declare function checkIfAccountFlagIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): void;
 export declare function suggestRecommendedNestedAccount(accounts: HubSpotConfigAccount[], accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment): Promise<number>;
 export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment, useV2?: boolean): Promise<number>;
-export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
+export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<boolean>;
 export declare function hasSandboxes(account: HubSpotConfigAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: HubSpotConfigAccount): Promise<string | null>;

package/lib/projects/localDev/helpers/account.js

@@ -1,5 +1,5 @@
 import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
-import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
@@ -18,65 +18,60 @@ import { selectDeveloperTestTargetAccountPrompt } from '../../../prompts/project
 import { selectSandboxTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
 import { validateSandboxUsageLimits } from '../../../sandboxes.js';
 import { logError } from '../../../errorHandlers/index.js';
-import { syncSandbox } from '../../../sandboxSync.js';
-import { getAvailableSyncTypes } from '../../../sandboxes.js';
 import { hubspotAccountNamePrompt } from '../../../prompts/accountNamePrompt.js';
 import { trackCommandMetadataUsage } from '../../../usageTracking.js';
 import { validateDevTestAccountUsageLimits } from '../../../developerTestAccounts.js';
-import { buildSandbox, buildDeveloperTestAccount, saveAccountToConfig, } from '../../../buildAccount.js';
+import { buildDeveloperTestAccount, saveAccountToConfig, buildV2Sandbox, } from '../../../buildAccount.js';
 import { debugError } from '../../../errorHandlers/index.js';
 import { listPrompt } from '../../../prompts/promptUtils.js';
 import { confirmUseExistingDeveloperTestAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
 // If the user passed in the --account flag, confirm they want to use that account as
 // their target account, otherwise exit
-export async function confirmDefaultAccountIsTarget(accountConfig) {
+export async function confirmDefaultAccountIsTarget(accountConfig, exit) {
     if (!accountConfig.name || !accountConfig.accountType) {
         uiLogger.error(lib.localDevHelpers.account.confirmDefaultAccountIsTarget.configError);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     uiLogger.log('');
     const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
     if (!useDefaultAccount) {
         uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
 }
 // Confirm the default account is supported for the type of apps being developed
-export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
+export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps, exit) {
     const defaultAccountIsUnified = await isUnifiedAccount(accountConfig);
     if (hasPublicApps &&
         !(isAppDeveloperAccount(accountConfig) ||
             isDeveloperTestAccount(accountConfig) ||
             defaultAccountIsUnified)) {
         uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
         uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.privateApp);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
 }
 export function checkIfParentAccountIsAuthed(accountConfig) {
     if (!accountConfig.parentAccountId ||
         !getConfigAccountIfExists(accountConfig.parentAccountId)?.accountId) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(accountConfig.accountId)));
-        process.exit(EXIT_CODES.SUCCESS);
+        throw new Error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(accountConfig.accountId)));
     }
 }
 // Confirm the default account is a developer account if developing public apps
 export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
     if (hasPublicApps) {
         if (!isDeveloperTestAccount(accountConfig)) {
-            uiLogger.error(lib.localDevHelpers.account.validateAccountOption
+            throw new Error(lib.localDevHelpers.account.validateAccountOption
                 .invalidPublicAppAccount);
-            process.exit(EXIT_CODES.SUCCESS);
         }
         checkIfParentAccountIsAuthed(accountConfig);
     }
     else if (isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
-        process.exit(EXIT_CODES.SUCCESS);
+        throw new Error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
     }
 }
 // If the user isn't using the recommended account type, prompt them to use or create one
@@ -112,24 +107,20 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
         else {
             logError(err);
         }
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
     try {
         const { name } = await hubspotAccountNamePrompt({
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         });
         trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
-        const result = await buildSandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
-        const targetAccountId = result.sandbox.sandboxHubId;
-        const sandboxAccountConfig = getConfigAccountById(result.sandbox.sandboxHubId);
-        const syncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
-        // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
-        await syncSandbox(sandboxAccountConfig, accountConfig, env, syncTasks, true);
-        return targetAccountId;
+        const result = await buildV2Sandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, // syncObjectRecords
+        env);
+        return result.sandbox.sandboxHubId;
     }
     catch (err) {
         logError(err);
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
 }
 // Create a developer test account and return its accountId
@@ -155,7 +146,7 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
         else {
             logError(err);
         }
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
     try {
         const { name } = await hubspotAccountNamePrompt({
@@ -163,12 +154,11 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         });
         trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
-        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
-        return result;
+        return await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
     }
     catch (err) {
         logError(err);
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
 }
 // Prompt user to confirm usage of an existing developer test account that is not currently in the config
@@ -179,10 +169,11 @@ export async function useExistingDevTestAccount(env, account) {
         uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
         uiLogger.log('');
-        process.exit(EXIT_CODES.SUCCESS);
+        return false;
     }
     const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
     uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
+    return true;
 }
 export async function hasSandboxes(account) {
     const accountId = account.accountId;

package/lib/projects/localDev/helpers/process.d.ts

@@ -1 +1 @@
-export declare function confirmLocalDevIsNotRunning(): Promise<void>;
+export declare function isLocalDevRunning(): Promise<boolean>;

package/lib/projects/localDev/helpers/process.js

@@ -1,17 +1,11 @@
 import { LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID } from '../../../constants.js';
-import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { getServerPortByInstanceId } from '@hubspot/local-dev-lib/portManager';
-import { uiLogger } from '../../../ui/logger.js';
-import { commands } from '../../../../lang/en.js';
-export async function confirmLocalDevIsNotRunning() {
+export async function isLocalDevRunning() {
     try {
         const existingPortInUse = await getServerPortByInstanceId(LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID);
-        if (existingPortInUse) {
-            uiLogger.error(commands.project.dev.errors.localDevAlreadyRunning);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        return Boolean(existingPortInUse);
     }
-    catch (error) {
-        return;
+    catch {
+        return false;
     }
 }

package/lib/projects/localDev/helpers/project.d.ts

@@ -2,11 +2,12 @@ import { type IntermediateRepresentationNode, type IntermediateRepresentationNod
 import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { ProjectConfig } from '../../../../types/Projects.js';
-export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
-export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
+import { ExitFunction } from '../../../../types/Yargs.js';
+export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean, exit: ExitFunction): Promise<Project>;
+export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, exit: ExitFunction, sendIR?: boolean, profile?: string): Promise<Build>;
 export declare function compareLocalProjectToDeployed(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number | undefined, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
-}, profile?: string): Promise<void>;
+}, exit: ExitFunction, profile?: string): Promise<void>;
 export declare function getDeployedProjectNodes(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, profile?: string): Promise<{
     [key: string]: IntermediateRepresentationNode;
 }>;