@hubspot/cli 7.10.0-beta.0 → 7.10.0-beta.1

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

@@ -1,83 +1,54 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { validateProjectConfig } from '../../projects/config.js';
-import { uiLogger } from '../../ui/logger.js';
+import ProjectValidationError from '../../errors/ProjectValidationError.js';
 vi.mock('../../ui/logger.js');
 describe('lib/projects', () => {
     describe('validateProjectConfig()', () => {
         let projectDir;
-        let exitMock;
         beforeAll(() => {
             projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'projects-'));
             fs.mkdirSync(path.join(projectDir, 'src'));
         });
-        beforeEach(() => {
-            // @ts-expect-error - Mocking process.exit
-            exitMock = vi
-                .spyOn(process, 'exit')
-                .mockImplementation(() => undefined);
-        });
-        afterEach(() => {
-            exitMock.mockRestore();
-        });
         it('rejects undefined configuration', () => {
             // @ts-ignore Testing invalid input
-            validateProjectConfig(null, projectDir);
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/));
+            expect(() => validateProjectConfig(null, projectDir)).toThrow(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/);
         });
         it('rejects configuration with missing name', () => {
             // @ts-ignore Testing invalid input
-            validateProjectConfig({ srcDir: '.' }, projectDir);
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields*/));
+            expect(() => validateProjectConfig({ srcDir: '.' }, projectDir)).toThrow(/.*missing required fields*/);
         });
         it('rejects configuration with missing srcDir', () => {
+            expect(() => 
             // @ts-ignore Testing invalid input
-            validateProjectConfig({ name: 'hello' }, projectDir);
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields.*/));
+            validateProjectConfig({ name: 'hello' }, projectDir)).toThrow(/.*missing required fields.*/);
         });
         describe('rejects configuration with srcDir outside project directory', () => {
             it('for parent directory', () => {
-                validateProjectConfig({ name: 'hello', srcDir: '..', platformVersion: '' }, projectDir);
-                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: ".."'));
+                expect(() => validateProjectConfig({ name: 'hello', srcDir: '..', platformVersion: '' }, projectDir)).toThrow(/srcDir: "\.\."/);
             });
             it('for root directory', () => {
-                validateProjectConfig({ name: 'hello', srcDir: '/', platformVersion: '' }, projectDir);
-                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: "/"'));
+                expect(() => validateProjectConfig({ name: 'hello', srcDir: '/', platformVersion: '' }, projectDir)).toThrow(/srcDir: "\/"/);
             });
             it('for complicated directory', () => {
                 const srcDir = './src/././../src/../../src';
-                validateProjectConfig({ name: 'hello', srcDir, platformVersion: '' }, projectDir);
-                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining(`srcDir: "${srcDir}"`));
+                expect(() => validateProjectConfig({ name: 'hello', srcDir, platformVersion: '' }, projectDir)).toThrow(ProjectValidationError);
+                expect(() => validateProjectConfig({ name: 'hello', srcDir, platformVersion: '' }, projectDir)).toThrow(/srcDir:/);
             });
         });
         it('rejects configuration with srcDir that does not exist', () => {
-            validateProjectConfig({ name: 'hello', srcDir: 'foo', platformVersion: '' }, projectDir);
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*could not be found in.*/));
+            expect(() => validateProjectConfig({ name: 'hello', srcDir: 'foo', platformVersion: '' }, projectDir)).toThrow(/.*could not be found in.*/);
         });
         describe('accepts configuration with valid srcDir', () => {
             it('for current directory', () => {
-                validateProjectConfig({ name: 'hello', srcDir: '.', platformVersion: '' }, projectDir);
-                expect(exitMock).not.toHaveBeenCalled();
-                expect(uiLogger.error).not.toHaveBeenCalled();
+                expect(() => validateProjectConfig({ name: 'hello', srcDir: '.', platformVersion: '' }, projectDir)).not.toThrow();
             });
             it('for relative directory', () => {
-                validateProjectConfig({ name: 'hello', srcDir: './src', platformVersion: '' }, projectDir);
-                expect(exitMock).not.toHaveBeenCalled();
-                expect(uiLogger.error).not.toHaveBeenCalled();
+                expect(() => validateProjectConfig({ name: 'hello', srcDir: './src', platformVersion: '' }, projectDir)).not.toThrow();
             });
             it('for implied relative directory', () => {
-                validateProjectConfig({ name: 'hello', srcDir: 'src', platformVersion: '' }, projectDir);
-                expect(exitMock).not.toHaveBeenCalled();
-                expect(uiLogger.error).not.toHaveBeenCalled();
+                expect(() => validateProjectConfig({ name: 'hello', srcDir: 'src', platformVersion: '' }, projectDir)).not.toThrow();
             });
         });
     });

