@hubspot/cli 8.0.10-experimental.4 → 8.0.10-experimental.6

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

@@ -1,208 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HsCreateTemplateTool } from '../HsCreateTemplateTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
-import { addFlag } from '../../../utils/command.js';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockRunCommandInDir = runCommandInDir;
-const mockAddFlag = addFlag;
-describe('HsCreateTemplateTool', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error Not mocking the whole server
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        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', expect.objectContaining({
-                title: 'Create HubSpot CMS Template',
-                description: expect.stringContaining('Creates a new HubSpot CMS template'),
-                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

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

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

@@ -1,186 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HsFunctionLogsTool } from '../HsFunctionLogsTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
-import { addFlag } from '../../../utils/command.js';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockRunCommandInDir = runCommandInDir;
-const mockAddFlag = addFlag;
-describe('HsFunctionLogsTool', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error Not mocking the whole server
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        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: expect.stringContaining('Retrieve logs for HubSpot CMS serverless functions'),
-                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

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

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

@@ -1,124 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HsListFunctionsTool } from '../HsListFunctionsTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
-import { addFlag } from '../../../utils/command.js';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockRunCommandInDir = runCommandInDir;
-const mockAddFlag = addFlag;
-describe('HsListFunctionsTool', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error Not mocking the whole server
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        tool = new HsListFunctionsTool(mockMcpServer);
-    });
-    describe('register', () => {
-        it('should register the tool with the MCP server', () => {
-            const result = tool.register();
-            // First assertion - verify original description
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-cms-serverless-functions', expect.objectContaining({
-                title: 'List HubSpot CMS Serverless Functions',
-                description: expect.stringContaining('Get a list of all serverless functions deployed in a HubSpot portal/account'),
-                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

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

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

@@ -1,124 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HsListTool } from '../HsListTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
-import { addFlag } from '../../../utils/command.js';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockRunCommandInDir = runCommandInDir;
-const mockAddFlag = addFlag;
-describe('HsListTool', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error Not mocking the whole server
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        tool = new HsListTool(mockMcpServer);
-    });
-    describe('register', () => {
-        it('should register the tool with the MCP server', () => {
-            const result = tool.register();
-            // First assertion - verify original description
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-cms-remote-contents', expect.objectContaining({
-                title: 'List HubSpot CMS Directory Contents',
-                description: expect.stringContaining('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

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