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

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/lang/en.d.ts

@@ -884,10 +884,12 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
                 readonly configuringCursor: "Configuring Cursor...";
                 readonly failedToConfigureCursor: "Failed to configure Cursor";
                 readonly configuredCursor: "Configured Cursor";
+                readonly cursorNotFound: "Cursor not found - skipping configuration";
                 readonly alreadyInstalled: "HubSpot CLI mcp server already installed, reinstalling";
                 readonly configuringWindsurf: "Configuring Windsurf...";
                 readonly failedToConfigureWindsurf: "Failed to configure Windsurf";
                 readonly configuredWindsurf: "Configured Windsurf";
+                readonly windsurfNotFound: "Windsurf not found - skipping configuration";
                 readonly configuringVsCode: "Configuring VSCode...";
                 readonly failedToConfigureVsCode: "Failed to configure VSCode";
                 readonly configuredVsCode: "Configured VSCode";

package/lang/en.js

@@ -889,11 +889,13 @@ export const commands = {
                 configuringCursor: 'Configuring Cursor...',
                 failedToConfigureCursor: 'Failed to configure Cursor',
                 configuredCursor: 'Configured Cursor',
+                cursorNotFound: 'Cursor not found - skipping configuration',
                 alreadyInstalled: 'HubSpot CLI mcp server already installed, reinstalling',
                 // Windsurf
                 configuringWindsurf: 'Configuring Windsurf...',
                 failedToConfigureWindsurf: 'Failed to configure Windsurf',
                 configuredWindsurf: 'Configured Windsurf',
+                windsurfNotFound: 'Windsurf not found - skipping configuration',
                 // VS Code
                 configuringVsCode: 'Configuring VSCode...',
                 failedToConfigureVsCode: 'Failed to configure VSCode',

package/lib/mcp/setup.d.ts

@@ -16,8 +16,8 @@ interface McpCommand {
     args: string[];
 }
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
-export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
-export declare function setupCursor(mcpCommand?: McpCommand): boolean;
-export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
+export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupCursor(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupWindsurf(mcpCommand?: McpCommand): Promise<boolean>;
 export {};

package/lib/mcp/setup.js

@@ -4,10 +4,6 @@ import { promptUser } from '../prompts/promptUtils.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError } from '../errorHandlers/index.js';
 import { execAsync } from '../../mcp-server/utils/command.js';
-import path from 'path';
-import os from 'os';
-import fs from 'fs-extra';
-import { existsSync } from 'fs';
 const mcpServerName = 'hubspot-cli-mcp';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
@@ -72,96 +68,6 @@ async function runSetupFunction(func) {
         throw new Error();
     }
 }
-function setupMcpConfigFile(config) {
-    try {
-        SpinniesManager.add('spinner', {
-            text: config.configuringMessage,
-        });
-        if (!existsSync(config.configPath)) {
-            fs.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
-        }
-        let mcpConfig = {};
-        let configContent;
-        try {
-            configContent = fs.readFileSync(config.configPath, 'utf8');
-        }
-        catch (error) {
-            SpinniesManager.fail('spinner', {
-                text: config.failedMessage,
-            });
-            logError(error);
-            return false;
-        }
-        try {
-            // In the event the file exists, but is empty, initialize it to and empty object
-            if (configContent.trim() === '') {
-                mcpConfig = {};
-            }
-            else {
-                mcpConfig = JSON.parse(configContent);
-            }
-        }
-        catch (error) {
-            SpinniesManager.fail('spinner', {
-                text: config.failedMessage,
-            });
-            uiLogger.error(commands.mcp.setup.errors.errorParsingJsonFIle(config.configPath, error instanceof Error ? error.message : `${error}`));
-            return false;
-        }
-        // Initialize mcpServers if it doesn't exist
-        if (!mcpConfig.mcpServers) {
-            mcpConfig.mcpServers = {};
-        }
-        // Add or update HubSpot CLI MCP server
-        mcpConfig.mcpServers[mcpServerName] = {
-            ...config.mcpCommand,
-        };
-        // Write the updated config
-        fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
-        SpinniesManager.succeed('spinner', {
-            text: config.configuredMessage,
-        });
-        return true;
-    }
-    catch (error) {
-        SpinniesManager.fail('spinner', {
-            text: config.failedMessage,
-        });
-        logError(error);
-        return false;
-    }
-}
-export async function setupVsCode(mcpCommand = defaultMcpCommand) {
-    try {
-        SpinniesManager.add('vsCode', {
-            text: commands.mcp.setup.spinners.configuringVsCode,
-        });
-        const mcpConfig = JSON.stringify({
-            name: mcpServerName,
-            ...buildCommandWithAgentString(mcpCommand, vscode),
-        });
-        await execAsync(`code --add-mcp '${mcpConfig}'`);
-        SpinniesManager.succeed('vsCode', {
-            text: commands.mcp.setup.spinners.configuredVsCode,
-        });
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message.includes('code: command not found')) {
-            SpinniesManager.fail('vsCode', {
-                text: commands.mcp.setup.spinners.vsCodeNotFound,
-            });
-        }
-        else {
-            SpinniesManager.fail('vsCode', {
-                text: commands.mcp.setup.spinners.failedToConfigureVsCode,
-            });
-            logError(error);
-        }
-        return false;
-    }
-}
 export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     try {
         SpinniesManager.add('claudeCode', {
@@ -182,15 +88,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,
                 });
@@ -212,25 +117,44 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
         return false;
     }
 }
