@hubspot/cli 8.2.0-beta.0 → 8.2.0-experimental.1

package/lib/projects/delete.js

@@ -0,0 +1,193 @@
+import { fetchProjects, fetchProject, stageProjectForDeletion, getDeployStatus, deleteProject, } from '@hubspot/local-dev-lib/api/projects';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { debugError, getErrorMessage } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { commands } from '../../lang/en.js';
+import { confirmPrompt, listPrompt } from '../prompts/promptUtils.js';
+import { poll, DEFAULT_POLLING_STATES, DEFAULT_POLLING_STATUS_LOOKUP, } from '../polling.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
+import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { COMPONENT_TYPES, SUBCOMPONENT_TYPES, } from '@hubspot/local-dev-lib/enums/build';
+export const DELETION_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+export const DELETION_DEPLOY_SUCCESS_STATES = [
+    DEFAULT_POLLING_STATES.SUCCESS,
+    'FINISHED',
+];
+export const DELETION_DEPLOY_ERROR_STATES = DEFAULT_POLLING_STATUS_LOOKUP.errorStates;
+const LEGACY_COMPONENTS_TO_FILTER = [
+    SUBCOMPONENT_TYPES.SERVERLESS_PKG,
+    SUBCOMPONENT_TYPES.REACT_EXTENSION,
+    SUBCOMPONENT_TYPES.PACKAGE_LOCK_FILE,
+    COMPONENT_TYPES.PRIVATE_APP,
+    COMPONENT_TYPES.PUBLIC_APP,
+];
+const legacyComponentFriendlyNames = {
+    [SUBCOMPONENT_TYPES.APP_ID]: 'Private App',
+    [SUBCOMPONENT_TYPES.PUBLIC_APP_ID]: 'Public App',
+    [SUBCOMPONENT_TYPES.CRM_CARD_V2]: 'Card',
+    [SUBCOMPONENT_TYPES.CARD_V2]: 'Card',
+    [SUBCOMPONENT_TYPES.SERVERLESS_FUNCTION]: 'Serverless Function',
+    [SUBCOMPONENT_TYPES.APP_FUNCTION]: 'App Function',
+    [SUBCOMPONENT_TYPES.AUTOMATION_ACTION]: 'Automation Action',
+    [SUBCOMPONENT_TYPES.WEBHOOKS]: 'Webhooks',
+    [COMPONENT_TYPES.THEME]: 'Theme',
+    [COMPONENT_TYPES.REACT_THEME]: 'React Theme',
+};
+function mapLegacyComponentToUserFriendlyName(type) {
+    return legacyComponentFriendlyNames[type] || 'unknown';
+}
+export async function resolveProjectName(accountId, projectArg) {
+    const { data } = await fetchProjects(accountId);
+    const projects = data.results;
+    if (projectArg) {
+        if (!projects.some(p => p.name === projectArg)) {
+            throw new Error(commands.project.delete.errors.projectNotFound(projectArg, accountId));
+        }
+        return projectArg;
+    }
+    if (projects.length === 0) {
+        throw new Error(commands.project.delete.errors.noProjectsFound(accountId));
+    }
+    const selected = await listPrompt(commands.project.delete.prompts.selectProject(accountId), {
+        choices: projects.map(p => ({ name: p.name, value: p.name })),
+        validate: value => !!value || commands.project.delete.prompts.validation.projectRequired,
+    });
+    if (!selected) {
+        throw new Error(commands.project.delete.prompts.validation.projectRequired);
+    }
+    return selected;
+}
+export async function fetchProjectInstallCount(accountId, projectId) {
+    try {
+        const { data } = await fetchPublicAppsForPortal(accountId);
+        return data.results
+            .filter(app => app.projectId === projectId)
+            .reduce((sum, app) => sum + app.publicApplicationInstallCounts.uniquePortalInstallCount, 0);
+    }
+    catch (e) {
+        debugError(e);
+        uiLogger.warn(commands.project.delete.logs.installCountUnknown);
+        return 0;
+    }
+}
+export async function checkDeployedComponents(accountId, projectName) {
+    const { data: projectData } = await fetchProject(accountId, projectName);
+    const platformVersion = projectData.deployedBuild?.platformVersion ||
+        projectData.latestBuild?.platformVersion;
+    if (!platformVersion) {
+        throw new Error(commands.project.delete.errors.noPlatformVersion);
+    }
+    if (isLegacyProject(platformVersion)) {
+        const userVisibleComponents = [];
+        projectData.deployedBuild?.subbuildStatuses?.forEach(item => {
+            if (LEGACY_COMPONENTS_TO_FILTER.includes(item.buildType)) {
+                return;
+            }
+            userVisibleComponents.push(`${item.buildName} - (${mapLegacyComponentToUserFriendlyName(item.buildType)})`);
+        });
+        if (userVisibleComponents.length > 0) {
+            uiLogger.log(commands.project.delete.logs.componentsToDeleteLegacy(userVisibleComponents));
+        }
+        return {
+            platformVersion,
+            hasUnifiedComponents: false,
+            projectId: projectData.id,
+        };
+    }
+    try {
+        const { data } = await stageProjectForDeletion(accountId, projectName, true);
+        if (data.hasDeployedComponents) {
+            const userVisibleComponents = data.componentsToRemove.filter(item => !AUTO_GENERATED_COMPONENT_TYPES.includes(mapToUserFacingType(item.componentType)));
+            uiLogger.log(commands.project.delete.logs.componentsToDeleteUnified(userVisibleComponents));
+        }
+        return {
+            hasUnifiedComponents: data.hasDeployedComponents,
+            platformVersion,
+            projectId: projectData.id,
+        };
+    }
+    catch (e) {
+        debugError(e);
+        throw new Error(commands.project.delete.errors.cannotDelete(projectName, getErrorMessage(e)));
+    }
+}
+export async function deleteDeployedComponents(accountId, projectName) {
+    SpinniesManager.add('removeComponents', {
+        text: commands.project.delete.logs.deletingComponents(projectName),
+    });
+    let projectDeletionResponse;
+    try {
+        const { data } = await stageProjectForDeletion(accountId, projectName, false);
+        projectDeletionResponse = data;
+    }
+    catch (e) {
+        debugError(e);
+        SpinniesManager.fail('removeComponents', {
+            text: commands.project.delete.errors.componentDeletionFailed(projectName),
+        });
+        throw new Error(commands.project.delete.errors.componentDeletionFailed(projectName));
+    }
+    const { deployId, hasDeployedComponents } = projectDeletionResponse;
+    if (deployId === undefined) {
+        if (hasDeployedComponents) {
+            SpinniesManager.fail('removeComponents', {
+                text: commands.project.delete.logs.unableToDetermineIfComponentsWereDeleted(projectName),
+            });
+            throw new Error(commands.project.delete.logs.unableToDetermineIfComponentsWereDeleted(projectName));
+        }
+        else {
+            SpinniesManager.succeed('removeComponents', {
+                text: commands.project.delete.logs.componentsDeleted(projectName),
+            });
+        }
+        return;
+    }
+    try {
+        await poll(() => getDeployStatus(accountId, projectName, deployId), {
+            successStates: DELETION_DEPLOY_SUCCESS_STATES,
+            errorStates: DELETION_DEPLOY_ERROR_STATES,
+        }, DELETION_POLL_TIMEOUT_MS);
+        SpinniesManager.succeed('removeComponents', {
+            text: commands.project.delete.logs.componentsDeleted(projectName),
+        });
+    }
+    catch (e) {
+        debugError(e);
+        SpinniesManager.fail('removeComponents', {
+            text: commands.project.delete.errors.componentDeletionFailed(projectName),
+        });
+        throw new Error(commands.project.delete.errors.componentDeletionFailed(projectName));
+    }
+}
+export async function handleProjectDeletion(accountId, projectName) {
+    try {
+        SpinniesManager.add('deleteProject', {
+            text: commands.project.delete.logs.deleting(projectName),
+        });
+        await deleteProject(accountId, projectName);
+        SpinniesManager.succeed('deleteProject', {
+            text: commands.project.delete.logs.deleted(projectName, accountId),
+        });
+    }
+    catch (e) {
+        SpinniesManager.fail('deleteProject', {
+            text: commands.project.delete.errors.deleteFailed(projectName),
+        });
+        throw e;
+    }
+}
+export async function confirmDeletion(projectName, accountId, projectId) {
+    const installCount = await fetchProjectInstallCount(accountId, projectId);
+    if (installCount > 0) {
+        uiLogger.warn(commands.project.delete.logs.installWarning(installCount));
+    }
+    const confirmed = await confirmPrompt(commands.project.delete.prompts.confirmDelete(projectName, accountId), { defaultAnswer: false });
+    if (!confirmed) {
+        uiLogger.log(commands.project.delete.logs.cancelled);
+        throw new PromptExitError(commands.project.delete.logs.cancelled, EXIT_CODES.SUCCESS);
+    }
+}

