@hubspot/cli 8.0.10-experimental.4 → 8.0.10-experimental.5

package/lib/__tests__/buildAccount.test.js

@@ -1,7 +1,7 @@
 import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
 import { getConfigAccountIfExists, updateConfigAccount, } from '@hubspot/local-dev-lib/config';
 import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
-import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
 import { cliAccountNamePrompt } from '../prompts/accountNamePrompt.js';
@@ -32,7 +32,6 @@ const mockedCliAccountNamePrompt = cliAccountNamePrompt;
 const mockedCreateDeveloperTestAccount = createDeveloperTestAccount;
 const mockedFetchDeveloperTestAccountGateSyncStatus = fetchDeveloperTestAccountGateSyncStatus;
 const mockedGenerateDeveloperTestAccountPersonalAccessKey = generateDeveloperTestAccountPersonalAccessKey;
-const mockedCreateSandbox = createSandbox;
 const mockedCreateV2Sandbox = createV2Sandbox;
 const mockedGetPersonalAccessKey = getSandboxPersonalAccessKey;
 const mockedPoll = poll;
@@ -162,56 +161,6 @@ describe('lib/buildAccount', () => {
             await expect(buildAccount.buildDeveloperTestAccount(mockDeveloperTestAccount.accountName, mockParentAccountConfig, mockParentAccountConfig.env, 10)).rejects.toThrow();
         });
     });
