@hubspot/cli 7.7.0-experimental.3 → 7.7.0

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

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

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

@@ -0,0 +1,183 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsFunctionLogsTool } from '../HsFunctionLogsTool.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('HsFunctionLogsTool', () => {
+    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 HsFunctionLogsTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-cms-serverless-function-logs', expect.objectContaining({
+                title: 'Get HubSpot CMS serverless function logs for an endpoint',
+                description: 'Retrieve logs for HubSpot CMS serverless functions. Use this tool to help debug issues with serverless functions by reading the production logs. Supports various options like latest, compact, and limiting results. Use after listing functions with list-cms-serverless-functions to get the endpoint path.',
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should execute basic hs logs command with endpoint', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '2023-01-01 10:00:00 INFO Function executed successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'my-function',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs logs my-function');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Function executed successfully');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should strip leading slash from endpoint', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '2023-01-01 10:00:00 INFO Function executed successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: '/api/my-endpoint',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs logs api/my-endpoint');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Function executed successfully');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs logs command with latest flag', async () => {
+            mockAddFlag.mockReturnValue('hs logs my-endpoint --latest');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '2023-01-01 10:00:00 INFO Latest log entry',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'my-endpoint',
+                latest: true,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs logs my-endpoint', 'latest', true);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs logs my-endpoint --latest');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Latest log entry');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs logs command with compact flag', async () => {
+            mockAddFlag.mockReturnValue('hs logs my-endpoint --compact');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'compact log output',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'my-endpoint',
+                compact: true,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs logs my-endpoint', 'compact', true);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs logs my-endpoint --compact');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('compact log output');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs logs command with limit parameter', async () => {
+            mockAddFlag.mockReturnValue('hs logs my-endpoint --limit 10');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'limited log entries',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'my-endpoint',
+                limit: 10,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs logs my-endpoint', 'limit', 10);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs logs my-endpoint --limit 10');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('limited log entries');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs logs command with account parameter', async () => {
+            mockAddFlag.mockReturnValue('hs logs my-endpoint --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'account-specific logs',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'my-endpoint',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs logs my-endpoint', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs logs my-endpoint --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('account-specific logs');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs logs command with multiple parameters', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs logs my-endpoint --latest')
+                .mockReturnValueOnce('hs logs my-endpoint --latest --compact')
+                .mockReturnValueOnce('hs logs my-endpoint --latest --compact --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'latest compact logs',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'my-endpoint',
+                latest: true,
+                compact: true,
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledTimes(3);
+            expect(mockAddFlag).toHaveBeenNthCalledWith(1, 'hs logs my-endpoint', 'latest', true);
+            expect(mockAddFlag).toHaveBeenNthCalledWith(2, 'hs logs my-endpoint --latest', 'compact', true);
+            expect(mockAddFlag).toHaveBeenNthCalledWith(3, 'hs logs my-endpoint --latest --compact', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs logs my-endpoint --latest --compact --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('latest compact logs');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Function not found'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'non-existent-function',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Error executing hs logs command: Function not found');
+        });
+        it('should handle stderr output', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'function logs',
+                stderr: 'Warning: Function may be slow to respond',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                endpoint: 'slow-function',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('function logs');
+            expect(result.content[1].text).toContain('Warning: Function may be slow to respond');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsListTool } from '../HsListTool.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('HsListTool', () => {
+    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 HsListTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-cms-remote-contents', {
+                title: 'List HubSpot CMS Directory Contents',
+                description: 'List remote contents of a HubSpot CMS directory.',
+                inputSchema: expect.any(Object),
+            }, expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should execute hs list command with no parameters', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'file1.html\nfile2.js\nfolder/',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('file1.html\nfile2.js\nfolder/');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with path parameter', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'nested-file.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                path: '/my-modules',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list /my-modules');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('nested-file.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with account parameter', async () => {
+            mockAddFlag.mockReturnValue('hs list --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'account-specific-files.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs list', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('account-specific-files.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with both path and account parameters', async () => {
+            mockAddFlag.mockReturnValue('hs list /my-path --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'path-and-account-files.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                path: '/my-path',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs list /my-path', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list /my-path --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('path-and-account-files.html');
+            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 list command: Command failed');
+        });
+        it('should handle stderr output', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'file1.html',
+                stderr: 'Warning: Some warning message',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('file1.html');
+            expect(result.content[1].text).toContain('Warning: Some warning message');
+        });
+    });
+});

package/mcp-server/tools/index.d.ts

@@ -0,0 +1,3 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerProjectTools(mcpServer: McpServer): RegisteredTool[];
+export declare function registerCmsTools(mcpServer: McpServer): RegisteredTool[];