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

package/commands/sandbox/create.js

@@ -6,17 +6,14 @@ import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/l
 import { commands, lib } from '../../lang/en.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiFeatureHighlight, uiBetaTag } from '../../lib/ui/index.js';
-import { SANDBOX_TYPE_MAP, getAvailableSyncTypes, SYNC_TYPES, validateSandboxUsageLimits, } from '../../lib/sandboxes.js';
+import { SANDBOX_TYPE_MAP, validateSandboxUsageLimits, } from '../../lib/sandboxes.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { sandboxTypePrompt } from '../../lib/prompts/sandboxesPrompt.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
-import { syncSandbox } from '../../lib/sandboxSync.js';
 import { logError } from '../../lib/errorHandlers/index.js';
-import { buildSandbox, buildV2Sandbox } from '../../lib/buildAccount.js';
+import { buildV2Sandbox } from '../../lib/buildAccount.js';
 import { hubspotAccountNamePrompt } from '../../lib/prompts/accountNamePrompt.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { hasFeature } from '../../lib/hasFeature.js';
-import { FEATURES } from '../../lib/constants.js';
 const command = 'create';
 const describe = uiBetaTag(commands.sandbox.subcommands.create.describe, false);
 async function handler(args) {
@@ -98,38 +95,14 @@ async function handler(args) {
             contactRecordsSyncPromptResult = contactRecordsSyncPrompt;
         }
     }