package/lib/projects/deploy.d.ts

@@ -10,4 +10,4 @@ export declare function logDeployErrors(errorData: {
         };
     }>;
 }): void;
-export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isV2Project: boolean, force: boolean): Promise<Deploy | undefined>;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isLegacyProject: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -47,9 +47,9 @@ function handleBlockedDeploy(deployResp) {
         uiLogger.log('');
     });
 }
-export async function handleProjectDeploy(targetAccountId, projectName, buildId, isV2Project, force) {
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, isLegacyProject, force) {
     let deployId;
-    if (isV2Project) {
+    if (!isLegacyProject) {
         const { data: deployResp } = await deployProjectV2(targetAccountId, projectName, buildId, force);
         if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
             if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {

package/lib/projects/localDev/AppDevModeInterface.js

@@ -6,6 +6,7 @@ import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { isAppIRNode } from '../../projects/structure.js';
 import { uiLine } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
+import { isPromptExitError } from '../../errors/PromptExitError.js';
 import { installAppAutoPrompt, installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
 import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { lib } from '../../../lang/en.js';
@@ -27,7 +28,7 @@ class AppDevModeInterface {
             !this.localDevState.projectConfig ||
             !this.localDevState.projectDir) {
             uiLogger.error(lib.LocalDevManager.failedToInitialize);
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.LocalDevManager.failedToInitialize);
         }
     }
     getAppNodeFromProjectNodes(projectNodes) {
@@ -45,12 +46,12 @@ class AppDevModeInterface {
         // App data will never be accessed before being set
         if (!this.appNode) {
             uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.AppDevModeInterface.appDataNotFound);
         }
         const data = this.localDevState.getAppDataByUid(this.appNode.uid);
         if (!data) {
             uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.AppDevModeInterface.appDataNotFound);
         }
         return data;
     }
@@ -107,7 +108,7 @@ class AppDevModeInterface {
                 text: lib.AppDevModeInterface.fetchAppData.error,
             });
             logError(e);
-            process.exit(EXIT_CODES.ERROR);
+            return this.localDevState.actions.exit(EXIT_CODES.ERROR);
         }
         if (!appData) {
             return;
@@ -135,7 +136,7 @@ class AppDevModeInterface {
         uiLine();
         const proceed = await confirmPrompt(lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
         if (!proceed) {
-            process.exit(EXIT_CODES.SUCCESS);
+            return this.localDevState.actions.exit(EXIT_CODES.SUCCESS);
         }
         this.localDevState.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
     }
@@ -155,7 +156,7 @@ class AppDevModeInterface {
         const shouldInstall = await installAppAutoPrompt();
         if (!shouldInstall) {
             uiLogger.log(lib.AppDevModeInterface.autoInstallDeclined);
-            process.exit(EXIT_CODES.SUCCESS);
+            return this.localDevState.actions.exit(EXIT_CODES.SUCCESS);
         }
         uiLogger.log('');
         SpinniesManager.add('autoInstallStaticAuthApp', {
@@ -224,7 +225,7 @@ class AppDevModeInterface {
         if (!serverIsRunningAtRedirectUrl) {
             uiLogger.log('');
             uiLogger.error(lib.AppDevModeInterface.oauthAppRedirectUrlError(redirectUrl));
-            process.exit(EXIT_CODES.ERROR);
+            return this.localDevState.actions.exit(EXIT_CODES.ERROR);
         }
     }
     resolveAppInstallPromise() {
@@ -245,7 +246,7 @@ class AppDevModeInterface {
     }
     handleAppInstallFailureDevServerMessage() {
         uiLogger.error(lib.AppDevModeInterface.installationFailed);
-        process.exit(EXIT_CODES.ERROR);
+        this.localDevState.actions.exit(EXIT_CODES.ERROR);
     }
     onDevServerMessage = async (message) => {
         if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
@@ -313,6 +314,9 @@ class AppDevModeInterface {
             }
         }
         catch (e) {
+            if (isPromptExitError(e)) {
+                throw e;
+            }
             if (SpinniesManager.pick('fetchAppData')) {
                 SpinniesManager.fail('fetchAppData', {
                     text: lib.AppDevModeInterface.fetchAppData.error,
@@ -320,7 +324,7 @@ class AppDevModeInterface {
                 });
             }
             logError(e);
-            process.exit(EXIT_CODES.ERROR);
+            return this.localDevState.actions.exit(EXIT_CODES.ERROR);
         }
     }
     async start() {

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

@@ -1,4 +1,5 @@
 import { ProjectConfig, ComponentTypes, Component } from '../../../types/Projects.js';
+import { ExitFunction } from '../../../types/Yargs.js';
 type DevServerInterface = {
     setup?: Function;
     start?: (options: object) => Promise<void>;
@@ -20,11 +21,13 @@ declare class DevServerManager_DEPRECATED {
         [key: string]: Component;
     }) => Promise<void>): Promise<void>;
     arrangeComponentsByType(components: Component[]): ComponentsByType;
-    setup({ components, onUploadRequired, accountId, setActiveApp, }: {
+    setup({ components, onUploadRequired, accountId, setActiveApp, exit, port, }: {
         components: Component[];
         onUploadRequired: () => void;
         accountId: number;
         setActiveApp: (appUid: string | undefined) => Promise<void>;
+        exit: ExitFunction;
+        port?: number;
     }): Promise<void>;
     start({ accountId, projectConfig, }: {
         accountId: number;

package/lib/projects/localDev/DevServerManager_DEPRECATED.js

@@ -57,7 +57,7 @@ class DevServerManager_DEPRECATED {
             return acc;
         }, {});
     }
-    async setup({ components, onUploadRequired, accountId, setActiveApp, }) {
+    async setup({ components, onUploadRequired, accountId, setActiveApp, exit, port, }) {
         this.componentsByType = this.arrangeComponentsByType(components);
         let env;
         const accountConfig = getConfigAccountById(accountId);
@@ -65,11 +65,11 @@ class DevServerManager_DEPRECATED {
             env = accountConfig.env;
         }
         try {
-            await startPortManagerServer();
+            await startPortManagerServer(port);
         }
         catch (e) {
             logError(e);
-            process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
         await this.iterateDevServers(async (serverInterface, compatibleComponents) => {
             if (serverInterface.setup) {

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

@@ -1,14 +1,17 @@
 import LocalDevLogger from './LocalDevLogger.js';
+import { ExitFunction } from '../../../types/Yargs.js';
 type DevSessionManagerConstructorOptions = {
     targetTestingAccountId: number;
     localDevLogger?: LocalDevLogger;
+    exit: ExitFunction;
 };
 declare class DevSessionManager {
     localDevLogger?: LocalDevLogger;
     targetTestingAccountId: number;
-    protected _devSessionId: number | undefined;
-    private _heartbeatInterval;
-    private _heartbeatRetries;
+    protected devSessionId: number | undefined;
+    private heartbeatInterval;
+    private heartbeatRetries;
+    private exit;
     constructor(options: DevSessionManagerConstructorOptions);
     private validateSessionIdExists;
     registerSession(): Promise<boolean>;

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();