@hubspot/cli 7.7.28-experimental.0 → 7.7.30-experimental.0

package/commands/project/__tests__/add.test.js

@@ -1,7 +1,22 @@
 import yargs from 'yargs';
 import projectAddCommand from '../add.js';
 import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, } from '../../../lib/constants.js';
+import { v3AddComponent } from '../../../lib/projects/add/v3AddComponent.js';
+import { legacyAddComponent } from '../../../lib/projects/add/legacyAddComponent.js';
+import { getProjectConfig } from '../../../lib/projects/config.js';
+import { useV3Api } from '../../../lib/projects/buildAndDeploy.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
 vi.mock('../../../lib/commonOpts');
+vi.mock('../../../lib/projects/add/v3AddComponent');
+vi.mock('../../../lib/projects/add/legacyAddComponent');
+vi.mock('../../../lib/projects/config');
+vi.mock('../../../lib/projects/buildAndDeploy');
+vi.mock('../../../lib/usageTracking');
+const mockedV3AddComponent = vi.mocked(v3AddComponent);
+const mockedLegacyAddComponent = vi.mocked(legacyAddComponent);
+const mockedGetProjectConfig = vi.mocked(getProjectConfig);
+const mockedUseV3Api = vi.mocked(useV3Api);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('commands/project/add', () => {
     const yargsMock = yargs;
     describe('command', () => {
@@ -40,4 +55,55 @@ describe('commands/project/add', () => {
             });
         });
     });
+    describe('handler', () => {
+        const mockProjectConfig = {
+            name: 'test-project',
+            srcDir: 'src',
+            platformVersion: 'v3',
+        };
+        const mockProjectDir = '/path/to/project';
+        const mockArgs = {
+            derivedAccountId: 123,
+            name: 'test-component',
+            type: 'module',
+        };
+        beforeEach(() => {
+            mockedGetProjectConfig.mockResolvedValue({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            mockedTrackCommandUsage.mockResolvedValue();
+            mockedV3AddComponent.mockResolvedValue();
+            mockedLegacyAddComponent.mockResolvedValue();
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error('process.exit called');
+            });
+        });
+        it('should call v3AddComponent with accountId for v3 projects', async () => {
+            mockedUseV3Api.mockReturnValue(true);
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', undefined, 123);
+            expect(mockedV3AddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig, 123);
+            expect(mockedLegacyAddComponent).not.toHaveBeenCalled();
+        });
+        it('should call legacyAddComponent for non-v3 projects', async () => {
+            mockedUseV3Api.mockReturnValue(false);
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', undefined, 123);
+            expect(mockedLegacyAddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig);
+            expect(mockedV3AddComponent).not.toHaveBeenCalled();
+        });
+        it('should exit with error when project config is not found', async () => {
+            mockedGetProjectConfig.mockResolvedValue({
+                projectConfig: null,
+                projectDir: null,
+            });
+            const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error('process.exit called');
+            });
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockExit).toHaveBeenCalledWith(1);
+            mockExit.mockRestore();
+        });
+    });
 });

package/commands/project/add.d.ts

@@ -1,5 +1,5 @@
 import { YargsCommandModule, CommonArgs } from '../../types/Yargs.js';