-    // Check if parent portal is ungated for v2 sandboxes
-    const isUngatedForV2Cli = await hasFeature(derivedAccountId, FEATURES.SANDBOXES_V2_CLI);
-    const isUngatedForV2Sandboxes = await hasFeature(derivedAccountId, FEATURES.SANDBOXES_V2);
-    const canCreateV2Sandbox = isUngatedForV2Sandboxes && isUngatedForV2Cli;
     try {
-        let result;
-        if (canCreateV2Sandbox) {
-            result = await buildV2Sandbox(sandboxName, accountConfig, sandboxType, contactRecordsSyncPromptResult, env, force);
-        }
-        else {
-            result = await buildSandbox(sandboxName, accountConfig, sandboxType, env, force);
-        }
+        const result = await buildV2Sandbox(sandboxName, accountConfig, sandboxType, contactRecordsSyncPromptResult, env, force);
         const sandboxAccountConfig = getConfigAccountById(result.sandbox.sandboxHubId);
         // Check if sandbox account config exists
         if (!sandboxAccountConfig) {
             uiLogger.error(commands.sandbox.subcommands.create.failure.noSandboxAccountConfig(result.sandbox.sandboxHubId));
             process.exit(EXIT_CODES.ERROR);
         }
-        if (result && !canCreateV2Sandbox) {
-            // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
-            try {
-                let availableSyncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
-                if (!contactRecordsSyncPromptResult) {
-                    availableSyncTasks = availableSyncTasks.filter(t => t.type !== SYNC_TYPES.OBJECT_RECORDS);
-                }
-                await syncSandbox(sandboxAccountConfig, accountConfig, env, availableSyncTasks);
-            }
-            catch (err) {
-                logError(err);
-                throw err;
-            }
-        }
         const highlightItems = ['accountsUseCommand', 'projectCreateCommand'];
         if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
             highlightItems.push('projectDevCommand');

package/commands/testAccount/create.js

@@ -12,6 +12,7 @@ import { fileExists } from '../../lib/validation.js';
 import { commands } from '../../lang/en.js';
 import { createDeveloperTestAccountConfigPrompt } from '../../lib/prompts/createDeveloperTestAccountConfigPrompt.js';
 import { debugError, logError } from '../../lib/errorHandlers/index.js';
+import { PromptExitError } from '../../lib/errors/PromptExitError.js';
 import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 import { createDeveloperTestAccountV2, saveAccountToConfig, } from '../../lib/buildAccount.js';
 import { ACCOUNT_LEVEL_CHOICES, ACCOUNT_LEVELS } from '../../lib/constants.js';
@@ -130,6 +131,9 @@ async function handler(args) {
             }
         }
         catch (e) {
+            if (e instanceof PromptExitError) {
+                process.exit(e.exitCode);
+            }
             debugError(e);
             uiLogger.error(commands.testAccount.create.errors.saveAccountToConfigFailure(testAccountConfig.accountName));
             process.exit(EXIT_CODES.ERROR);

package/lang/en.d.ts

@@ -601,11 +601,6 @@ export declare const commands: {
                     src: string;
                     dest: string;
                 };
-                warnings: {
-                    disableInitial: string;
-                    initialUpload: string;
-                    notUploaded: (path: string) => string;
-                };
             };
             fetch: {
                 describe: string;
@@ -1261,7 +1256,6 @@ export declare const commands: {
             };
             success: (derivedTargets: string[]) => string;
             errors: {
-                needsMcpAccess: (accountId?: number) => string;
                 errorParsingJsonFIle: (filename: string, errorMessage: string) => string;
             };
             spinners: {
@@ -1295,6 +1289,8 @@ export declare const commands: {
             prompts: {
                 targets: string;
                 targetsRequired: string;
+                standaloneMode: string;
+                cliVersion: string;
             };
         };
         start: {
@@ -3478,6 +3474,7 @@ export declare const lib: {
                 invalidOauthClientSecretCopy: string;
                 invalidPersonalAccessKey: string;
                 invalidPersonalAccessKeyCopy: string;
+                authCancelled: string;
             };
         };
         createTemplatePrompt: {
@@ -3981,4 +3978,14 @@ export declare const lib: {
             copyingProjectFilesFailed: string;
         };
     };
+    theme: {
+        cmsDevServerProcess: {
+            installStarted: (targetVersion: string) => string;
+            installSucceeded: string;
+            installFailed: string;
+            serverStartError: (error: Error) => string;
+            serverExit: (code: number) => string;
+            serverKill: (signal: NodeJS.Signals) => string;
+        };
+    };
 };

package/lang/en.js

@@ -609,11 +609,6 @@ export const commands = {
                     src: 'Path to the local directory your files are in, relative to your current working directory',
                     dest: 'Path in HubSpot Design Tools. Can be a net new path',
                 },
-                warnings: {
-                    disableInitial: `Passing the "${chalk.bold('--disable-initial')}" option is no longer necessary. Running "${uiCommandReference('hs watch')}" no longer uploads the watched directory by default.`,
-                    initialUpload: `To upload the directory run "${uiCommandReference('hs upload')}" beforehand or add the "${chalk.bold('--initial-upload')}" option when running "${uiCommandReference('hs watch')}".`,
-                    notUploaded: (path) => `The "${uiCommandReference('hs watch')}" command no longer uploads the watched directory when started. The directory "${path}" was not uploaded.`,
-                },
             },
             fetch: {
                 describe: 'Fetch a file, directory or module from HubSpot and write to a path on your computer.',
@@ -1271,7 +1266,6 @@ export const commands = {
             },
             success: (derivedTargets) => `You can now use the HubSpot CLI MCP Server in ${derivedTargets.join(', ')}.  ${chalk.bold('You may need to restart these tools to apply the changes')}.`,
             errors: {
-                needsMcpAccess: (accountId) => `You must opt in to the developer MCP beta to use this feature on ${uiAccountDescription(accountId)}. Try again with a different account or ${uiLink('join the beta now', getProductUpdatesUrl('239890', accountId))}`,
                 errorParsingJsonFIle: (filename, errorMessage) => `Unable to update ${chalk.bold(filename)} due to invalid JSON: ${errorMessage}`,
             },
             spinners: {
@@ -1311,6 +1305,8 @@ export const commands = {
             prompts: {
                 targets: '[--client] Which tools would you like to add the HubSpot CLI MCP server to?',
                 targetsRequired: 'Must choose at least one app to configure.',
+                standaloneMode: 'Do you want to run in standalone mode? (This will use npx @hubspot/cli instead of the installed hs command)',
+                cliVersion: 'Specify a CLI version to pin (leave blank for latest):',
             },
         },
         start: {
@@ -3501,6 +3497,7 @@ export const lib = {
                 invalidOauthClientSecretCopy: 'Please copy the actual OAuth2 client secret rather than the asterisks that mask it.',
                 invalidPersonalAccessKey: 'You did not enter a valid access key. Please try again.',
                 invalidPersonalAccessKeyCopy: 'Please copy the actual access key rather than the bullets that mask it.',
+                authCancelled: 'Authentication cancelled.',
             },
         },
         createTemplatePrompt: {
@@ -4004,4 +4001,14 @@ export const lib = {
             copyingProjectFilesFailed: 'Unable to copy migrated project files',
         },
     },
+    theme: {
+        cmsDevServerProcess: {
+            installStarted: (targetVersion) => `Installing cms-dev-server ${targetVersion}...`,
+            installSucceeded: 'cms-dev-server setup complete',
+            installFailed: 'Failed to install cms-dev-server',
+            serverStartError: (error) => `Failed to start dev server: ${error}`,
+            serverExit: (code) => `Dev server exited with code ${code}`,
+            serverKill: (signal) => `Dev server killed with signal ${signal}`,
+        },
+    },
 };

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/__tests__/serverlessLogs.test.js

@@ -1,6 +1,6 @@
-import mockStdIn from 'mock-stdin';
 import { outputLogs } from '../ui/serverlessFunctionLogs.js';
 import { tailLogs } from '../serverlessLogs.js';
+import { handleKeypress } from '../process.js';
 vi.mock('../ui/serverlessFunctionLogs');
 vi.mock('../ui/SpinniesManager', () => ({
     default: {
@@ -12,82 +12,87 @@ vi.mock('../ui/SpinniesManager', () => ({
         stopAll: vi.fn(),
     },
 }));
+vi.mock('../process');
 vi.useFakeTimers();
 const ACCOUNT_ID = 123;
+function terminateTailLogs() {
+    const keypressCallback = vi.mocked(handleKeypress).mock.calls[0][0];
+    keypressCallback({ name: 'q' });
+}
 describe('lib/serverlessLogs', () => {
     describe('tailLogs()', () => {
-        let stdinMock;
-        beforeEach(() => {
-            // @ts-ignore - we don't need to mock the entire process object
-            vi.spyOn(process, 'exit').mockImplementation(() => { });
-            stdinMock = mockStdIn.stdin();
-        });
         afterEach(() => {
             vi.clearAllTimers();
-            stdinMock.restore();
+            vi.clearAllMocks();
         });
         it('calls tailCall() to get the next results', async () => {
             const compact = false;
-            const fetchLatest = vi.fn(() => {
-                return Promise.resolve({
-                    data: {
-                        id: '1234',
-                        executionTime: 510,
-                        log: 'Log message',
-                        error: { message: '', type: '', stackTrace: [] },
-                        status: 'SUCCESS',
-                        createdAt: 1620232011451,
-                        memory: '70/128 MB',
-                        duration: '53.40 ms',
-                    },
-                    status: 200,
-                    statusText: 'OK',
-                    headers: {},
-                    config: {},
-                });
-            });
-            const tailCall = vi.fn(() => {
-                return Promise.resolve({
-                    data: {
-                        results: [],
-                        paging: {
-                            next: {
-                                after: 'somehash',
-                            },
+            const fetchLatest = vi.fn(() => Promise.resolve({
+                data: {
+                    id: '1234',
+                    executionTime: 510,
+                    log: 'Log message',
+                    error: { message: '', type: '', stackTrace: [] },
+                    status: 'SUCCESS',
+                    createdAt: 1620232011451,
+                    memory: '70/128 MB',
+                    duration: '53.40 ms',
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
+            const tailCall = vi.fn(() => Promise.resolve({
+                data: {
+                    results: [],
+                    paging: {
+                        next: {
+                            after: 'somehash',
                         },
                     },
-                    status: 200,
-                    statusText: 'OK',
-                    headers: {},
-                    config: {},
-                });
-            });
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
             // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            vi.runOnlyPendingTimers();
+            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await vi.advanceTimersByTimeAsync(0);
             expect(fetchLatest).toHaveBeenCalled();
+            expect(tailCall).toHaveBeenCalledTimes(1);
+            await vi.advanceTimersByTimeAsync(5000);
             expect(tailCall).toHaveBeenCalledTimes(2);
+            terminateTailLogs();
+            await tailPromise;
         });
         it('outputs results', async () => {
             const compact = false;
-            const fetchLatest = vi.fn(() => {
-                return Promise.resolve({
-                    data: {
-                        id: '1234',
-                        executionTime: 510,
-                        log: 'Log message',
-                        error: { message: '', type: '', stackTrace: [], statusCode: null },
-                        status: 'SUCCESS',
-                        createdAt: 1620232011451,
-                        memory: '70/128 MB',
-                        duration: '53.40 ms',
+            const fetchLatest = vi.fn(() => Promise.resolve({
+                data: {
+                    id: '1234',
+                    executionTime: 510,
+                    log: 'Log message',
+                    error: {
+                        message: '',
+                        type: '',
+                        stackTrace: [],
+                        statusCode: null,
                     },
-                    status: 200,
-                    statusText: 'OK',
-                    headers: {},
-                    config: {},
-                });
-            });
+                    status: 'SUCCESS',
+                    createdAt: 1620232011451,
+                    memory: '70/128 MB',
+                    duration: '53.40 ms',
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
             const latestLogResponse = {
                 results: [
                     {
@@ -117,12 +122,23 @@ describe('lib/serverlessLogs', () => {
                     },
                 },
             };
-            const tailCall = vi.fn(() => Promise.resolve({ data: latestLogResponse }));
+            const tailCall = vi.fn(() => Promise.resolve({
+                data: latestLogResponse,
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
             // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            vi.runOnlyPendingTimers();
+            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await vi.advanceTimersByTimeAsync(0);
             expect(outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(tailCall).toHaveBeenCalledTimes(1);
+            await vi.advanceTimersByTimeAsync(5000);
             expect(tailCall).toHaveBeenCalledTimes(2);
+            terminateTailLogs();
+            await tailPromise;
         });
         it('handles no logs', async () => {
             const compact = false;
@@ -141,8 +157,7 @@ describe('lib/serverlessLogs', () => {
                 statusCode: 404,
             }));
             await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            vi.runOnlyPendingTimers();
-            expect(tailCall).toHaveBeenCalledTimes(2);
+            expect(tailCall).toHaveBeenCalledTimes(1);
         });
     });
 });

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/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,11 +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 MCP_ACCESS: "Developers:CLIMCPAccess";
     readonly THEME_MIGRATION_2025_2: "Developers:ProjectThemeMigrations:2025.2";
     readonly AGENT_TOOLS: "ThirdPartyAgentTools";
 };
@@ -145,3 +142,4 @@ export declare const ACCOUNT_LEVELS: {
     readonly ENTERPRISE: "ENTERPRISE";
 };
 export declare const ACCOUNT_LEVEL_CHOICES: readonly ["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"];
+export declare const FEEDBACK_URL = "https://developers.hubspot.com/feedback";