@hubspot/cli 7.7.0-experimental.3 → 7.7.0

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

@@ -0,0 +1,58 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { addFlag } from '../../utils/command.js';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+    json: z
+        .boolean()
+        .describe('Return raw JSON output instead of formatted table. Useful for programmatic access.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'list-cms-serverless-functions';
+export class HsListFunctionsTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ account, json, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        let command = 'hs function list';
+        if (json) {
+            command += ' --json';
+        }
+        if (account) {
+            command = addFlag(command, 'account', account);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing hs function list command: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'List HubSpot CMS Serverless Functions',
+            description: 'Get a list of all serverless functions deployed in a HubSpot portal/account. Shows function routes, HTTP methods, secrets, and timestamps.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,23 @@
+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;
+    path: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    path?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    path?: string | undefined;
+}>;
+export type HsListInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsListTool extends Tool<HsListInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ path, account, absoluteCurrentWorkingDirectory, }: HsListInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { addFlag } from '../../utils/command.js';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    path: z
+        .string()
+        .describe('The remote directory path in the HubSpot CMS to list contents. If not specified, lists the root directory.')
+        .optional(),
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'list-cms-remote-contents';
+export class HsListTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ path, account, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        let command = 'hs list';
+        if (path) {
+            command += ` ${path}`;
+        }
+        if (account) {
+            command = addFlag(command, 'account', account);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing hs list command: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'List HubSpot CMS Directory Contents',
+            description: 'List remote contents of a HubSpot CMS directory.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

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

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

@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsCreateFunctionTool } from '../HsCreateFunctionTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { HTTP_METHODS } from '../../../../types/Cms.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('HsCreateFunctionTool', () => {
+    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 HsCreateFunctionTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-cms-function', {
+                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: expect.any(Object),
+            }, expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should prompt for all 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 provide the folder name for the function');
+            expect(result.content[1].text).toContain('Ask the user to provide the filename for the function');
+            expect(result.content[2].text).toContain('Ask the user to provide the API endpoint path for the function');
+        });
+        it('should not prompt when all required params provided', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function --functions-folder api')
+                .mockReturnValueOnce('hs create function --functions-folder api --filename test-function')
+                .mockReturnValueOnce('hs create function --functions-folder api --filename test-function --endpoint-method GET')
+                .mockReturnValueOnce('hs create function --functions-folder api --filename test-function --endpoint-method GET --endpoint-path /api/test');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Function created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'test-function',
+                endpointPath: '/api/test',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Function created successfully');
+        });
+        it('should prompt for missing functionsFolder when other required params provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                filename: 'test-function',
+                endpointPath: '/api/test',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to provide the folder name for the function');
+        });
+        it('should prompt for missing filename when other required params provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                endpointPath: '/api/test',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to provide the filename for the function');
+        });
+        it('should prompt for missing endpointPath when other required params provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'test-function',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to provide the API endpoint path for the function');
+        });
+        it('should execute command with all required parameters (default GET method)', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function --functions-folder api')
+                .mockReturnValueOnce('hs create function --functions-folder api --filename test-function')
+                .mockReturnValueOnce('hs create function --functions-folder api --filename test-function --endpoint-method GET')
+                .mockReturnValueOnce('hs create function --functions-folder api --filename test-function --endpoint-method GET --endpoint-path /api/test');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Function created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'test-function',
+                endpointPath: '/api/test',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create function', 'functions-folder', 'api');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('functions-folder'), 'filename', 'test-function');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('filename'), 'endpoint-method', 'GET');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('endpoint-method'), 'endpoint-path', '/api/test');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', expect.stringContaining('hs create function'));
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Function created successfully');
+        });
+        it('should execute command with POST method', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function --functions-folder api')
+                .mockReturnValueOnce('hs create function --functions-folder api --filename post-function')
+                .mockReturnValueOnce('hs create function "POST Function" --functions-folder api --filename post-function --endpoint-method POST')
+                .mockReturnValueOnce('hs create function "POST Function" --functions-folder api --filename post-function --endpoint-method POST --endpoint-path /api/create');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'POST function created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'post-function',
+                endpointMethod: 'POST',
+                endpointPath: '/api/create',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('filename'), 'endpoint-method', 'POST');
+            expect(result.content[0].text).toContain('POST function created successfully');
+        });
+        it('should execute command with PUT method', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function --functions-folder api')
+                .mockReturnValueOnce('hs create function "PUT Function" --functions-folder api --filename put-function')
+                .mockReturnValueOnce('hs create function "PUT Function" --functions-folder api --filename put-function --endpoint-method PUT')
+                .mockReturnValueOnce('hs create function "PUT Function" --functions-folder api --filename put-function --endpoint-method PUT --endpoint-path /api/update');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'PUT function created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'put-function',
+                endpointMethod: 'PUT',
+                endpointPath: '/api/update',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('filename'), 'endpoint-method', 'PUT');
+            expect(result.content[0].text).toContain('PUT function created successfully');
+        });
+        it('should execute command with DELETE method', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function --functions-folder api')
+                .mockReturnValueOnce('hs create function "DELETE Function" --functions-folder api --filename delete-function')
+                .mockReturnValueOnce('hs create function "DELETE Function" --functions-folder api --filename delete-function --endpoint-method DELETE')
+                .mockReturnValueOnce('hs create function "DELETE Function" --functions-folder api --filename delete-function --endpoint-method DELETE --endpoint-path /api/delete');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'DELETE function created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'delete-function',
+                endpointMethod: 'DELETE',
+                endpointPath: '/api/delete',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('filename'), 'endpoint-method', 'DELETE');
+            expect(result.content[0].text).toContain('DELETE function created successfully');
+        });
+        it('should execute command with PATCH method', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function --functions-folder api')
+                .mockReturnValueOnce('hs create function "PATCH Function" --functions-folder api --filename patch-function')
+                .mockReturnValueOnce('hs create function "PATCH Function" --functions-folder api --filename patch-function --endpoint-method PATCH')
+                .mockReturnValueOnce('hs create function "PATCH Function" --functions-folder api --filename patch-function --endpoint-method PATCH --endpoint-path /api/patch');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'PATCH function created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'patch-function',
+                endpointMethod: 'PATCH',
+                endpointPath: '/api/patch',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('filename'), 'endpoint-method', 'PATCH');
+            expect(result.content[0].text).toContain('PATCH function created successfully');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Function creation failed'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'test-function',
+                endpointPath: '/api/test',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Function creation failed');
+        });
+        it('should handle stderr output', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function "Test Function" --functions-folder api')
+                .mockReturnValueOnce('hs create function "Test Function" --functions-folder api --filename test-function')
+                .mockReturnValueOnce('hs create function "Test Function" --functions-folder api --filename test-function --endpoint-method GET')
+                .mockReturnValueOnce('hs create function "Test Function" --functions-folder api --filename test-function --endpoint-method GET --endpoint-path /api/test');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Function created successfully',
+                stderr: 'Warning: Using deprecated function syntax',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                functionsFolder: 'api',
+                filename: 'test-function',
+                endpointPath: '/api/test',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Function created successfully');
+            expect(result.content[1].text).toContain('Warning: Using deprecated function syntax');
+        });
+        it('should execute command with destination path', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create function "functions/custom" --functions-folder api')
+                .mockReturnValueOnce('hs create function "functions/custom" --functions-folder api --filename test-function')
+                .mockReturnValueOnce('hs create function "functions/custom" --functions-folder api --filename test-function --endpoint-method GET')
+                .mockReturnValueOnce('hs create function "functions/custom" --functions-folder api --filename test-function --endpoint-method GET --endpoint-path /api/test');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Function created at custom path',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                dest: 'functions/custom',
+                functionsFolder: 'api',
+                filename: 'test-function',
+                endpointPath: '/api/test',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', expect.stringContaining('"functions/custom"'));
+            expect(result.content[0].text).toContain('Function created at custom path');
+        });
+    });
+});

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-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/cms/__tests__/HsCreateTemplateTool.test.d.ts

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