@hubspot/cli 7.7.31-experimental.0 → 7.7.33-experimental.0

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

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

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

@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsCreateFunctionTool } from '../HsCreateFunctionTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { HTTP_METHODS } from '../../../../types/Cms.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../utils/toolUsageTracking', () => ({
+    trackToolUsage: vi.fn(),
+}));
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('HsCreateFunctionTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new HsCreateFunctionTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-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__/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-hubspot-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-hubspot-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 {};