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

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-hubspot-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__/HsCreateTemplateTool.test.d.ts

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

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

@@ -0,0 +1,206 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsCreateTemplateTool } from '../HsCreateTemplateTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { TEMPLATE_TYPES } 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('HsCreateTemplateTool', () => {
+    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 HsCreateTemplateTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-hubspot-cms-template', {
+                title: 'Create HubSpot CMS Template',
+                description: `Creates a new HubSpot CMS template using the hs create template command. Templates can be created non-interactively by specifying templateType. Supports all template types including: ${TEMPLATE_TYPES.join(', ')}.`,
+                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(2);
+            expect(result.content[0].text).toContain('Ask the user to specify the name of the template');
+            expect(result.content[1].text).toContain('Ask the user what template type they want to create');
+            expect(result.content[1].text).toContain('page-template, email-template, partial, global-partial');
+        });
+        it('should prompt for missing name only when template type provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                templateType: 'page-template',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to specify the name of the template');
+        });
+        it('should prompt for missing templateType when name provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Template',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user what template type they want to create');
+        });
+        it('should execute command with all required parameters (page template)', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Page Template" --template-type page-template');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Page template created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Page Template',
+                templateType: 'page-template',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create template "Page Template"', 'template-type', 'page-template');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs create template "Page Template" --template-type page-template');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Page template created successfully');
+        });
+        it('should execute command with email template', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Email Template" --template-type email-template');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Email template created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Email Template',
+                templateType: 'email-template',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create template "Email Template"', 'template-type', 'email-template');
+            expect(result.content[0].text).toContain('Email template created successfully');
+        });
+        it('should execute command with partial template', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Header Partial" --template-type partial');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Partial template created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Header Partial',
+                templateType: 'partial',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create template "Header Partial"', 'template-type', 'partial');
+            expect(result.content[0].text).toContain('Partial template created successfully');
+        });
+        it('should execute command with blog-listing-template', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Blog Listing" --template-type blog-listing-template');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Blog listing template created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Blog Listing',
+                templateType: 'blog-listing-template',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create template "Blog Listing"', 'template-type', 'blog-listing-template');
+            expect(result.content[0].text).toContain('Blog listing template created successfully');
+        });
+        it('should execute command with destination path', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Test Template" "templates/custom" --template-type page-template');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Template created at custom path',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Template',
+                dest: 'templates/custom',
+                templateType: 'page-template',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', expect.stringContaining('"templates/custom"'));
+            expect(result.content[0].text).toContain('Template created at custom path');
+        });
+        it('should execute command with section template', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Hero Section" --template-type section');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Section template created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Hero Section',
+                templateType: 'section',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create template "Hero Section"', 'template-type', 'section');
+            expect(result.content[0].text).toContain('Section template created successfully');
+        });
+        it('should execute command with search template', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Search Results" --template-type search-template');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Search template created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Search Results',
+                templateType: 'search-template',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create template "Search Results"', 'template-type', 'search-template');
+            expect(result.content[0].text).toContain('Search template created successfully');
+        });
+        it('should execute command with blog-post-template', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Custom Blog Post" --template-type blog-post-template');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Blog post template created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Custom Blog Post',
+                templateType: 'blog-post-template',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create template "Custom Blog Post"', 'template-type', 'blog-post-template');
+            expect(result.content[0].text).toContain('Blog post template created successfully');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Template creation failed'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Template',
+                templateType: 'page-template',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Template creation failed');
+        });
+        it('should handle stderr output', async () => {
+            mockAddFlag.mockReturnValueOnce('hs create template "Test Template" --template-type page-template');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Template created successfully',
+                stderr: 'Warning: Using deprecated template syntax',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Template',
+                templateType: 'page-template',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Template created successfully');
+            expect(result.content[1].text).toContain('Warning: Using deprecated template syntax');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsListFunctionsTool } from '../HsListFunctionsTool.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('HsListFunctionsTool', () => {
+    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 HsListFunctionsTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-hubspot-cms-serverless-functions', {
+                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: expect.any(Object),
+            }, expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should execute hs function list command with no parameters', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Route | Method | Secrets | Created | Updated\n/api/test | GET | | 2023-01-01 | 2023-01-01',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs function list');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Route | Method | Secrets');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs function list command with json flag', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '[{"route": "/api/test", "method": "GET"}]',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                json: true,
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs function list --json');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('[{"route": "/api/test"');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs function list command with account parameter', async () => {
+            mockAddFlag.mockReturnValue('hs function list --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'account-specific-functions',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs function list', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs function list --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('account-specific-functions');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs function list command with both json and account parameters', async () => {
+            mockAddFlag.mockReturnValue('hs function list --json --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '[{"route": "/api/test"}]',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                json: true,
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs function list --json', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs function list --json --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('[{"route": "/api/test"}]');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Command failed'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Error executing hs function list command: Command failed');
+        });
+        it('should handle stderr output', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Route | Method | Secrets\n/api/test | GET |',
+                stderr: 'Warning: Some warning message',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('/api/test | GET');
+            expect(result.content[1].text).toContain('Warning: Some warning message');
+        });
+    });
+});