-type ProjectAddArgs = CommonArgs & {
+export type ProjectAddArgs = CommonArgs & {
     type?: string;
     name?: string;
     features?: string[];

package/commands/project/add.js

@@ -23,7 +23,7 @@ async function handler(args) {
         }
         const isV3ProjectCreate = useV3Api(projectConfig.platformVersion);
         if (isV3ProjectCreate) {
-            await v3AddComponent(args, projectDir, projectConfig);
+            await v3AddComponent(args, projectDir, projectConfig, derivedAccountId);
         }
         else {
             await legacyAddComponent(args, projectDir, projectConfig);

package/commands/project/create.js

@@ -41,7 +41,7 @@ async function handler(args) {
         type: selectProjectTemplatePromptResponse.projectTemplate?.name ||
             (selectProjectTemplatePromptResponse.componentTemplates || [])
                 // @ts-expect-error
-                .map((item) => item.label)
+                .map((item) => item.type)
                 .join(','),
     }, derivedAccountId);
     const projectDest = path.resolve(getCwd(), projectNameAndDestPromptResponse.dest);

package/commands/project/upload.d.ts

@@ -1,5 +1,5 @@
-import { CommonArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectUploadArgs = CommonArgs & JSONOutputArgs & EnvironmentArgs & {
+import { CommonArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectUploadArgs = CommonArgs & JSONOutputArgs & {
     forceCreate: boolean;
     message: string;
     m: string;

package/commands/project/upload.js

@@ -25,7 +25,7 @@ async function handler(args) {
     validateProjectConfig(projectConfig, projectDir);
     let targetAccountId;
     if (useV3Api(projectConfig.platformVersion)) {
-        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile, args.useEnv);
+        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
     }
     targetAccountId = targetAccountId || derivedAccountId;
     const accountConfig = getAccountConfig(targetAccountId);

package/lib/mcp/setup.js

@@ -140,7 +140,7 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
             name: mcpServerName,
             ...buildCommandWithAgentString(mcpCommand, vscode),
         });
-        await execAsync(`code --add-mcp '${mcpConfig}'`);
+        await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
         SpinniesManager.succeed('vsCode', {
             text: commands.mcp.setup.spinners.configuredVsCode,
         });
@@ -182,15 +182,14 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
                 });
                 await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
             }
-            await execAsync(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
+            await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
             SpinniesManager.succeed('claudeCode', {
                 text: commands.mcp.setup.spinners.configuredClaudeCode,
             });
             return true;
         }
         catch (error) {
-            if (error instanceof Error &&
-                error.message.includes('claude: command not found')) {
+            if (error instanceof Error && error.message.includes('claude')) {
                 SpinniesManager.fail('claudeCode', {
                     text: commands.mcp.setup.spinners.claudeCodeNotFound,
                 });

package/lib/projectProfiles.d.ts

@@ -4,4 +4,4 @@ export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
 export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
 export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined, useEnv?: boolean): Promise<number | undefined>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -38,12 +38,7 @@ export function loadProfile(projectConfig, projectDir, profileName) {
             uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
             return;
         }
-        return {
-            ...profile,
-            accountId: process.env.HUBSPOT_ACCOUNT_ID
-                ? Number(process.env.HUBSPOT_ACCOUNT_ID)
-                : profile.accountId,
-        };
+        return profile;
     }
     catch (e) {
         uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
@@ -59,7 +54,7 @@ export async function exitIfUsingProfiles(projectConfig, projectDir) {
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile, useEnv = false) {
+export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
     if (argsProfile) {
         logProfileHeader(argsProfile);
         const profile = loadProfile(projectConfig, projectDir, argsProfile);
@@ -68,9 +63,6 @@ export async function loadAndValidateProfile(projectConfig, projectDir, argsProf
             process.exit(EXIT_CODES.ERROR);
         }
         logProfileFooter(profile, true);
-        if (useEnv) {
-            return Number(process.env.HUBSPOT_ACCOUNT_ID);
-        }
         return profile.accountId;
     }
     else {

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

@@ -7,6 +7,7 @@ import { projectAddPromptV3 } from '../../../prompts/projectAddPrompt.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { trackCommandUsage } from '../../../usageTracking.js';
 import { commands } from '../../../../lang/en.js';
 vi.mock('fs');
 vi.mock('../../../prompts/promptUtils');
@@ -16,6 +17,7 @@ vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/project-parsing-lib/src/lib/project');
+vi.mock('../../../usageTracking');
 const mockedFs = vi.mocked(fs);
 const mockedGetConfigForPlatformVersion = vi.mocked(getConfigForPlatformVersion);
 const mockedConfirmPrompt = vi.mocked(confirmPrompt);
@@ -24,6 +26,7 @@ const mockedProjectAddPromptV3 = vi.mocked(projectAddPromptV3);
 const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
 const mockedLogger = vi.mocked(logger);
 const mockedGetProjectMetadata = vi.mocked(getProjectMetadata);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('lib/projects/add/v3AddComponent', () => {
     const mockProjectConfig = {
         name: 'test-project',
@@ -32,6 +35,7 @@ describe('lib/projects/add/v3AddComponent', () => {
     };
     const mockArgs = { name: 'test-component', type: 'module' };
     const projectDir = '/path/to/project';
+    const mockAccountId = 123;
     const mockComponentTemplate = {
         label: 'Test Component',
         path: 'test-component',
@@ -62,6 +66,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             authType: 'oauth',
             distribution: 'private',
         });
+        mockedTrackCommandUsage.mockResolvedValue();
     });
     describe('v3AddComponent()', () => {
         it('successfully adds a component when app already exists', async () => {
@@ -79,10 +84,13 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedGetConfigForPlatformVersion).toHaveBeenCalledWith('v3');
             expect(mockedGetProjectMetadata).toHaveBeenCalledWith('/path/to/project/src');
             expect(mockedProjectAddPromptV3).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
                 sourceDir: ['v3/test-component'],
                 hideLogs: true,
@@ -106,8 +114,11 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedConfirmPrompt.mockResolvedValue(true);
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedCreateV3App).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
                 sourceDir: ['v3/test-component', 'v3/app-template'],
             }));
@@ -132,8 +143,11 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedConfirmPrompt.mockResolvedValue(true);
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedCreateV3App).not.toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: '',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
         });
         it('throws an error when app count exceeds maximum', async () => {
@@ -146,7 +160,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataMaxApps);
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('This project currently has the maximum number of apps: 1');
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('This project currently has the maximum number of apps: 1');
         });
         it('throws an error when components list is empty', async () => {
             const mockEmptyConfig = {
@@ -154,7 +168,7 @@ describe('lib/projects/add/v3AddComponent', () => {
                 parentComponents: [],
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockEmptyConfig);
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
         });
         it('throws an error when app meta file cannot be parsed', async () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
@@ -162,7 +176,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockImplementation(() => {
                 throw new Error('File read error');
             });
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('Unable to parse app file');
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('Unable to parse app file');
         });
         it('throws an error when cloning fails', async () => {
             const mockAppMeta = {
@@ -179,7 +193,57 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+        });
+        it('should track usage with multiple component types', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockSecondComponentTemplate = {
+                label: 'Test Card',
+                path: 'test-card',
+                type: 'card',
+                supportedAuthTypes: ['oauth'],
+                supportedDistributions: ['private'],
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate, mockSecondComponentTemplate],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module,card',
+            }, mockAccountId);
+        });
+        it('should track usage with empty type when no components are selected', async () => {
+            const mockProjectMetadataNoApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: {
+                        count: 1,
+                        maxCount: 1,
+                        hsMetaFiles: ['/path/to/app.meta.json'],
+                    },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: '',
+            }, mockAccountId);
         });
     });
 });