-export function setupCursor(mcpCommand = defaultMcpCommand) {
-    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
-    return setupMcpConfigFile({
-        configPath: cursorConfigPath,
-        configuringMessage: commands.mcp.setup.spinners.configuringCursor,
-        configuredMessage: commands.mcp.setup.spinners.configuredCursor,
-        failedMessage: commands.mcp.setup.spinners.failedToConfigureCursor,
-        mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
-    });
+async function setupVsCodeBasedIntegration(commandName, configuringText, configuredText, notFoundText, failedText, mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add(commandName, {
+            text: configuringText,
+        });
+        const mcpConfig = JSON.stringify({
+            name: mcpServerName,
+            ...buildCommandWithAgentString(mcpCommand, vscode),
+        });
+        await execAsync(`${commandName} --add-mcp ${JSON.stringify(mcpConfig)}`);
+        SpinniesManager.succeed(commandName, {
+            text: configuredText,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes(commandName)) {
+            SpinniesManager.fail(commandName, {
+                text: notFoundText,
+            });
+        }
+        else {
+            SpinniesManager.fail(commandName, {
+                text: failedText,
+            });
+            logError(error);
+        }
+        return false;
+    }
+}
+export async function setupVsCode(mcpCommand = defaultMcpCommand) {
+    return setupVsCodeBasedIntegration('code', commands.mcp.setup.spinners.configuringVsCode, commands.mcp.setup.spinners.configuredVsCode, commands.mcp.setup.spinners.vsCodeNotFound, commands.mcp.setup.spinners.failedToConfigureVsCode, mcpCommand);
+}
+export async function setupCursor(mcpCommand = defaultMcpCommand) {
+    return setupVsCodeBasedIntegration('cursor', commands.mcp.setup.spinners.configuringCursor, commands.mcp.setup.spinners.configuredCursor, commands.mcp.setup.spinners.cursorNotFound, commands.mcp.setup.spinners.failedToConfigureCursor, mcpCommand);
 }
-export function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
-    return setupMcpConfigFile({
-        configPath: windsurfConfigPath,
-        configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,
-        configuredMessage: commands.mcp.setup.spinners.configuredWindsurf,
-        failedMessage: commands.mcp.setup.spinners.failedToConfigureWindsurf,
-        mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
-    });
+export async function setupWindsurf(mcpCommand = defaultMcpCommand) {
+    return setupVsCodeBasedIntegration('windsurf', commands.mcp.setup.spinners.configuringWindsurf, commands.mcp.setup.spinners.configuredWindsurf, commands.mcp.setup.spinners.windsurfNotFound, commands.mcp.setup.spinners.failedToConfigureWindsurf, mcpCommand);
 }
 function buildCommandWithAgentString(mcpCommand, agent) {
     const mcpCommandCopy = structuredClone(mcpCommand);

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/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.29-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;