package/mcp-server/tools/index.js

@@ -9,6 +9,9 @@ import { DocsSearchTool } from './project/DocsSearchTool.js';
 import { DocFetchTool } from './project/DocFetchTool.js';
 import { HsListTool } from './cms/HsListTool.js';
 import { HsCreateModuleTool } from './cms/HsCreateModuleTool.js';
+import { HsCreateTemplateTool } from './cms/HsCreateTemplateTool.js';
+import { HsCreateFunctionTool } from './cms/HsCreateFunctionTool.js';
+import { HsListFunctionsTool } from './cms/HsListFunctionsTool.js';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
@@ -26,5 +29,8 @@ export function registerCmsTools(mcpServer) {
     return [
         new HsListTool(mcpServer).register(),
         new HsCreateModuleTool(mcpServer).register(),
+        new HsCreateTemplateTool(mcpServer).register(),
+        new HsCreateFunctionTool(mcpServer).register(),
+        new HsListFunctionsTool(mcpServer).register(),
     ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.7.30-experimental.0",
+    "version": "7.7.32-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
@@ -84,6 +84,7 @@
         "mcp-local": "yarn tsx ./scripts/mcp-local.ts",
         "prettier:write": "prettier --write './**/*.{ts,js,json}'",
         "release": "yarn tsx ./scripts/release.ts release",
+        "view-ui": "yarn build && yarn tsx ./scripts/view-ui.ts",
         "test": "vitest run",
         "test-dev": "vitest",
         "test-cli": "yarn build && yarn --cwd 'acceptance-tests' test-ci",

package/ui/components/BoxWithTitle.d.ts

@@ -0,0 +1,8 @@
+export interface BoxWithTitleProps {
+    title: string;
+    message: string;
+    titleBackgroundColor?: string;
+    borderColor?: string;
+}
+export declare function getBoxWithTitle(props: BoxWithTitleProps): React.ReactNode;
+export declare function BoxWithTitle({ title, message, titleBackgroundColor, borderColor, }: BoxWithTitleProps): React.ReactNode;

package/ui/components/BoxWithTitle.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { CONTAINER_STYLES } from '../styles.js';
+export function getBoxWithTitle(props) {
+    return _jsx(BoxWithTitle, { ...props });
+}
+export function BoxWithTitle({ title, message, titleBackgroundColor, borderColor, }) {
+    return (_jsxs(Box, { ...CONTAINER_STYLES, borderStyle: "round", borderColor: borderColor, children: [_jsx(Box, { position: "absolute", marginTop: -2, paddingX: 0, alignSelf: "flex-start", justifyContent: "center", alignItems: "center", children: _jsx(Text, { backgroundColor: titleBackgroundColor, bold: true, children: ` ${title} ` }) }), _jsx(Box, { justifyContent: "center", alignItems: "center", children: _jsx(Text, { children: message }) })] }));
+}

package/ui/components/HorizontalSelectPrompt.d.ts

@@ -0,0 +1,8 @@
+export interface HorizontalSelectPromptProps {
+    defaultOption?: string;
+    options: string[];
+    onSelect: (value: string) => void;
+    prompt?: string;
+}
+export declare function getHorizontalSelectPrompt(props: HorizontalSelectPromptProps): React.ReactNode;
+export declare function HorizontalSelectPrompt({ defaultOption, options, onSelect, prompt, }: HorizontalSelectPromptProps): React.ReactNode;