package/lib/projects/add/v3AddComponent.d.ts

@@ -5,4 +5,4 @@ export declare function v3AddComponent(args: {
     features?: string[];
     auth?: string;
     distribution?: string;
-}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;
+}, projectDir: string, projectConfig: ProjectConfig, accountId: number): Promise<void>;

package/lib/projects/add/v3AddComponent.js

@@ -12,7 +12,8 @@ import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { debugError } from '../../errorHandlers/index.js';
 import { uiLogger } from '../../ui/logger.js';
-export async function v3AddComponent(args, projectDir, projectConfig) {
+import { trackCommandUsage } from '../../usageTracking.js';
+export async function v3AddComponent(args, projectDir, projectConfig, accountId) {
     uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
     const config = await getConfigForPlatformVersion(projectConfig.platformVersion);
     const { components, parentComponents } = config;
@@ -47,6 +48,10 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
     }
     const componentTemplateChoices = calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, currentProjectMetadata);
     const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
+    const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.type);
+    await trackCommandUsage('project-add', {
+        type: componentTypes?.join(','),
+    }, accountId);
     try {
         const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
             return path.join(projectConfig.platformVersion, componentTemplate.path);

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

@@ -0,0 +1,38 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    userSuppliedName: z.ZodOptional<z.ZodString>;
+    dest: z.ZodOptional<z.ZodString>;
+    moduleLabel: z.ZodOptional<z.ZodString>;
+    reactType: z.ZodOptional<z.ZodBoolean>;
+    contentTypes: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    global: z.ZodOptional<z.ZodBoolean>;
+    availableForNewContent: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    global?: boolean | undefined;
+    moduleLabel?: string | undefined;
+    reactType?: 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;
+    contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
+    userSuppliedName?: string | undefined;
+}>;
+export type HsCreateModuleInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsCreateModuleTool extends Tool<HsCreateModuleInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }: HsCreateModuleInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,118 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { addFlag } from '../../utils/command.js';
+import { CONTENT_TYPES } from '../../../types/Cms.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    userSuppliedName: z
+        .string()
+        .describe('REQUIRED - If not specified by the user, DO NOT choose. Ask the user to specify the name of the module they want to create.')
+        .optional(),
+    dest: z
+        .string()
+        .describe('The destination path where the module should be created on the current computer.')
+        .optional(),
+    moduleLabel: z
+        .string()
+        .describe('Label for module creation. Required for non-interactive module creation. If not provided, ask the user to provide it.')
+        .optional(),
+    reactType: z
+        .boolean()
+        .describe('Whether to create a React module. If the user has not specified that they want a React module, DO NOT choose for them, ask them what type of module they want to create HubL or React.')
+        .optional(),
+    contentTypes: z
+        .string()
+        .refine(val => {
+        if (!val)
+            return true; // optional
+        const types = val.split(',').map(t => t.trim().toUpperCase());
+        return types.every(type => CONTENT_TYPES.includes(type));
+    }, {
+        message: `Content types must be a comma-separated list of valid values: ${CONTENT_TYPES.join(', ')}`,
+    })
+        .describe(`Content types where the module can be used. Comma-separated list. Valid values: ${CONTENT_TYPES.join(', ')}. Defaults to "ANY".`)
+        .optional(),
+    global: z
+        .boolean()
+        .describe('Whether the module is global. Defaults to false.')
+        .optional(),
+    availableForNewContent: z
+        .boolean()
+        .describe('Whether the module is available for new content. Defaults to true.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-hubspot-cms-module';
+export class HsCreateModuleTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        const content = [];
+        // Always require a name
+        if (!userSuppliedName) {
+            content.push(formatTextContent(`Ask the user to specify the name of the module they want to create.`));
+        }
+        // Require module label
+        if (!moduleLabel) {
+            content.push(formatTextContent(`Ask the user to provide a label for the module.`));
+        }
+        // Ask about React vs HubL if not specified
+        if (reactType === undefined) {
+            content.push(formatTextContent(`Ask the user what type of module they want to create: HubL or React?`));
+        }
+        // If we have missing required information, return the prompts
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Build the command
+        let command = 'hs create module';
+        if (userSuppliedName) {
+            command += ` "${userSuppliedName}"`;
+        }
+        if (dest) {
+            command += ` "${dest}"`;
+        }
+        // Add module-specific flags
+        if (moduleLabel) {
+            command = addFlag(command, 'module-label', moduleLabel);
+        }
+        if (reactType !== undefined) {
+            command = addFlag(command, 'react-type', reactType);
+        }
+        if (contentTypes) {
+            command = addFlag(command, 'content-types', contentTypes);
+        }
+        else {
+            command = addFlag(command, 'content-types', 'ANY');
+        }
+        if (global !== undefined) {
+            command = addFlag(command, 'global', global);
+        }
+        if (availableForNewContent !== undefined) {
+            command = addFlag(command, 'available-for-new-content', availableForNewContent);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

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

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

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

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsCreateModuleTool } from '../HsCreateModuleTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../utils/toolUsageTracking', () => ({
+    trackToolUsage: vi.fn(),
+}));
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('HsCreateModuleTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new HsCreateModuleTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-hubspot-cms-module', {
+                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: expect.any(Object),
+            }, expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should prompt for missing required parameters', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(3);
+            expect(result.content[0].text).toContain('Ask the user to specify the name of the module');
+            expect(result.content[1].text).toContain('Ask the user to provide a label for the module');
+            expect(result.content[2].text).toContain('Ask the user what type of module they want to create: HubL or React?');
+        });
+        it('should prompt for missing name only when other params provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to specify the name of the module');
+        });
+        it('should prompt for missing moduleLabel when name provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                reactType: true,
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to provide a label for the module');
+        });
+        it('should prompt for missing reactType when other required params provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user what type of module they want to create: HubL or React?');
+        });
+        it('should execute command with all required parameters (HubL module)', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create module "Test Module"', 'module-label', 'Test Label');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('module-label'), 'react-type', false);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('react-type'), 'content-types', 'ANY');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', expect.stringContaining('hs create module'));
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Module created successfully');
+        });
+        it('should execute command with React module', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "React Module" --module-label React Label')
+                .mockReturnValueOnce('hs create module "React Module" --module-label React Label --react-type true')
+                .mockReturnValueOnce('hs create module "React Module" --module-label React Label --react-type true --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'React module created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'React Module',
+                moduleLabel: 'React Label',
+                reactType: true,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('module-label'), 'react-type', true);
+            expect(result.content[0].text).toContain('React module created successfully');
+        });
+        it('should execute command with destination path', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" "custom/path" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" "custom/path" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" "custom/path" --module-label Test Label --react-type false --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created at custom path',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                dest: 'custom/path',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', expect.stringContaining('"custom/path"'));
+            expect(result.content[0].text).toContain('Module created at custom path');
+        });
+        it('should execute command with custom content types', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types LANDING_PAGE,BLOG_POST');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module with custom content types created',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+                contentTypes: 'LANDING_PAGE,BLOG_POST',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('react-type'), 'content-types', 'LANDING_PAGE,BLOG_POST');
+            expect(result.content[0].text).toContain('Module with custom content types created');
+        });
+        it('should execute command with global flag', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label')
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label --react-type false')
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label --react-type false --content-types ANY')
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label --react-type false --content-types ANY --global true');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Global module created',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Global Module',
+                moduleLabel: 'Global Label',
+                reactType: false,
+                global: true,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('content-types'), 'global', true);
+            expect(result.content[0].text).toContain('Global module created');
+        });
+        it('should execute command with availableForNewContent flag', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY --available-for-new-content false');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created with availableForNewContent false',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+                availableForNewContent: false,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('content-types'), 'available-for-new-content', false);
+            expect(result.content[0].text).toContain('Module created with availableForNewContent false');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Command failed'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Command failed');
+        });
+        it('should handle stderr output', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created successfully',
+                stderr: 'Warning: Deprecated feature used',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Module created successfully');
+            expect(result.content[1].text).toContain('Warning: Deprecated feature used');
+        });
+    });
+});

package/mcp-server/tools/index.js

@@ -8,6 +8,7 @@ import { GetConfigValuesTool } from './project/GetConfigValuesTool.js';
 import { DocsSearchTool } from './project/DocsSearchTool.js';
 import { DocFetchTool } from './project/DocFetchTool.js';
 import { HsListTool } from './cms/HsListTool.js';
+import { HsCreateModuleTool } from './cms/HsCreateModuleTool.js';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
@@ -22,5 +23,8 @@ export function registerProjectTools(mcpServer) {
     ];
 }
 export function registerCmsTools(mcpServer) {
-    return [new HsListTool(mcpServer).register()];
+    return [
+        new HsListTool(mcpServer).register(),
+        new HsCreateModuleTool(mcpServer).register(),
+    ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.7.28-experimental.0",
+    "version": "7.7.30-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",

package/types/Yargs.d.ts

@@ -15,7 +15,7 @@ export type AccountArgs = {
     account?: string;
 };
 export type EnvironmentArgs = {
-    'use-env'?: boolean;
+    'use-env'?: string;
 };
 export type OverwriteArgs = Options & {
     o?: boolean;