package/lib/projects/components.js

@@ -1,9 +1,51 @@
 import path from 'path';
 import fs from 'fs';
 import { coerceToValidUid, metafileExtension, } from '@hubspot/project-parsing-lib';
+import { fileExists } from '../validation.js';
 import { uiLogger } from '../ui/logger.js';
 import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 import { lib } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+// Prefix for the metafile extension
+const metafileExtensionPrefix = path.parse(metafileExtension).name;
+function applyDifferentiatorToFilename(filename, differentiator, isHsMetaFile) {
+    const { name, ext, dir } = path.parse(filename);
+    if (isHsMetaFile) {
+        return path.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${differentiator}${metafileExtension}`);
+    }
+    return path.join(dir, `${name}-${differentiator}${ext}`);
+}
+// Generates safe filename differentiators, avoiding collisions with existing filenames
+// E.x. "NewCard.tsx" -> "NewCard-1.tsx"
+function generateSafeFilenameDifferentiator(sourceFiles, hsMetaFiles) {
+    let differentiator = 1;
+    let isDifferentiatorUnique = false;
+    let maxAttempts = 10;
+    while (!isDifferentiatorUnique) {
+        differentiator++;
+        maxAttempts--;
+        try {
+            const isDifferentiatorUniqueForSourceFiles = sourceFiles.every(file => {
+                return !fileExists(applyDifferentiatorToFilename(file, differentiator, false));
+            });
+            const isDifferentiatorUniqueForHsMetaFiles = hsMetaFiles.every(file => {
+                return !fileExists(applyDifferentiatorToFilename(file, differentiator, true));
+            });
+            isDifferentiatorUnique =
+                isDifferentiatorUniqueForSourceFiles &&
+                    isDifferentiatorUniqueForHsMetaFiles;
+        }
+        catch (error) {
+            uiLogger.debug(lib.projects.generateSafeFilenameDifferentiator.failedToCheckFiles);
+            maxAttempts = 0;
+        }
+        // If we've tried too many times, just use a timestamp
+        if (maxAttempts <= 0) {
+            return Date.now();
+        }
+    }
+    return differentiator;
+}
 // Handles a collision between component source files
 export function handleComponentCollision({ dest, src, collisions }) {
     const hsMetaFiles = [];
@@ -20,19 +62,20 @@ export function handleComponentCollision({ dest, src, collisions }) {
             sourceFiles.push(collision);
         }
     });
-    const sourceFilenameMapping = sourceFiles.reduce((acc, filename) => {
-        const { name, ext, dir } = path.parse(filename);
+    const filenameDifferentiator = generateSafeFilenameDifferentiator(sourceFiles, hsMetaFiles);
+    // Exclude markdown files fromthe rename process because they should not be duplicated
+    const sourceFilenameMapping = sourceFiles
+        .filter(filename => !filename.endsWith('.md'))
+        .reduce((acc, filename) => {
         return {
             ...acc,
-            [filename]: path.join(dir, `${name}-${Date.now()}${ext}`),
+            [filename]: applyDifferentiatorToFilename(filename, filenameDifferentiator, false),
         };
     }, {});
-    const metafileExtensionPrefix = path.parse(metafileExtension).name;
     const metaFilenameMapping = hsMetaFiles.reduce((acc, filename) => {
-        const { name, dir } = path.parse(filename);
         return {
             ...acc,
-            [filename]: path.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${Date.now()}${metafileExtension}`),
+            [filename]: applyDifferentiatorToFilename(filename, filenameDifferentiator, true),
         };
     }, {});
     // Update the metafiles that might contain references to the old filenames