-    describe('buildSandbox()', () => {
-        const mockParentAccountConfig = {
-            name: 'Prod account',
-            accountId: 123456,
-            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-            env: 'prod',
-        };
-        const mockSandbox = {
-            sandboxHubId: 56789,
-            parentHubId: 123456,
-            createdAt: '2025-01-01',
-            type: 'STANDARD',
-            version: 'V1',
-            archived: false,
-            name: 'Test Sandbox',
-            domain: 'test-sandbox.hubspot.com',
-            createdByUser: {
-                id: 123456,
-                email: 'test@test.com',
-                firstName: 'Test',
-                lastName: 'User',
-            },
-        };
-        beforeEach(() => {
-            vi.spyOn(buildAccount, 'saveAccountToConfig').mockResolvedValue(mockParentAccountConfig.name);
-            mockedCreateSandbox.mockResolvedValue({
-                data: { sandbox: mockSandbox, personalAccessKey: 'test-key' },
-            });
-        });
-        it('should create a standard sandbox successfully', async () => {
-            const result = await buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env, false);
-            expect(result).toEqual({
-                name: mockSandbox.name,
-                personalAccessKey: 'test-key',
-                sandbox: mockSandbox,
-            });
-        });
-        it('should create a development sandbox successfully', async () => {
-            const result = await buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, mockParentAccountConfig.env);
-            expect(result).toEqual({
-                name: mockSandbox.name,
-                personalAccessKey: 'test-key',
-                sandbox: mockSandbox,
-            });
-        });
-        it('should handle API errors when creating sandbox', async () => {
-            mockedCreateSandbox.mockRejectedValue(new Error('test-error'));
-            await expect(buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env, false)).rejects.toThrow();
-        });
-    });
     describe('buildV2Sandbox()', () => {
         const mockParentAccountConfig = {
             name: 'Prod account',

package/lib/__tests__/sandboxes.test.js

@@ -1,10 +1,9 @@
 import { uiLogger } from '../ui/logger.js';
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
 import { getAllConfigAccounts, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { mockHubSpotHttpError } from '../testUtils.js';
-import { getSandboxTypeAsString, getHasSandboxesByType, getAvailableSyncTypes, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
+import { getSandboxTypeAsString, getHasSandboxesByType, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
 import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
 vi.mock('@hubspot/local-dev-lib/api/sandboxHubs');
 vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
@@ -12,7 +11,6 @@ vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/errors/index');
 const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
 const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
-const mockedFetchTypes = fetchTypes;
 const mockedGetAllConfigAccounts = getAllConfigAccounts;
 const mockedUiLogger = uiLogger;
 const mockedIsMissingScopeError = isMissingScopeError;
@@ -53,32 +51,6 @@ describe('lib/sandboxes', () => {
             expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
         });
     });
-    describe('getAvailableSyncTypes()', () => {
-        const mockParentAccount = {
-            name: 'Parent Account',
-            accountId: 123,
-            env: 'qa',
-        };
-        const mockChildAccount = {
-            ...mockParentAccount,
-            accountId: 456,
-        };
-        it('returns available sync types when fetch is successful', async () => {
-            const mockSyncTypes = [{ name: 'type1' }, { name: 'type2' }];
-            mockedGetConfigAccountIfExists
-                .mockReturnValue(mockParentAccount.accountId)
-                .mockReturnValue(mockChildAccount.accountId);
-            mockedFetchTypes.mockResolvedValue({
-                data: { results: mockSyncTypes },
-            });
-            const result = await getAvailableSyncTypes(mockParentAccount, mockChildAccount);
-            expect(result).toEqual([{ type: 'type1' }, { type: 'type2' }]);
-        });
-        it('throws error when sync types fetch fails', async () => {
-            mockedFetchTypes.mockResolvedValue({ data: { results: null } });
-            await expect(getAvailableSyncTypes(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
-        });
-    });
     describe('validateSandboxUsageLimits()', () => {
         const mockAccount = {
             name: 'Test Account',

package/lib/accountAuth.js

@@ -3,6 +3,7 @@ import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev
 import { toKebabCase } from '@hubspot/local-dev-lib/text';
 import { handleMerge, handleMigration } from './configMigrate.js';
 import { debugError, logError } from './errorHandlers/index.js';
+import { PromptExitError } from './errors/PromptExitError.js';
 import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
 import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
 import { setAsDefaultAccountPrompt } from './prompts/setAsDefaultAccountPrompt.js';
@@ -36,6 +37,9 @@ async function updateConfigWithNewAccount(env, configAlreadyExists, providedPers
         return updatedConfig;
     }
     catch (e) {
+        if (e instanceof PromptExitError) {
+            throw e;
+        }
         debugError(e);
         return null;
     }

package/lib/app/__tests__/migrate.test.js

@@ -424,7 +424,7 @@ describe('lib/app/migrate', () => {
             };
             mockedPoll.mockResolvedValue(mockStatus);
             const result = await pollMigrationStatus(ACCOUNT_ID, MIGRATION_ID);
-            expect(mockedPoll).toHaveBeenCalledWith(expect.any(Function), expect.any(Object));
+            expect(mockedPoll).toHaveBeenCalledWith(expect.any(Function), expect.any(Object), 300_000);
             expect(result).toBe(mockStatus);
         });
     });

package/lib/app/migrate.js

@@ -255,7 +255,7 @@ export async function pollMigrationStatus(derivedAccountId, migrationId, success
     return poll(() => checkMigrationStatusV2(derivedAccountId, migrationId), {
         successStates: [...successStates],
         errorStates: [...DEFAULT_POLLING_STATUS_LOOKUP.errorStates],
-    });
+    }, 300_000);
 }
 export async function finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectName) {
     let pollResponse;

package/lib/buildAccount.d.ts

@@ -1,7 +1,7 @@
 import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxResponse, V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
+import { V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
 import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare function saveAccountToConfig(accountId: number | undefined, accountName: string, env: Environment, personalAccessKey?: string, force?: boolean): Promise<string>;
 export declare function createDeveloperTestAccountV2(parentAccountId: number, testAccountConfig: DeveloperTestAccountConfig): Promise<{
@@ -10,11 +10,6 @@ export declare function createDeveloperTestAccountV2(parentAccountId: number, te
     personalAccessKey?: string;
 }>;
 export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: HubSpotConfigAccount, env: Environment, portalLimit: number, useV2?: boolean): Promise<number>;
-type SandboxAccount = SandboxResponse & {
-    name: string;
-};
-export declare function buildSandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, env: Environment, force?: boolean): Promise<SandboxAccount>;
 export declare function buildV2Sandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, syncObjectRecords: boolean, env: Environment, force?: boolean): Promise<{
     sandbox: V2Sandbox;
 }>;
-export {};

package/lib/buildAccount.js

@@ -3,13 +3,14 @@ import { getConfigAccountIfExists, updateConfigAccount, } from '@hubspot/local-d
 import { uiLogger } from './ui/logger.js';
 import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { PromptExitError } from './errors/PromptExitError.js';
 import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
 import { createDeveloperTestAccountConfigPrompt } from './prompts/createDeveloperTestAccountConfigPrompt.js';
 import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { debugError, logError } from './errorHandlers/index.js';
-import { SANDBOX_API_TYPE_MAP, SANDBOX_TYPE_MAP_V2, handleSandboxCreateError, } from './sandboxes.js';
+import { SANDBOX_TYPE_MAP_V2, handleSandboxCreateError } from './sandboxes.js';
 import { handleDeveloperTestAccountCreateError } from './developerTestAccounts.js';
 import { lib } from '../lang/en.js';
 import { poll } from './polling.js';
@@ -127,51 +128,14 @@ export async function buildDeveloperTestAccount(testAccountName, parentAccountCo
         await saveAccountToConfig(developerTestAccountId, testAccountName, env, developerTestAccountPersonalAccessKey);
     }
     catch (err) {
+        if (err instanceof PromptExitError) {
+            throw err;
+        }
         logError(err);
         throw err;
     }
     return developerTestAccountId;
 }
-export async function buildSandbox(sandboxName, parentAccountConfig, sandboxType, env, force = false) {
-    const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
-        ? 'standard'
-        : 'developer';
-    const parentAccountId = parentAccountConfig.accountId;
-    if (!parentAccountId) {
-        throw new Error(lib.sandbox.create[sandboxTypeKey].loading.fail(''));
-    }
-    SpinniesManager.init({
-        succeedColor: 'white',
-    });
-    uiLogger.log('');
-    SpinniesManager.add('buildSandbox', {
-        text: lib.sandbox.create[sandboxTypeKey].loading.add(sandboxName),
-    });
-    let sandbox;
-    try {
-        const sandboxApiType = SANDBOX_API_TYPE_MAP[sandboxType];
-        const { data } = await createSandbox(parentAccountId, sandboxName, sandboxApiType);
-        sandbox = { name: sandboxName, ...data };
-        SpinniesManager.succeed('buildSandbox', {
-            text: lib.sandbox.create[sandboxTypeKey].loading.succeed(sandboxName, sandbox.sandbox.sandboxHubId.toString()),
-        });
-    }
-    catch (e) {
-        debugError(e);
-        SpinniesManager.fail('buildSandbox', {
-            text: lib.sandbox.create[sandboxTypeKey].loading.fail(sandboxName),
-        });
-        handleSandboxCreateError(e, env, sandboxName, parentAccountId);
-    }
-    try {
-        await saveAccountToConfig(sandbox.sandbox.sandboxHubId, sandboxName, env, sandbox.personalAccessKey, force);
-    }
-    catch (err) {
-        logError(err);
-        throw err;
-    }
-    return sandbox;
-}
 export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxType, syncObjectRecords, env, force = false) {
     const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
         ? 'standard'
@@ -210,6 +174,9 @@ export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxTy
         await saveAccountToConfig(sandbox.sandboxHubId, sandboxName, env, pak, force);
     }
     catch (err) {
+        if (err instanceof PromptExitError) {
+            throw err;
+        }
         logError(err);
         throw err;
     }

package/lib/constants.d.ts

@@ -77,8 +77,6 @@ export declare const APP_AUTH_TYPES: {
 };
 export declare const FEATURES: {
     readonly UNIFIED_APPS: "Developers:UnifiedApps:PrivateBeta";
-    readonly SANDBOXES_V2: "sandboxes:v2:enabled";
-    readonly SANDBOXES_V2_CLI: "sandboxes:v2:cliEnabled";
     readonly APP_EVENTS: "Developers:UnifiedApps:AppEventsAccess";
     readonly APPS_HOME: "UIE:AppHome";
     readonly THEME_MIGRATION_2025_2: "Developers:ProjectThemeMigrations:2025.2";

package/lib/constants.js

@@ -69,8 +69,6 @@ export const APP_AUTH_TYPES = {
 };
 export const FEATURES = {
     UNIFIED_APPS: 'Developers:UnifiedApps:PrivateBeta',
-    SANDBOXES_V2: 'sandboxes:v2:enabled',
-    SANDBOXES_V2_CLI: 'sandboxes:v2:cliEnabled',
     APP_EVENTS: 'Developers:UnifiedApps:AppEventsAccess',
     APPS_HOME: 'UIE:AppHome',
     THEME_MIGRATION_2025_2: 'Developers:ProjectThemeMigrations:2025.2',

package/lib/errors/PromptExitError.d.ts

@@ -0,0 +1,4 @@
+export declare class PromptExitError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode: number);
+}

package/lib/errors/PromptExitError.js

@@ -0,0 +1,8 @@
+export class PromptExitError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.name = 'PromptExitError';
+        this.exitCode = exitCode;
+    }
+}

