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

package/lib/middleware/autoUpdateMiddleware.js

@@ -42,6 +42,10 @@ export async function autoUpdateCLI(argv) {
         debugError(e);
     }
     const cliUpgradeInfo = getCliUpgradeInfo();
+    // Ignore all update notifications if the current version is a pre-release (contains a hyphen)
+    if (cliUpgradeInfo.current && cliUpgradeInfo.current.includes('-')) {
+        showManualInstallHelp = false;
+    }
     if (isAllowAutoUpdatesEnabled &&
         cliUpgradeInfo.current &&
         cliUpgradeInfo.latest &&
@@ -49,9 +53,8 @@ export async function autoUpdateCLI(argv) {
         !argv.useEnv &&
         !process.env.SKIP_HUBSPOT_CLI_AUTO_UPDATES &&
         !preventAutoUpdateForCommand(argv._)) {
-        // Ignore all update notifications if the current version is a pre-release (contains a hyphen)
-        if (cliUpgradeInfo.current.includes('-')) {
-            showManualInstallHelp = false;
+        if (!showManualInstallHelp) {
+            // Pre-release version detected, skip auto-update
         }
         else if (!['major', 'latest'].includes(cliUpgradeInfo.type)) {
             // type "latest" => current installed version is latest

package/lib/process.d.ts

@@ -8,6 +8,6 @@ interface KeyPress {
 export declare const TERMINATION_SIGNALS: string[];
 export declare function handleExit(callback: (onTerminate: {
     isSIGHUP: boolean;
-}) => void): void;
+}) => void): () => void;
 export declare function handleKeypress(callback: (onKeyPress: KeyPress) => void): void;
 export {};

package/lib/process.js

@@ -16,9 +16,9 @@ export const TERMINATION_SIGNALS = [
 ];
 export function handleExit(callback) {
     let exitInProgress = false;
+    const listeners = [];
     TERMINATION_SIGNALS.forEach(signal => {
-        process.removeAllListeners(signal);
-        process.on(signal, async (...args) => {
+        const handler = async (...args) => {
             // Prevent duplicate exit handling
             if (!exitInProgress) {
                 exitInProgress = true;
@@ -38,8 +38,15 @@ export function handleExit(callback) {
                 }
                 await callback({ isSIGHUP });
             }
-        });
+        };
+        listeners.push({ signal, handler });
+        process.on(signal, handler);
     });
+    return () => {
+        for (const { signal, handler } of listeners) {
+            process.removeListener(signal, handler);
+        }
+    };
 }
 export function handleKeypress(callback) {
     readline.createInterface(process.stdin, process.stdout);

package/lib/projects/ProjectLogsManager.js

@@ -4,7 +4,7 @@ import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/proje
 import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
 import { uiLogger } from '../ui/logger.js';
 import { commands } from '../../lang/en.js';
-import { isV2Project } from './platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { getDeployedProjectNodes } from './localDev/helpers/project.js';
 import { debugError } from '../errorHandlers/index.js';
 class _ProjectLogsManager {
@@ -51,7 +51,7 @@ class _ProjectLogsManager {
             throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
         }
         this.projectId = project.id;
-        if (isV2Project(projectConfig.platformVersion)) {
+        if (!isLegacyProject(projectConfig.platformVersion)) {
             const deployedBuildId = project.deployedBuild.buildId;
             if (!deployedBuildId) {
                 throw new Error(commands.project.logs.errors.noDeployedBuild);

package/lib/projects/create/index.js

@@ -1,7 +1,7 @@
 import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
 import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
-import { isV2Project } from '../platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { v2ComponentFlow } from './v2.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
 import { commands } from '../../../lang/en.js';
@@ -9,7 +9,7 @@ export async function handleProjectCreationFlow(args) {
     const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
     const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
-    if (isV2Project(platformVersion)) {
+    if (!isLegacyProject(platformVersion)) {
         const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
         const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
         return {

package/lib/projects/create/legacy.js

@@ -1,13 +1,13 @@
 import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
 import { debugError } from '../../errorHandlers/index.js';
-import { isV2Project } from '../platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { lib } from '../../../lang/en.js';
 const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
 export async function getConfigForPlatformVersion(platformVersion) {
     let path = '';
-    if (isV2Project(platformVersion)) {
+    if (!isLegacyProject(platformVersion)) {
         path = `${platformVersion}/`;
     }
     const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, DEFAULT_PROJECT_TEMPLATE_BRANCH);

package/lib/projects/create/v2.js

@@ -1,8 +1,8 @@
 import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, FEATURES, } from '../../constants.js';
 import { commands, lib } from '../../../lang/en.js';
 import { listPrompt } from '../../prompts/promptUtils.js';
-import { APP_EVENTS_KEY as AppEventsKey, PAGES_KEY as PagesKey, } from '@hubspot/project-parsing-lib/constants';
-import { isV2Project } from '../platformVersion.js';
+import { APP_EVENTS_KEY as AppEventsKey } from '@hubspot/project-parsing-lib/constants';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import path from 'path';
 import { getConfigForPlatformVersion } from './legacy.js';
 import { hasFeature } from '../../hasFeature.js';
@@ -47,7 +47,6 @@ export async function createV2App(providedAuth, providedDistribution) {
 }
 const componentTypeToGateMap = {
     [AppEventsKey]: FEATURES.APP_EVENTS,
-    [PagesKey]: FEATURES.APPS_HOME,
     'workflow-action-tool': FEATURES.AGENT_TOOLS,
 };
 export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
@@ -135,7 +134,7 @@ export async function v2ComponentFlow(platformVersion, projectBase, providedAuth
     };
 }
 export function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
-    if (!isV2Project(platformVersion)) {
+    if (isLegacyProject(platformVersion)) {
         return [];
     }
     const components = selectProjectTemplatePromptResponse.componentTemplates?.map((componentTemplate) => {

package/lib/projects/delete.d.ts

@@ -0,0 +1,13 @@
+export declare const DELETION_POLL_TIMEOUT_MS: number;
+export declare const DELETION_DEPLOY_SUCCESS_STATES: string[];
+export declare const DELETION_DEPLOY_ERROR_STATES: ("FAILURE" | "ERROR" | "REVERTED")[];
+export declare function resolveProjectName(accountId: number, projectArg: string | undefined): Promise<string>;
+export declare function fetchProjectInstallCount(accountId: number, projectId: number): Promise<number>;
+export declare function checkDeployedComponents(accountId: number, projectName: string): Promise<{
+    platformVersion: string;
+    hasUnifiedComponents: boolean;
+    projectId: number;
+}>;
+export declare function deleteDeployedComponents(accountId: number, projectName: string): Promise<void>;
+export declare function handleProjectDeletion(accountId: number, projectName: string): Promise<void>;
+export declare function confirmDeletion(projectName: string, accountId: number, projectId: number): Promise<void>;

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,7 +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 { PromptExitError } from '../../errors/PromptExitError.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';
@@ -28,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) {
@@ -46,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;
     }
@@ -108,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;
@@ -136,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));
     }
@@ -156,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', {
@@ -225,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() {
@@ -246,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) {
@@ -314,7 +314,7 @@ class AppDevModeInterface {
             }
         }
         catch (e) {
-            if (e instanceof PromptExitError) {
+            if (isPromptExitError(e)) {
                 throw e;
             }
             if (SpinniesManager.pick('fetchAppData')) {
@@ -324,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,12 @@ 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, }: {
         components: Component[];
         onUploadRequired: () => void;
         accountId: number;
         setActiveApp: (appUid: string | undefined) => Promise<void>;
+        exit: ExitFunction;
     }): 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, }) {
         this.componentsByType = this.arrangeComponentsByType(components);
         let env;
         const accountConfig = getConfigAccountById(accountId);
@@ -69,7 +69,7 @@ class DevServerManager_DEPRECATED {
         }
         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,7 @@ type LocalDevManagerConstructorOptions = {
     isGithubLinked: boolean;
     runnableComponents: Component[];
     env: Environment;
+    exit: ExitFunction;
 };
 declare class LocalDevManager_DEPRECATED {
     targetAccountId: number;
@@ -36,6 +38,7 @@ declare class LocalDevManager_DEPRECATED {
     projectSourceDir: string;
     mostRecentUploadWarning: string | null;
     private devSessionManager;
+    private exit;
     constructor(options: LocalDevManagerConstructorOptions);
     setActiveApp(appUid?: string): Promise<void>;
     setActivePublicAppData(): Promise<void>;