@@ -81,22 +124,35 @@ export function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFile
     uiLogger.log('');
     uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.header);
     for (const hsMetaFile of hsMetaFilePaths) {
-        const component = JSON.parse(fs.readFileSync(hsMetaFile).toString());
-        let uid = coerceToValidUid(`${component.type}-${projectName}`) || component.uid;
-        if (existingUids.includes(uid)) {
-            uid =
-                coerceToValidUid(`${component.type}-${Date.now()}-${projectName}`) ||
-                    component.uid;
+        try {
+            const component = JSON.parse(fs.readFileSync(hsMetaFile).toString());
+            const getBaseUid = () => {
+                const customUid = coerceToValidUid(`${projectName}_${component.type}`);
+                if (customUid) {
+                    return customUid.replace(/-/g, '_');
+                }
+                return component.uid;
+            };
+            let uid = getBaseUid();
+            let differentiator = 1;
+            while (existingUids.includes(uid)) {
+                differentiator++;
+                uid = `${getBaseUid()}-${differentiator}`;
+            }
+            component.uid = uid;
+            if (component.type === AppKey && component.config) {
+                component.config.name = `${projectName}-Application`;
+                uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.applicationLog(component.type, component.uid, component.config.name));
+            }
+            else {
+                uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.componentLog(component.type, component.uid));
+            }
+            fs.writeFileSync(hsMetaFile, JSON.stringify(component, null, 2));
         }
-        component.uid = uid;
-        if (component.type === AppKey && component.config) {
-            component.config.name = `${projectName}-Application`;
-            uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.applicationLog(component.type, component.uid, component.config.name));
-        }
-        else {
-            uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.componentLog(component.type, component.uid));
+        catch (error) {
+            debugError(error);
+            uiLogger.error(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.failedToUpdate(hsMetaFile));
         }
-        fs.writeFileSync(hsMetaFile, JSON.stringify(component, null, 2));
     }
     uiLogger.log('');
 }

package/lib/projects/config.js

@@ -4,8 +4,8 @@ import findup from 'findup-sync';
 import { getAbsoluteFilePath, getCwd } from '@hubspot/local-dev-lib/path';
 import { PROJECT_CONFIG_FILE } from '../constants.js';
 import { lib } from '../../lang/en.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { uiLogger } from '../ui/logger.js';
+import ProjectValidationError from '../errors/ProjectValidationError.js';
 export function writeProjectConfig(configPath, config) {
     try {
         fs.ensureFileSync(configPath);
@@ -50,21 +50,17 @@ export async function getProjectConfig(dir) {
 }
 export function validateProjectConfig(projectConfig, projectDir) {
     if (!projectConfig || !projectDir) {
-        uiLogger.error(lib.projects.validateProjectConfig.configNotFound);
-        return process.exit(EXIT_CODES.ERROR);
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.configNotFound);
     }
     if (!projectConfig.name || !projectConfig.srcDir) {
-        uiLogger.error(lib.projects.validateProjectConfig.configMissingFields);
-        return process.exit(EXIT_CODES.ERROR);
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.configMissingFields);
     }
     const resolvedPath = path.resolve(projectDir, projectConfig.srcDir);
     if (!resolvedPath.startsWith(projectDir)) {
         const projectConfigFile = path.relative('.', path.join(projectDir, PROJECT_CONFIG_FILE));
-        uiLogger.error(lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
-        return process.exit(EXIT_CODES.ERROR);
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
     }
     if (!fs.existsSync(resolvedPath)) {
-        uiLogger.error(lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
-        return process.exit(EXIT_CODES.ERROR);
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
     }
 }

package/lib/prompts/__tests__/createDeveloperTestAccountConfigPrompt.test.d.ts

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

package/lib/prompts/__tests__/createDeveloperTestAccountConfigPrompt.test.js

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createDeveloperTestAccountConfigPrompt } from '../createDeveloperTestAccountConfigPrompt.js';
+import * as promptUtils from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+describe('createDeveloperTestAccountConfigPrompt', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('with name and description provided via args', () => {
+        it('should skip name and description prompts when provided', async () => {
+            const mockPromptUser = vi.mocked(promptUtils.promptUser);
+            mockPromptUser.mockResolvedValueOnce({}); // name/description prompts skipped
+            mockPromptUser.mockResolvedValueOnce({
+                useDefaultAccountLevels: 'default',
+            }); // tier selection
+            const result = await createDeveloperTestAccountConfigPrompt({
+                name: 'TestAccount',
+                description: 'Test description',
+            });
+            expect(result).toEqual({
+                accountName: 'TestAccount',
+                description: 'Test description',
+                marketingLevel: 'ENTERPRISE',
+                opsLevel: 'ENTERPRISE',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'ENTERPRISE',
+                contentLevel: 'ENTERPRISE',
+            });
+            expect(mockPromptUser).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('with tier flags provided', () => {
+        it('should skip tier prompts and use provided values with defaults', async () => {
+            const mockPromptUser = vi.mocked(promptUtils.promptUser);
+            mockPromptUser.mockResolvedValueOnce({}); // name/description prompts skipped
+            const result = await createDeveloperTestAccountConfigPrompt({
+                name: 'TestAccount',
+                description: 'Test',
+                marketingLevel: 'PROFESSIONAL',
+                salesLevel: 'STARTER',
+            });
+            expect(result).toEqual({
+                accountName: 'TestAccount',
+                description: 'Test',
+                marketingLevel: 'PROFESSIONAL',
+                opsLevel: 'ENTERPRISE',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'STARTER',
+                contentLevel: 'ENTERPRISE',
+            });
+            // Should only call promptUser once (for name/description which are skipped)
+            expect(mockPromptUser).toHaveBeenCalledTimes(1);
+        });
+        it('should default unprovided tiers to ENTERPRISE', async () => {
+            const mockPromptUser = vi.mocked(promptUtils.promptUser);
+            mockPromptUser.mockResolvedValueOnce({
+                description: 'Test',
+            }); // description prompt (name provided via args, description not provided)
+            const result = await createDeveloperTestAccountConfigPrompt({
+                name: 'TestAccount',
+                contentLevel: 'FREE',
+            });
+            expect(result).toEqual({
+                accountName: 'TestAccount',
+                description: 'Test',
+                marketingLevel: 'ENTERPRISE',
+                opsLevel: 'ENTERPRISE',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'ENTERPRISE',
+                contentLevel: 'FREE',
+            });
+        });
+    });
+    describe('with no flags provided', () => {
+        it('should prompt for name, description, and tier selection', async () => {
+            const mockPromptUser = vi.mocked(promptUtils.promptUser);
+            // First call: name/description prompts
+            mockPromptUser.mockResolvedValueOnce({
+                accountName: 'PromptedAccount',
+                description: 'Prompted description',
+            });
+            // Second call: tier selection
+            mockPromptUser.mockResolvedValueOnce({
+                useDefaultAccountLevels: 'default',
+            });
+            const result = await createDeveloperTestAccountConfigPrompt({});
+            expect(result).toEqual({
+                accountName: 'PromptedAccount',
+                description: 'Prompted description',
+                marketingLevel: 'ENTERPRISE',
+                opsLevel: 'ENTERPRISE',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'ENTERPRISE',
+                contentLevel: 'ENTERPRISE',
+            });
+            expect(mockPromptUser).toHaveBeenCalledTimes(2);
+        });
+        it('should allow manual tier selection', async () => {
+            const mockPromptUser = vi.mocked(promptUtils.promptUser);
+            mockPromptUser.mockResolvedValueOnce({
+                accountName: 'TestAccount',
+                description: 'Test',
+            }); // name/description
+            mockPromptUser.mockResolvedValueOnce({
+                useDefaultAccountLevels: 'manual',
+            }); // tier choice
+            mockPromptUser.mockResolvedValueOnce({
+                testAccountLevels: [
+                    { hub: 'MARKETING', tier: 'PROFESSIONAL' },
+                    { hub: 'OPS', tier: 'STARTER' },
+                    { hub: 'SERVICE', tier: 'ENTERPRISE' },
+                    { hub: 'SALES', tier: 'FREE' },
+                    { hub: 'CONTENT', tier: 'ENTERPRISE' },
+                ],
+            }); // manual tier selection
+            const result = await createDeveloperTestAccountConfigPrompt({});
+            expect(result).toEqual({
+                accountName: 'TestAccount',
+                description: 'Test',
+                marketingLevel: 'PROFESSIONAL',
+                opsLevel: 'STARTER',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'FREE',
+                contentLevel: 'ENTERPRISE',
+            });
+            expect(mockPromptUser).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('with only name provided', () => {
+        it('should skip name prompt but show description and tier prompts', async () => {
+            const mockPromptUser = vi.mocked(promptUtils.promptUser);
+            mockPromptUser.mockResolvedValueOnce({
+                description: 'Prompted description',
+            }); // description prompt (name skipped)
+            mockPromptUser.mockResolvedValueOnce({
+                useDefaultAccountLevels: 'default',
+            }); // tier selection
+            const result = await createDeveloperTestAccountConfigPrompt({
+                name: 'TestAccount',
+            });
+            expect(result).toEqual({
+                accountName: 'TestAccount',
+                description: 'Prompted description',
+                marketingLevel: 'ENTERPRISE',
+                opsLevel: 'ENTERPRISE',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'ENTERPRISE',
+                contentLevel: 'ENTERPRISE',
+            });
+            expect(mockPromptUser).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/lib/prompts/createDeveloperTestAccountConfigPrompt.d.ts

@@ -14,5 +14,10 @@ export type HubConfig = {
 export declare function createDeveloperTestAccountConfigPrompt(args?: {
     name?: string;
     description?: string;
+    marketingLevel?: AccountLevel;
+    opsLevel?: AccountLevel;
+    serviceLevel?: AccountLevel;
+    salesLevel?: AccountLevel;
+    contentLevel?: AccountLevel;
 }, supportFlags?: boolean): Promise<DeveloperTestAccountConfig>;
 export {};

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -49,15 +49,17 @@ const TEST_ACCOUNT_TIERS = [
     new Separator(),
 ];
 export async function createDeveloperTestAccountConfigPrompt(args = {}, supportFlags = true) {
-    const { name, description } = args;
-    let accountName = name;
-    let accountDescription = description;
-    let accountLevelsArray = [];
-    if (!accountName) {
-        const namePromptResult = await promptUser({
+    const hasAnyTierLevels = !!(args.marketingLevel ||
+        args.opsLevel ||
+        args.serviceLevel ||
+        args.salesLevel ||
+        args.contentLevel);
+    const result = await promptUser([
+        {
             name: 'accountName',
             message: lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt(supportFlags),
             type: 'input',
+            when: !args.name,
             validate: value => {
                 if (!value) {
                     return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
@@ -65,58 +67,67 @@ export async function createDeveloperTestAccountConfigPrompt(args = {}, supportF
                 }
                 return true;
             },
-        });
-        accountName = namePromptResult.accountName;
-    }
-    if (!accountDescription) {
-        const descriptionPromptResult = await promptUser({
+        },
+        {
             name: 'description',
             message: lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt(supportFlags),
             type: 'input',
-        });
-        accountDescription = descriptionPromptResult.description;
-    }
-    const useDefaultAccountLevelsPromptResult = await promptUser({
-        name: 'useDefaultAccountLevels',
-        message: lib.prompts.createDeveloperTestAccountConfigPrompt
-            .useDefaultAccountLevelsPrompt.message,
-        type: 'list',
-        choices: [
-            {
-                name: lib.prompts.createDeveloperTestAccountConfigPrompt
-                    .useDefaultAccountLevelsPrompt.default,
-                value: 'default',
-            },
-            {
-                name: lib.prompts.createDeveloperTestAccountConfigPrompt
-                    .useDefaultAccountLevelsPrompt.manual,
-                value: 'manual',
-            },
-        ],
-    });
-    if (useDefaultAccountLevelsPromptResult.useDefaultAccountLevels === 'default') {
-        accountLevelsArray = [
-            { hub: 'MARKETING', tier: AccountTiers.ENTERPRISE },
-            { hub: 'OPS', tier: AccountTiers.ENTERPRISE },
-            { hub: 'SERVICE', tier: AccountTiers.ENTERPRISE },
-            { hub: 'SALES', tier: AccountTiers.ENTERPRISE },
-            { hub: 'CONTENT', tier: AccountTiers.ENTERPRISE },
-        ];
+            when: !args.description,
+        },
+    ]);
+    const accountName = args.name || result.accountName;
+    const description = args.description || result.description;
+    let accountLevels = {};
+    if (hasAnyTierLevels) {
+        accountLevels = {
+            marketingLevel: args.marketingLevel || 'ENTERPRISE',
+            opsLevel: args.opsLevel || 'ENTERPRISE',
+            serviceLevel: args.serviceLevel || 'ENTERPRISE',
+            salesLevel: args.salesLevel || 'ENTERPRISE',
+            contentLevel: args.contentLevel || 'ENTERPRISE',
+        };
     }
     else {
-        const accountLevelsPromptResult = await promptUser({
-            name: 'testAccountLevels',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
-            type: 'checkbox',
-            pageSize: 13,
-            choices: TEST_ACCOUNT_TIERS,
-            loop: false,
-            validate: choices => {
-                if (choices?.length < Object.keys(hubs).length) {
-                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                        .allHubsRequired;
-                }
-                else {
+        const tierChoiceResult = await promptUser({
+            name: 'useDefaultAccountLevels',
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt
+                .useDefaultAccountLevelsPrompt.message,
+            type: 'list',
+            choices: [
+                {
+                    name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                        .useDefaultAccountLevelsPrompt.default,
+                    value: 'default',
+                },
+                {
+                    name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                        .useDefaultAccountLevelsPrompt.manual,
+                    value: 'manual',
+                },
+            ],
+        });
+        if (tierChoiceResult.useDefaultAccountLevels === 'default') {
+            accountLevels = {
+                marketingLevel: 'ENTERPRISE',
+                opsLevel: 'ENTERPRISE',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'ENTERPRISE',
+                contentLevel: 'ENTERPRISE',
+            };
+        }
+        else {
+            const tierResult = await promptUser({
+                name: 'testAccountLevels',
+                message: lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
+                type: 'checkbox',
+                pageSize: 13,
+                choices: TEST_ACCOUNT_TIERS,
+                loop: false,
+                validate: choices => {
+                    if (choices?.length < Object.keys(hubs).length) {
+                        return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                            .allHubsRequired;
+                    }
                     const hubMap = {};
                     for (const choice of choices) {
                         const { hub } = choice.value;
@@ -126,21 +137,20 @@ export async function createDeveloperTestAccountConfigPrompt(args = {}, supportF
                         }
                         hubMap[hub] = true;
                     }
-                }
-                return true;
-            },
-        });
-        accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
+                    return true;
+                },
+            });
+            accountLevels = tierResult.testAccountLevels.reduce((acc, level) => {
+                const { hub: hubName, tier: hubTier } = level;
+                const hubLevel = hubs[hubName];
+                acc[hubLevel] = hubTier;
+                return acc;
+            }, {});
+        }
     }
-    const accountLevels = accountLevelsArray.reduce((acc, level) => {
-        const { hub: hubName, tier: hubTier } = level;
-        const hubLevel = hubs[hubName];
-        acc[hubLevel] = hubTier;
-        return acc;
-    }, {});
     return {
-        accountName: accountName,
-        description: accountDescription,
+        accountName,
+        description,
         ...accountLevels,
     };
 }

package/mcp-server/tools/cms/HsCreateFunctionTool.js

@@ -91,6 +91,12 @@ export class HsCreateFunctionTool extends Tool {
             title: 'Create HubSpot CMS Serverless Function',
             description: `Creates a new HubSpot CMS serverless function using the hs create function command. Functions can be created non-interactively by specifying functionsFolder, filename, and endpointPath. Supports all HTTP methods (${HTTP_METHODS.join(', ')}).`,
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

package/mcp-server/tools/cms/HsCreateModuleTool.d.ts

@@ -13,20 +13,20 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     absoluteCurrentWorkingDirectory: string;
     dest?: string | undefined;
+    global?: boolean | undefined;
     moduleLabel?: string | undefined;
     reactType?: boolean | undefined;
-    global?: boolean | undefined;
-    availableForNewContent?: boolean | undefined;
     contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
     userSuppliedName?: string | undefined;
 }, {
     absoluteCurrentWorkingDirectory: string;
     dest?: string | undefined;
+    global?: boolean | undefined;
     moduleLabel?: string | undefined;
     reactType?: boolean | undefined;
-    global?: boolean | undefined;
-    availableForNewContent?: boolean | undefined;
     contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
     userSuppliedName?: string | undefined;
 }>;
 export type HsCreateModuleInputSchema = z.infer<typeof inputSchemaZodObject>;

package/mcp-server/tools/cms/HsCreateModuleTool.js

@@ -113,6 +113,12 @@ export class HsCreateModuleTool extends Tool {
             title: 'Create HubSpot CMS Module',
             description: 'Creates a new HubSpot CMS module using the hs create module command. Modules can be created non-interactively by specifying moduleLabel and other module options. You can create either HubL or React modules by setting the reactType parameter.',
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }