@hubspot/cli 7.7.23-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/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/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}.`;
@@ -828,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";
@@ -842,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";
@@ -856,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?";
@@ -1386,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";

package/lang/en.js

@@ -4,8 +4,7 @@ import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constant
 import { ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME, GLOBAL_CONFIG_PATH, DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME, } from '@hubspot/local-dev-lib/constants/config';
 import { uiAccountDescription, uiBetaTag, uiCommandReference, uiLink, UI_COLORS, } from '../lib/ui/index.js';
 import { getProjectDetailUrl, getProjectSettingsUrl, getLocalDevUiUrl, } from '../lib/projects/urls.js';
-import { PROJECT_CONFIG_FILE } from '../lib/constants.js';
-import { PROJECT_WITH_APP } from '../lib/projects/create/v3.js';
+import { PROJECT_CONFIG_FILE, PROJECT_WITH_APP } from '../lib/constants.js';
 export const commands = {
     generalErrors: {
         srcIsProject: (src, command) => `"${src}" is in a project folder. Did you mean "hs project ${command}"?`,
@@ -80,6 +79,7 @@ export const commands = {
                     personalAccessKey: 'Enter existing personal access key',
                 },
                 errors: {
+                    invalidAccountIdProvided: `--account must be a number.`,
                     failedToUpdateConfig: 'Failed to update the configuration file. Please try again.',
                     migrationNotConfirmed: `Did not migrate your configuration file. Run ${uiCommandReference('hs auth')} to update your existing config, or use ${uiCommandReference('hs config migrate')} to switch to the new global configuration.`,
                     mergeNotConfirmed: `Did not merge configuration files. When you are ready to merge the deprecated config file with the global config file, run ${uiCommandReference('hs config migrate')}.`,
@@ -831,9 +831,9 @@ export const commands = {
         setup: {
             installingDocSearch: 'Adding the docs-search mcp server',
             claudeCode: 'Claude Code',
-            claudeDesktop: 'Claude Desktop',
             cursor: 'Cursor',
             windsurf: 'Windsurf',
+            vsCode: 'VSCode',
             args: {
                 client: 'Target applications to configure',
                 docsSearch: 'Should the docs search mcp server be installed',
@@ -845,20 +845,26 @@ export const commands = {
             },
             spinners: {
                 failedToConfigure: 'Failed to configure the HubSpot mcp server.',
-                configuringClaudeDesktop: 'Configuring Claude Desktop...',
-                configuredClaudeDesktop: 'Configured Claude Desktop',
+                // Claude
                 configuringClaudeCode: 'Configuring Claude Code...',
                 configuredClaudeCode: 'Configured Claude Code',
                 claudeCodeNotFound: 'Claude Code not found - skipping configuration',
                 claudeCodeInstallFailed: 'Claude Code CLI not working - skipping configuration',
                 failedToConfigureClaudeDesktop: 'Failed to configure Claude Desktop',
+                // Cursor
                 configuringCursor: 'Configuring Cursor...',
                 failedToConfigureCursor: 'Failed to configure Cursor',
                 configuredCursor: 'Configured Cursor',
                 alreadyInstalled: 'HubSpot CLI mcp server already installed, reinstalling',
+                // Windsurf
                 configuringWindsurf: 'Configuring Windsurf...',
                 failedToConfigureWindsurf: 'Failed to configure Windsurf',
                 configuredWindsurf: 'Configured Windsurf',
+                // VS Code
+                configuringVsCode: 'Configuring VSCode...',
+                failedToConfigureVsCode: 'Failed to configure VSCode',
+                configuredVsCode: 'Configured VSCode',
+                vsCodeNotFound: 'VSCode not found - skipping configuration',
             },
             prompts: {
                 targets: '[--client] Which tools would you like to add the HubSpot CLI MCP server to?',
@@ -1378,6 +1384,7 @@ export const commands = {
                 default: 'Validate the project before uploading',
             },
             success: (projectName) => `Project ${projectName} is valid and ready to upload`,
+            failure: (projectName) => `Project ${projectName} is invalid`,
             options: {
                 profile: {
                     describe: 'The profile to target for this validation',

package/lang/en.lyaml

@@ -1038,12 +1038,14 @@ en:
         compressing: "Compressing build files to \"{{ path }}\""
         fileFiltered: "Ignore rule triggered for \"{{ filename }}\""
     ui:
-      betaTag: "{{#bold}}[BETA]{{/bold}}"
+      betaTag: "[BETA]"
+      betaTagWithStyle: "{{#bold}}[BETA]{{/bold}}"
       betaWarning:
         header: "{{#yellow}}***************************** WARNING ****************************{{/yellow}}"
         footer: "{{#yellow}}******************************************************************{{/yellow}}"
       infoTag: "{{#bold}}[INFO]{{/bold}}"
-      deprecatedTag: "{{#bold}}[DEPRECATED]{{/bold}}"
+      deprecatedTag: "[DEPRECATED]"
+      deprecatedTagWithStyle: "{{#bold}}[DEPRECATED]{{/bold}}"
       errorTag: "{{#bold}}[ERROR]{{/bold}}"
       deprecatedMessage: "The {{ command }} command is deprecated and will be disabled soon. {{ url }}"
       deprecatedDescription: "{{ message }}. The {{ command }} command is deprecated and will be disabled soon. {{ url }}"