package/lib/projects/__tests__/components.test.js

@@ -174,6 +174,20 @@ describe('lib/projects/components', () => {
             expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/package.json', 'utf-8');
             consoleSpy.mockRestore();
         });
+        it('skips tooling config files on collision instead of renaming them', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: [
+                    'src/app/cards/.prettierrc.json',
+                    'src/app/cards/component.js',
+                    'src/app/cards/eslint.config.js',
+                ],
+            };
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            handleComponentCollision(collision);
+            expect(mockedFs.copyFileSync).toHaveBeenCalledTimes(1);
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/src/app/cards/component.js', '/dest/path/src/app/cards/component-2.js');
+        });
         it('falls back to timestamp when maxAttempts is exhausted', () => {
             const collision = {
                 ...mockCollision,

package/lib/projects/components.js

@@ -114,9 +114,19 @@ export function handleComponentCollision({ dest, src, collisions }) {
         }
     });
     const filenameDifferentiator = generateSafeFilenameDifferentiator(sourceFiles, hsMetaFiles);
-    // Exclude markdown files fromthe rename process because they should not be duplicated
     const sourceFilenameMapping = sourceFiles
-        .filter(filename => !filename.endsWith('.md'))
+        .filter(filename => {
+        // Exclude markdown files from the rename process because they should not be duplicated
+        if (filename.endsWith('.md')) {
+            return false;
+        }
+        // Also exclude the tooling config we add to new projects
+        const base = path.parse(filename).base;
+        if (base === '.prettierrc.json' || base === 'eslint.config.js') {
+            return false;
+        }
+        return true;
+    })
         .reduce((acc, filename) => {
         return {
             ...acc,

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 { PromptExitError } from '../../errors/PromptExitError.js';
 import { installAppAutoPrompt, installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
 import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { lib } from '../../../lang/en.js';
@@ -313,6 +314,9 @@ class AppDevModeInterface {
             }
         }
         catch (e) {
+            if (e instanceof PromptExitError) {
+                throw e;
+            }
             if (SpinniesManager.pick('fetchAppData')) {
                 SpinniesManager.fail('fetchAppData', {
                     text: lib.AppDevModeInterface.fetchAppData.error,

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 { PromptExitError } from '../../errors/PromptExitError.js';
 import { installAppBrowserPrompt } from '../../prompts/installAppPrompt.js';
 import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { handleKeypress } from '../../process.js';
@@ -89,6 +90,9 @@ class LocalDevManager_DEPRECATED {
                 await this.checkPublicAppInstallation();
             }
             catch (e) {
+                if (e instanceof PromptExitError) {
+                    throw e;
+                }
                 logError(e);
             }
         }

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,12 +18,10 @@ 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';
@@ -119,13 +117,9 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
             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);

package/lib/prompts/downloadProjectPrompt.js

@@ -2,21 +2,22 @@ import { promptUser } from './promptUtils.js';
 import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
 import { logError, ApiErrorContext } from '../errorHandlers/index.js';
-import { uiLogger } from '../ui/logger.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { uiLogger } from '../ui/logger.js';
 async function createProjectsList(accountId) {
-    try {
-        if (accountId) {
-            const { data: projects } = await fetchProjects(accountId);
-            return projects.results;
-        }
+    if (!accountId) {
         uiLogger.error(lib.prompts.downloadProjectPrompt.errors.accountIdRequired);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.downloadProjectPrompt.errors.accountIdRequired, EXIT_CODES.ERROR);
+    }
+    try {
+        const { data: projects } = await fetchProjects(accountId);
+        return projects.results;
     }
     catch (e) {
-        logError(e, accountId ? new ApiErrorContext({ accountId }) : undefined);
-        process.exit(EXIT_CODES.ERROR);
+        logError(e, new ApiErrorContext({ accountId }));
+        throw new PromptExitError('Failed to fetch projects', EXIT_CODES.ERROR);
     }
 }
 export async function downloadProjectPrompt(promptOptions) {

package/lib/prompts/installAppPrompt.js

@@ -1,8 +1,9 @@
 import open from 'open';
 import { promptUser } from './promptUtils.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     uiLogger.log('');
     if (isReinstall) {
@@ -20,7 +21,7 @@ export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     });
     if (!isReinstall && !shouldOpenBrowser) {
         uiLogger.log(lib.prompts.installAppPrompt.decline);
-        process.exit(EXIT_CODES.SUCCESS);
+        throw new PromptExitError(lib.prompts.installAppPrompt.decline, EXIT_CODES.SUCCESS);
     }
     else if (!shouldOpenBrowser) {
         return;

package/lib/prompts/personalAccessKeyPrompt.js

@@ -6,8 +6,9 @@ import { uiLogger } from '../ui/logger.js';
 import { promptUser } from './promptUtils.js';
 import { getCliAccountNamePromptConfig, } from './accountNamePrompt.js';
 import { uiInfoSection } from '../ui/index.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 /**
  * Displays notification to user that we are about to open the browser,
  * then opens their browser to the personal-access-key shortlink
@@ -27,7 +28,7 @@ export async function personalAccessKeyPrompt({ env, account, }) {
         ]);
         if (!choice) {
             deleteConfigFileIfEmpty();
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(lib.prompts.personalAccessKeyPrompt.errors.authCancelled, EXIT_CODES.SUCCESS);
         }
         if (choice ===
             lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -6,6 +6,7 @@ import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
 import { uiAccountDescription } from '../ui/index.js';
 import { isSandbox } from '../accountTypes.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 function mapNestedAccount(accountConfig) {
     const parentAccountId = accountConfig.parentAccountId ?? null;
@@ -23,20 +24,18 @@ function getNonConfigDeveloperTestAccountName(account) {
 }
 export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let choices = [];
     let sandboxUsage = {
         STANDARD: { used: 0, available: 0, limit: 0 },
         DEVELOPER: { used: 0, available: 0, limit: 0 },
     };
     try {
-        if (defaultAccountId) {
-            const { data } = await getSandboxUsageLimits(defaultAccountId);
-            sandboxUsage = data.usage;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await getSandboxUsageLimits(defaultAccountId);
+        sandboxUsage = data.usage;
     }
     catch (err) {
         uiLogger.debug('Unable to fetch sandbox usage limits: ', err);
@@ -83,16 +82,14 @@ export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountC
 }
 export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let devTestAccountsResponse;
     try {
-        if (defaultAccountId) {
-            const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
-            devTestAccountsResponse = data;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
+        devTestAccountsResponse = data;
     }
     catch (err) {
         uiLogger.debug('Unable to fetch developer test account usage limits: ', err);

package/lib/prompts/selectHubDBTablePrompt.js

@@ -4,25 +4,29 @@ import { lib } from '../../lang/en.js';
 import { debugError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchHubDBOptions(accountId) {
     try {
         const { data: { results: tables }, } = await fetchTables(accountId);
         if (tables.length === 0) {
             uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()), EXIT_CODES.SUCCESS);
         }
         return tables;
     }
     catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
         debugError(error, { accountId });
         uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()), EXIT_CODES.ERROR);
     }
 }
 export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
-    const hubdbTables = (await fetchHubDBOptions(accountId)) || [];
+    const hubdbTables = await fetchHubDBOptions(accountId);
     const id = options.tableId?.toString();
     const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
     return promptUser([

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -4,13 +4,14 @@ import { uiLine } from '../ui/index.js';
 import { logError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { PromptExitError } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
+    if (!accountId) {
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId, EXIT_CODES.ERROR);
+    }
     try {
-        if (!accountId) {
-            uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
         const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
         const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
         if (!filteredPublicApps.length ||
@@ -24,14 +25,19 @@ async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = fa
                 uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsCloneMessage(accountName)}`);
             }
             uiLine();
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration
+                : lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone, EXIT_CODES.SUCCESS);
         }
         return filteredPublicApps;
     }
     catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
         logError(error, accountId ? { accountId } : undefined);
         uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps, EXIT_CODES.ERROR);
     }
 }
 export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {