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

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 { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { createSandbox, 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,6 +32,7 @@ const mockedCliAccountNamePrompt = cliAccountNamePrompt;
 const mockedCreateDeveloperTestAccount = createDeveloperTestAccount;
 const mockedFetchDeveloperTestAccountGateSyncStatus = fetchDeveloperTestAccountGateSyncStatus;
 const mockedGenerateDeveloperTestAccountPersonalAccessKey = generateDeveloperTestAccountPersonalAccessKey;
+const mockedCreateSandbox = createSandbox;
 const mockedCreateV2Sandbox = createV2Sandbox;
 const mockedGetPersonalAccessKey = getSandboxPersonalAccessKey;
 const mockedPoll = poll;
@@ -161,6 +162,56 @@ 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__/sandboxSync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/sandboxSync.test.js

@@ -0,0 +1,147 @@
+import { uiLogger } from '../ui/logger.js';
+import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
+import { getConfigAccountIfExists, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { mockHubSpotHttpError } from '../testUtils.js';
+import { getAvailableSyncTypes } from '../sandboxes.js';
+import { syncSandbox } from '../sandboxSync.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../sandboxes');
+vi.mock('../ui/SpinniesManager');
+const mockedUiLogger = uiLogger;
+const mockedInitiateSync = initiateSync;
+const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
+const mockedGetConfigAccountById = getConfigAccountById;
+const mockedGetAvailableSyncTypes = getAvailableSyncTypes;
+const mockedSpinniesInit = SpinniesManager.init;
+const mockedSpinniesAdd = SpinniesManager.add;
+const mockedSpinniesSucceed = SpinniesManager.succeed;
+const mockedSpinniesFail = SpinniesManager.fail;
+describe('lib/sandboxSync', () => {
+    const mockEnv = 'qa';
+    const mockParentAccount = {
+        name: 'Parent Account',
+        accountId: 123,
+        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        env: mockEnv,
+        authType: 'personalaccesskey',
+    };
+    const mockChildAccount = {
+        name: 'Child Account',
+        accountId: 456,
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        env: mockEnv,
+        authType: 'personalaccesskey',
+    };
+    const mockChildAccountWithMissingId = {
+        name: 'Child Account',
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        env: mockEnv,
+        authType: 'personalaccesskey',
+    };
+    const mockSyncTasks = [{ type: 'mock-sync-type' }];
+    beforeEach(() => {
+        mockedGetConfigAccountIfExists
+            .mockReturnValueOnce(mockChildAccount)
+            .mockReturnValueOnce(mockParentAccount);
+        mockedGetAvailableSyncTypes.mockResolvedValue(mockSyncTasks);
+        // Mock SpinniesManager methods to prevent spinner errors
+        mockedSpinniesInit.mockImplementation(() => { });
+        mockedSpinniesAdd.mockImplementation(() => { });
+        mockedSpinniesSucceed.mockImplementation(() => { });
+        mockedSpinniesFail.mockImplementation(() => { });
+        // Mock account config for uiAccountDescription calls
+        mockedGetConfigAccountById.mockImplementation(accountId => {
+            if (accountId === mockChildAccount.accountId) {
+                return mockChildAccount;
+            }
+            if (accountId === mockParentAccount.accountId) {
+                return mockParentAccount;
+            }
+            return undefined; // Don't throw, just return undefined for unknown accounts
+        });
+    });
+    describe('syncSandbox()', () => {
+        it('successfully syncs a sandbox with provided sync tasks', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
+            expect(mockedSpinniesInit).toHaveBeenCalled();
+            expect(mockedSpinniesAdd).toHaveBeenCalled();
+            expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.accountId, mockChildAccount.accountId, mockSyncTasks, mockChildAccount.accountId);
+            expect(mockedSpinniesSucceed).toHaveBeenCalled();
+        });
+        it('fetches sync types when no tasks are provided', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, []);
+            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
+            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
+            expect(mockedInitiateSync).toHaveBeenCalled();
+        });
+        it('throws error when account IDs are missing', async () => {
+            const errorRegex = new RegExp(`because your account has been removed from`);
+            await expect(syncSandbox(mockChildAccountWithMissingId, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
+        });
+        it('handles sync in progress error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 429,
+                data: {
+                    category: 'RATE_LIMITS',
+                    subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because there's another sync in progress/));
+        });
+        it('handles invalid user error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/because your account has been removed from/));
+        });
+        it('handles not super admin error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because you are not a super admin in/));
+        });
+        it('handles sandbox not found error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 404,
+                data: {
+                    category: 'OBJECT_NOT_FOUND',
+                    subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/may have been deleted through the UI/));
+        });
+        it('displays slim info message when specified', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks, true);
+            expect(mockedUiLogger.info).not.toHaveBeenCalled();
+            expect(mockedSpinniesSucceed).toHaveBeenCalledWith('sandboxSync', expect.objectContaining({
+                text: expect.stringMatching(/Initiated sync of object definitions from production to /),
+            }));
+        });
+    });
+});

