@hubspot/cli 7.7.22-experimental.0 → 7.7.24-experimental.0

package/commands/account/auth.js

@@ -15,6 +15,7 @@ import { setAsDefaultAccountPrompt } from '../../lib/prompts/setAsDefaultAccount
 import { logError } from '../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiFeatureHighlight } from '../../lib/ui/index.js';
+import { parseStringToNumber } from '../../lib/parsing.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
@@ -96,9 +97,19 @@ async function handleConfigMigration() {
 const describe = commands.account.subcommands.auth.describe;
 const command = 'auth';
 async function handler(args) {
-    const { disableTracking, personalAccessKey: providedPersonalAccessKey, derivedAccountId, } = args;
+    const { disableTracking, personalAccessKey: providedPersonalAccessKey, userProvidedAccount, } = args;
+    let parsedUserProvidedAccountId;
+    if (userProvidedAccount) {
+        try {
+            parsedUserProvidedAccountId = parseStringToNumber(userProvidedAccount);
+        }
+        catch (err) {
+            uiLogger.error(commands.account.subcommands.auth.errors.invalidAccountIdProvided);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
     if (!disableTracking) {
-        trackCommandUsage('account-auth', {}, derivedAccountId);
+        trackCommandUsage('account-auth', {}, parsedUserProvidedAccountId);
         await trackAuthAction('account-auth', authType, TRACKING_STATUS.STARTED);
     }
     const configMigrationSuccess = await handleConfigMigration();
@@ -112,7 +123,7 @@ async function handler(args) {
     }
     loadConfig('');
     handleExit(deleteEmptyConfigFile);
-    const updatedConfig = await updateConfigWithNewAccount(args.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD, configAlreadyExists, providedPersonalAccessKey, derivedAccountId);
+    const updatedConfig = await updateConfigWithNewAccount(args.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD, configAlreadyExists, providedPersonalAccessKey, parsedUserProvidedAccountId);
     if (!updatedConfig) {
         if (!disableTracking) {
             await trackAuthAction('account-auth', authType, TRACKING_STATUS.ERROR);
@@ -143,7 +154,7 @@ function accountAuthBuilder(yargs) {
     yargs.options({
         account: {
             describe: commands.account.subcommands.auth.options.account,
-            type: 'string',
+            type: 'number',
             alias: 'a',
         },
         'disable-tracking': {

package/commands/auth.js

@@ -40,7 +40,7 @@ async function handler(args) {
         }
     }
     catch (err) {
-        logError(commands.auth.errors.invalidAccountIdProvided);
+        uiLogger.error(commands.auth.errors.invalidAccountIdProvided);
         process.exit(EXIT_CODES.ERROR);
     }
     const authType = (authTypeFlagValue && authTypeFlagValue.toLowerCase()) ||

package/commands/config/set.d.ts

@@ -5,6 +5,7 @@ type ConfigSetArgs = CommonArgs & ConfigArgs & {
     allowUsageTracking?: boolean;
     httpTimeout?: string;
     allowAutoUpdates?: boolean;
+    autoOpenBrowser?: boolean;
 };
 declare const configSetCommand: YargsCommandModule<unknown, ConfigSetArgs>;
 export default configSetCommand;

package/commands/config/set.js

@@ -2,9 +2,9 @@ import { i18n } from '../../lib/lang.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { setDefaultCmsPublishMode, setHttpTimeout, setAllowUsageTracking, setAllowAutoUpdates, } from '../../lib/configOptions.js';
+import { setDefaultCmsPublishMode, setHttpTimeout, setAllowUsageTracking, setAllowAutoUpdates, setAutoOpenBrowser, } from '../../lib/configOptions.js';
 import { commands } from '../../lang/en.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { makeYargsBuilder, getExclusiveConflicts, } from '../../lib/yargsUtils.js';
 const command = 'set';
 const describe = commands.config.subcommands.set.describe;
 async function selectOptions() {
@@ -28,7 +28,7 @@ async function selectOptions() {
     return configOption;
 }
 async function handleConfigUpdate(accountId, args) {
-    const { allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, } = args;
+    const { allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
     if (typeof defaultCmsPublishMode !== 'undefined') {
         await setDefaultCmsPublishMode({ defaultCmsPublishMode, accountId });
         return true;
@@ -45,6 +45,10 @@ async function handleConfigUpdate(accountId, args) {
         await setAllowAutoUpdates({ allowAutoUpdates, accountId });
         return true;
     }
+    else if (typeof autoOpenBrowser !== 'undefined') {
+        await setAutoOpenBrowser({ autoOpenBrowser, accountId });
+        return true;
+    }
     return false;
 }
 async function handler(args) {
@@ -77,13 +81,19 @@ function configSetBuilder(yargs) {
             type: 'boolean',
             hidden: true,
         },
+        'auto-open-browser': {
+            describe: commands.config.subcommands.set.options.autoOpenBrowser.describe,
+            type: 'boolean',
+            hidden: true,
+        },
     })
-        .conflicts('defaultCmsPublishMode', 'allowUsageTracking')
-        .conflicts('defaultCmsPublishMode', 'httpTimeout')
-        .conflicts('allowUsageTracking', 'httpTimeout')
-        .conflicts('allowAutoUpdates', 'defaultCmsPublishMode')
-        .conflicts('allowAutoUpdates', 'allowUsageTracking')
-        .conflicts('allowAutoUpdates', 'httpTimeout')
+        .conflicts(getExclusiveConflicts([
+        'default-cms-publish-mode',
+        'allow-usage-tracking',
+        'http-timeout',
+        'allow-auto-updates',
+        'auto-open-browser',
+    ]))
         .example([
         [
             '$0 config set',

package/commands/mcp/start.d.ts

@@ -1,6 +1,7 @@
 import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
 interface McpStartArgs extends CommonArgs {
     aiAgent: string;
+    standAloneMode: boolean;
 }
 declare const mcpStartCommand: YargsCommandModule<unknown, McpStartArgs>;
 export default mcpStartCommand;

package/commands/mcp/start.js

@@ -8,8 +8,11 @@ import { logError } from '../../lib/errorHandlers/index.js';
 import { commands } from '../../lang/en.js';
 import { handleExit } from '../../lib/process.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { fileURLToPath } from 'url';
 const command = 'start';
 const describe = undefined; // Leave hidden for now
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 async function handler(args) {
     try {
         await import('@modelcontextprotocol/sdk/server/mcp.js');
@@ -19,9 +22,10 @@ async function handler(args) {
         process.exit(EXIT_CODES.ERROR);
     }
     trackCommandUsage('mcp-start', {}, args.derivedAccountId);
-    await startMcpServer(args.aiAgent);
+    await startMcpServer(args);
 }
-async function startMcpServer(aiAgent) {
+async function startMcpServer(args) {
+    const { aiAgent, standAloneMode } = args;
     try {
         const serverPath = path.join(__dirname, '..', '..', 'mcp-server', 'server.js');
         // Check if server file exists
@@ -29,8 +33,8 @@ async function startMcpServer(aiAgent) {
             uiLogger.error(commands.mcp.start.errors.serverFileNotFound(serverPath));
             return;
         }
-        uiLogger.info(commands.mcp.start.startingServer);
-        uiLogger.info(commands.mcp.start.stopInstructions);
+        uiLogger.debug(commands.mcp.start.startingServer);
+        uiLogger.debug(commands.mcp.start.stopInstructions);
         const args = [serverPath];
         // Start the server using ts-node
         const child = spawn(`node`, args, {
@@ -38,6 +42,7 @@ async function startMcpServer(aiAgent) {
             env: {
                 ...process.env,
                 HUBSPOT_MCP_AI_AGENT: aiAgent || 'unknown',
+                HUBSPOT_MCP_STANDALONE_MODE: `${standAloneMode}`,
             },
         });
         // Handle server process events
@@ -63,6 +68,9 @@ function startBuilder(yargs) {
     yargs.option('ai-agent', {
         type: 'string',
     });
+    yargs.option('stand-alone-mode', {
+        type: 'boolean',
+    });
     return yargs;
 }
 const builder = makeYargsBuilder(startBuilder, command, describe, {

package/commands/project/create.js

@@ -5,7 +5,8 @@ import { getCwd } from '@hubspot/local-dev-lib/path';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { writeProjectConfig, getProjectConfig, } from '../../lib/projects/config.js';
 import { EMPTY_PROJECT_TEMPLATE_NAME } from '../../lib/projects/create/legacy.js';
-import { PROJECT_WITH_APP, EMPTY_PROJECT, } from '../../lib/projects/create/v3.js';
+import { generateComponentPaths } from '../../lib/projects/create/v3.js';
+import { PROJECT_WITH_APP, EMPTY_PROJECT } from '../../lib/constants.js';
 import { uiBetaTag, uiFeatureHighlight } from '../../lib/ui/index.js';
 import { debugError, logError } from '../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
@@ -14,7 +15,6 @@ import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { PLATFORM_VERSIONS } from '@hubspot/local-dev-lib/constants/projects';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { generateComponentPaths } from '../../lib/projects/create/v3.js';
 import { handleProjectCreationFlow, } from '../../lib/projects/create/index.js';
 const command = ['create', 'init'];
 const describe = uiBetaTag(commands.project.create.describe, false);

package/commands/project/validate.js

@@ -42,6 +42,7 @@ async function handler(args) {
     }
     catch (e) {
         logError(e);
+        uiLogger.error(commands.project.validate.failure(projectConfig.name));
         process.exit(EXIT_CODES.ERROR);
     }
     uiLogger.success(commands.project.validate.success(projectConfig.name));

package/commands/sandbox/__tests__/create.test.js

@@ -1,7 +1,43 @@
 import yargs from 'yargs';
 import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
 import sandboxCreateCommand from '../create.js';
+import { hasFeature } from '../../../lib/hasFeature.js';
+import * as sandboxPrompts from '../../../lib/prompts/sandboxesPrompt.js';
+import * as accountNamePrompt from '../../../lib/prompts/accountNamePrompt.js';
+import * as configUtils from '@hubspot/local-dev-lib/config';
+import * as promptUtils from '../../../lib/prompts/promptUtils.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import * as buildAccount from '../../../lib/buildAccount.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import * as sandboxesLib from '../../../lib/sandboxes.js';
+import * as sandboxSync from '../../../lib/sandboxSync.js';
+import { vi } from 'vitest';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../lib/commonOpts');
+vi.mock('../../../lib/hasFeature');
+vi.mock('../../../lib/prompts/sandboxesPrompt');
+vi.mock('../../../lib/prompts/promptUtils');
+vi.mock('../../../lib/prompts/accountNamePrompt');
+vi.mock('../../../lib/sandboxes');
+vi.mock('../../../lib/usageTracking');
+vi.mock('../../../lib/buildAccount');
+vi.mock('../../../lib/sandboxes');
+vi.mock('../../../lib/commonOpts');
+const getAccountConfigSpy = vi.spyOn(configUtils, 'getAccountConfig');
+const promptUserSpy = vi.spyOn(promptUtils, 'promptUser');
+const sandboxTypePromptSpy = vi.spyOn(sandboxPrompts, 'sandboxTypePrompt');
+const processExitSpy = vi.spyOn(process, 'exit');
+const buildSandboxSpy = vi.spyOn(buildAccount, 'buildSandbox');
+const buildV2SandboxSpy = vi.spyOn(buildAccount, 'buildV2Sandbox');
+const getAvailableSyncTypesSpy = vi.spyOn(sandboxesLib, 'getAvailableSyncTypes');
+const syncSandboxSpy = vi.spyOn(sandboxSync, 'syncSandbox');
+const validateSandboxUsageLimitsSpy = vi.spyOn(sandboxesLib, 'validateSandboxUsageLimits');
+const hubspotAccountNamePromptSpy = vi.spyOn(accountNamePrompt, 'hubspotAccountNamePrompt');
+const mockedHasFeatureV2Sandboxes = hasFeature;
+const mockedHasFeatureV2Cli = hasFeature;
 describe('commands/sandbox/create', () => {
     const yargsMock = yargs;
     describe('command', () => {
@@ -28,4 +64,175 @@ describe('commands/sandbox/create', () => {
             expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
         });
     });
+    describe('handler', () => {
+        let args;
+        const sandboxNameFromPrompt = 'sandbox name from prompt';
+        const mockSandbox = {
+            sandboxHubId: 56789,
+            parentHubId: 123456,
+            createdAt: '2025-01-01',
+            type: 'DEVELOPER',
+            archived: false,
+            version: 'V1',
+            status: 'PENDING',
+            name: 'Test Sandbox',
+            domain: 'test-sandbox.hubspot.com',
+            createdByUser: {
+                userId: 11111,
+                email: 'test@test.com',
+                firstName: 'Test',
+                lastName: 'User',
+            },
+        };
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 1234567890,
+            };
+            getAccountConfigSpy.mockReturnValue({
+                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                env: 'prod',
+            });
+            hubspotAccountNamePromptSpy.mockResolvedValue({
+                name: sandboxNameFromPrompt,
+            });
+            sandboxTypePromptSpy.mockResolvedValue({
+                type: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+            });
+            promptUserSpy.mockResolvedValue({
+                contactRecordsSyncPrompt: false,
+            });
+            validateSandboxUsageLimitsSpy.mockResolvedValue(undefined);
+            mockedHasFeatureV2Sandboxes.mockResolvedValue(false);
+            mockedHasFeatureV2Cli.mockResolvedValue(false);
+            buildSandboxSpy.mockResolvedValue({
+                sandbox: mockSandbox,
+                personalAccessKey: 'mock-personal-access-key',
+                name: sandboxNameFromPrompt,
+            });
+            buildV2SandboxSpy.mockResolvedValue({
+                sandbox: { ...mockSandbox, version: 'V2' },
+            });
+            getAvailableSyncTypesSpy.mockResolvedValue([
+                { type: 'object-schemas' },
+                { type: 'workflows' },
+            ]);
+            syncSandboxSpy.mockResolvedValue(undefined);
+            // Spy on process.exit so our tests don't close when it's called
+            // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+            processExitSpy.mockImplementation(() => { });
+        });
+        it('should load the account config for the correct account id', async () => {
+            await sandboxCreateCommand.handler(args);
+            expect(getAccountConfigSpy).toHaveBeenCalledTimes(2); // 1st is for parent account, 2nd is for sandbox account
+            expect(getAccountConfigSpy).toHaveBeenCalledWith(args.derivedAccountId);
+        });
+        it('should track the command usage', async () => {
+            await sandboxCreateCommand.handler(args);
+            expect(trackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(trackCommandUsage).toHaveBeenCalledWith('sandbox-create', {}, args.derivedAccountId);
+        });
+        it('should validate sandbox usage limits', async () => {
+            await sandboxCreateCommand.handler(args);
+            expect(validateSandboxUsageLimitsSpy).toHaveBeenCalledTimes(1);
+            expect(validateSandboxUsageLimitsSpy).toHaveBeenCalledWith({
+                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                env: 'prod',
+            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod');
+        });
+        it('should prompt for the sandbox type if no type is provided in options', async () => {
+            await sandboxCreateCommand.handler(args);
+            expect(sandboxTypePromptSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should not prompt for the sandbox type if type is provided in options', async () => {
+            await sandboxCreateCommand.handler({
+                ...args,
+                type: 'developer',
+            });
+            expect(sandboxTypePromptSpy).toHaveBeenCalledTimes(0);
+        });
+        it('should not prompt for contact records sync if the sandbox type is developer', async () => {
+            await sandboxCreateCommand.handler({
+                ...args,
+                type: 'developer',
+            });
+            expect(promptUserSpy).toHaveBeenCalledTimes(0);
+        });
+        it('should prompt for the contact records sync if the sandbox type is standard', async () => {
+            await sandboxCreateCommand.handler({
+                ...args,
+                type: 'standard',
+            });
+            expect(promptUserSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should build a v1 sandbox if the parent account is not ungated for sandboxes:v2:enabled and not ungated for sandboxes:v2:cliEnabled', async () => {
+            await sandboxCreateCommand.handler(args);
+            expect(buildSandboxSpy).toHaveBeenCalledTimes(1);
+            expect(buildSandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
+                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                env: 'prod',
+            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod', undefined // force
+            );
+            expect(getAvailableSyncTypesSpy).toHaveBeenCalledTimes(1);
+            expect(syncSandboxSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should build a v1 sandbox if the parent account is ungated for sandboxes:v2:enabled but not ungated for sandboxes:v2:cliEnabled', async () => {
+            mockedHasFeatureV2Sandboxes.mockResolvedValue(true);
+            mockedHasFeatureV2Cli.mockResolvedValue(false);
+            await sandboxCreateCommand.handler(args);
+            expect(buildSandboxSpy).toHaveBeenCalledTimes(1);
+            expect(buildSandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
+                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                env: 'prod',
+            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod', undefined // force
+            );
+            expect(getAvailableSyncTypesSpy).toHaveBeenCalledTimes(1);
+            expect(syncSandboxSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should build a v2 sandbox if the parent account is ungated for both sandboxes:v2:enabled and sandboxes:v2:cliEnabled', async () => {
+            mockedHasFeatureV2Sandboxes.mockResolvedValue(true);
+            mockedHasFeatureV2Cli.mockResolvedValue(true);
+            await sandboxCreateCommand.handler(args);
+            expect(buildV2SandboxSpy).toHaveBeenCalledTimes(1);
+            expect(buildV2SandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
+                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                env: 'prod',
+            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, // syncObjectRecords
+            'prod', undefined // force
+            );
+        });
+        it('should log an error and exit when force is used and invalid sandbox type is provided', async () => {
+            await sandboxCreateCommand.handler({
+                ...args,
+                name: sandboxNameFromPrompt,
+                type: 'invalid',
+                force: true,
+            });
+            expect(logger.error).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalled();
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should log an error and exit when force is used and no sandbox name is provided', async () => {
+            await sandboxCreateCommand.handler({
+                ...args,
+                type: 'standard',
+                force: true,
+            });
+            expect(logger.error).toHaveBeenCalled();
+            expect(processExitSpy).toHaveBeenCalled();
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should error out if the default account type is not standard', async () => {
+            getAccountConfigSpy.mockReturnValue({
+                accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                env: 'prod',
+            });
+            await sandboxCreateCommand.handler({
+                ...args,
+                type: 'developer',
+            });
+            expect(logger.error).toHaveBeenCalled();
+            expect(processExitSpy).toHaveBeenCalled();
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
 });

package/commands/sandbox/create.d.ts

@@ -1,5 +1,5 @@
 import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, TestingArgs, YargsCommandModule } from '../../types/Yargs.js';
-type SandboxCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & TestingArgs & {
+export type SandboxCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & TestingArgs & {
     name?: string;
     force?: boolean;
     type?: string;

package/commands/sandbox/create.js

@@ -13,9 +13,11 @@ 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 } from '../../lib/buildAccount.js';
+import { buildSandbox, 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(i18n(`commands.sandbox.subcommands.create.describe`), false);
 async function handler(args) {
@@ -84,7 +86,11 @@ async function handler(args) {
             process.exit(EXIT_CODES.ERROR);
         }
     }
-    const sandboxName = name || namePrompt.name;
+    const sandboxName = name || (namePrompt && namePrompt.name);
+    if (!sandboxName) {
+        logger.error(i18n(`commands.sandbox.subcommands.create.failure.optionMissing.name`));
+        process.exit(EXIT_CODES.ERROR);
+    }
     let contactRecordsSyncPromptResult = false;
     if (!force) {
         const isStandardSandbox = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX;
@@ -100,8 +106,18 @@ 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 {
-        const result = await buildSandbox(sandboxName, accountConfig, sandboxType, env, force);
+        let result;
+        if (canCreateV2Sandbox) {
+            result = await buildV2Sandbox(sandboxName, accountConfig, sandboxType, contactRecordsSyncPromptResult, env, force);
+        }
+        else {
+            result = await buildSandbox(sandboxName, accountConfig, sandboxType, env, force);
+        }
         const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
         // Check if sandbox account config exists
         if (!sandboxAccountConfig) {
@@ -111,20 +127,19 @@ async function handler(args) {
             }));
             process.exit(EXIT_CODES.ERROR);
         }
-        // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
-        async function handleSyncSandbox(syncTasks) {
-            await syncSandbox(sandboxAccountConfig, accountConfig, env, syncTasks);
-        }
-        try {
-            let availableSyncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
-            if (!contactRecordsSyncPromptResult) {
-                availableSyncTasks = availableSyncTasks.filter(t => t.type !== SYNC_TYPES.OBJECT_RECORDS);
+        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;
             }
-            await handleSyncSandbox(availableSyncTasks);
-        }
-        catch (err) {
-            logError(err);
-            throw err;
         }
         const highlightItems = ['accountsUseCommand', 'projectCreateCommand'];
         if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {

package/commands/testAccount/createConfig.js

@@ -7,7 +7,7 @@ import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { commands } from '../../lang/en.js';
-import { createDeveloperTestAccountConfigPrompt, } from '../../lib/prompts/createDeveloperTestAccountConfigPrompt.js';
+import { createDeveloperTestAccountConfigPrompt } from '../../lib/prompts/createDeveloperTestAccountConfigPrompt.js';
 import { fileExists } from '../../lib/validation.js';
 const command = 'create-config';
 const describe = commands.testAccount.createConfig.describe;

package/lang/en.d.ts

@@ -79,6 +79,7 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
                     readonly personalAccessKey: "Enter existing personal access key";
                 };
                 readonly errors: {
+                    readonly invalidAccountIdProvided: "--account must be a number.";
                     readonly failedToUpdateConfig: "Failed to update the configuration file. Please try again.";
                     readonly migrationNotConfirmed: `Did not migrate your configuration file. Run ${string} to update your existing config, or use ${string} to switch to the new global configuration.`;
                     readonly mergeNotConfirmed: `Did not merge configuration files. When you are ready to merge the deprecated config file with the global config file, run ${string}.`;
@@ -252,6 +253,9 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
                     readonly allowAutoUpdates: {
                         readonly describe: "Enable or disable auto updates";
                     };
+                    readonly autoOpenBrowser: {
+                        readonly describe: "Enable or disable automatic opening of the browser";
+                    };
                 };
             };
         };
@@ -825,9 +829,9 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
         readonly setup: {
             readonly installingDocSearch: "Adding the docs-search mcp server";
             readonly claudeCode: "Claude Code";
-            readonly claudeDesktop: "Claude Desktop";
             readonly cursor: "Cursor";
             readonly windsurf: "Windsurf";
+            readonly vsCode: "VSCode";
             readonly args: {
                 readonly client: "Target applications to configure";
                 readonly docsSearch: "Should the docs search mcp server be installed";
@@ -839,8 +843,6 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
             };
             readonly spinners: {
                 readonly failedToConfigure: "Failed to configure the HubSpot mcp server.";
-                readonly configuringClaudeDesktop: "Configuring Claude Desktop...";
-                readonly configuredClaudeDesktop: "Configured Claude Desktop";
                 readonly configuringClaudeCode: "Configuring Claude Code...";
                 readonly configuredClaudeCode: "Configured Claude Code";
                 readonly claudeCodeNotFound: "Claude Code not found - skipping configuration";
@@ -853,6 +855,10 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
                 readonly configuringWindsurf: "Configuring Windsurf...";
                 readonly failedToConfigureWindsurf: "Failed to configure Windsurf";
                 readonly configuredWindsurf: "Configured Windsurf";
+                readonly configuringVsCode: "Configuring VSCode...";
+                readonly failedToConfigureVsCode: "Failed to configure VSCode";
+                readonly configuredVsCode: "Configured VSCode";
+                readonly vsCodeNotFound: "VSCode not found - skipping configuration";
             };
             readonly prompts: {
                 readonly targets: "[--client] Which tools would you like to add the HubSpot CLI MCP server to?";
@@ -1383,6 +1389,7 @@ ${string}`;
                 readonly default: "Validate the project before uploading";
             };
             readonly success: (projectName: string) => string;
+            readonly failure: (projectName: string) => string;
             readonly options: {
                 readonly profile: {
                     readonly describe: "The profile to target for this validation";
@@ -2459,7 +2466,8 @@ export declare const lib: {
         readonly running: (projectName: string, accountIdentifier: string) => string;
         readonly quitHelper: `Press ${string} to stop the local dev server`;
         readonly viewProjectLink: (name: string, accountId: number) => string;
-        readonly viewLocalDevUILink: (accountId: number) => string;
+        readonly viewLocalDevUILink: (accountId: number, showWelcomeScreen: boolean) => string;
+        readonly localDevUIAutoMessage: (accountId: number, showWelcomeScreen: boolean) => string;
         readonly viewTestAccountLink: "View developer test account in HubSpot";
         readonly exitingStart: "Stopping local dev server ...";
         readonly exitingSucceed: "Successfully exited";
@@ -2791,6 +2799,11 @@ Run ${string} to upgrade to version ${string}`;
             readonly promptMessage: "Enter http timeout duration";
             readonly success: (timeout: string) => string;
         };
+        readonly setAutoOpenBrowser: {
+            readonly fieldName: "auto open browser";
+            readonly enabled: "Auto opening your browser has been enabled";
+            readonly disabled: "Auto opening your browser has been disabled";
+        };
     };
     readonly commonOpts: {
         readonly options: {