package/lib/__tests__/sandboxes.test.js

@@ -1,9 +1,10 @@
 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, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
+import { getSandboxTypeAsString, getHasSandboxesByType, getAvailableSyncTypes, 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');
@@ -11,6 +12,7 @@ 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;
@@ -51,6 +53,32 @@ 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,7 +3,6 @@ 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';
@@ -37,9 +36,6 @@ async function updateConfigWithNewAccount(env, configAlreadyExists, providedPers
         return updatedConfig;
     }
     catch (e) {
-        if (e instanceof PromptExitError) {
-            throw e;
-        }
         debugError(e);
         return null;
     }

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 { V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
+import { SandboxResponse, 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,6 +10,11 @@ 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,14 +3,13 @@ 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 { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { PromptExitError } from './errors/PromptExitError.js';
+import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
 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_TYPE_MAP_V2, handleSandboxCreateError } from './sandboxes.js';
+import { SANDBOX_API_TYPE_MAP, SANDBOX_TYPE_MAP_V2, handleSandboxCreateError, } from './sandboxes.js';
 import { handleDeveloperTestAccountCreateError } from './developerTestAccounts.js';
 import { lib } from '../lang/en.js';
 import { poll } from './polling.js';
@@ -128,14 +127,51 @@ 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'
@@ -174,9 +210,6 @@ 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,6 +77,8 @@ 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,6 +69,8 @@ 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/projects/__tests__/components.test.js

@@ -174,20 +174,6 @@ 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,19 +114,9 @@ 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 => {
-        // 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;
-    })
+        .filter(filename => !filename.endsWith('.md'))
         .reduce((acc, filename) => {
         return {
             ...acc,

package/lib/projects/localDev/AppDevModeInterface.js

@@ -6,7 +6,6 @@ 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';
@@ -314,9 +313,6 @@ 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,7 +15,6 @@ 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';
@@ -90,9 +89,6 @@ 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 { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, 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,10 +18,12 @@ 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 { buildDeveloperTestAccount, saveAccountToConfig, buildV2Sandbox, } from '../../../buildAccount.js';
+import { buildSandbox, buildDeveloperTestAccount, saveAccountToConfig, } from '../../../buildAccount.js';
 import { debugError } from '../../../errorHandlers/index.js';
 import { listPrompt } from '../../../prompts/promptUtils.js';
 import { confirmUseExistingDeveloperTestAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
@@ -117,9 +119,13 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         });
         trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
-        const result = await buildV2Sandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, // syncObjectRecords
-        env);
-        return result.sandbox.sandboxHubId;
+        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;
     }
     catch (err) {
         logError(err);

package/lib/prompts/downloadProjectPrompt.js

@@ -2,22 +2,21 @@ 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 { lib } from '../../lang/en.js';
-import { PromptExitError } from '../errors/PromptExitError.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { uiLogger } from '../ui/logger.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { lib } from '../../lang/en.js';
 async function createProjectsList(accountId) {
-    if (!accountId) {
-        uiLogger.error(lib.prompts.downloadProjectPrompt.errors.accountIdRequired);
-        throw new PromptExitError(lib.prompts.downloadProjectPrompt.errors.accountIdRequired, EXIT_CODES.ERROR);
-    }
     try {
-        const { data: projects } = await fetchProjects(accountId);
-        return projects.results;
+        if (accountId) {
+            const { data: projects } = await fetchProjects(accountId);
+            return projects.results;
+        }
+        uiLogger.error(lib.prompts.downloadProjectPrompt.errors.accountIdRequired);
+        process.exit(EXIT_CODES.ERROR);
     }
     catch (e) {
-        logError(e, new ApiErrorContext({ accountId }));
-        throw new PromptExitError('Failed to fetch projects', EXIT_CODES.ERROR);
+        logError(e, accountId ? new ApiErrorContext({ accountId }) : undefined);
+        process.exit(EXIT_CODES.ERROR);
     }
 }
 export async function downloadProjectPrompt(promptOptions) {

package/lib/prompts/installAppPrompt.js

@@ -1,9 +1,8 @@
 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) {
@@ -21,7 +20,7 @@ export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     });
     if (!isReinstall && !shouldOpenBrowser) {
         uiLogger.log(lib.prompts.installAppPrompt.decline);
-        throw new PromptExitError(lib.prompts.installAppPrompt.decline, EXIT_CODES.SUCCESS);
+        process.exit(EXIT_CODES.SUCCESS);
     }
     else if (!shouldOpenBrowser) {
         return;

package/lib/prompts/personalAccessKeyPrompt.js

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