@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/mcp-server/tools/project/__tests__/DocFetchTool.test.js

@@ -0,0 +1,125 @@
+import { DocFetchTool } from '../DocFetchTool.js';
+import { http } from '@hubspot/local-dev-lib/http/unauthed';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('@hubspot/local-dev-lib/http/unauthed');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockTrackToolUsage = trackToolUsage;
+const mockHttp = http;
+const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
+describe('mcp-server/tools/project/DocFetchTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        // @ts-expect-error Not mocking whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        mockTrackToolUsage.mockResolvedValue(undefined);
+        tool = new DocFetchTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('fetch-doc', expect.objectContaining({
+                title: 'Fetch HubSpot Developer Documentation (single file)',
+                description: expect.stringContaining('Always use this immediately after `search-docs`'),
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const mockInput = {
+            absoluteCurrentWorkingDirectory: '/test/dir',
+            docUrl: 'https://example.com/docs/test-doc',
+        };
+        it('should successfully fetch and return markdown content', async () => {
+            const mockContent = '# Test Document\n\nThis is a test markdown document.';
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.get.mockResolvedValue({
+                data: mockContent,
+            });
+            const result = await tool.handler(mockInput);
+            expect(mockHttp.get).toHaveBeenCalledWith({
+                url: 'https://example.com/docs/test-doc.md',
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: mockContent,
+                    },
+                ],
+            });
+        });
+        it('should handle HubSpot HTTP errors', async () => {
+            const mockError = {
+                toString: () => 'HubSpotHttpError: \n- message: The request was not found.\n- status: 404\n- statusText: Not Found\n- method: get\n- code: ERR_BAD_REQUEST\n- derivedContext: {\n  "request": "https://example.com/docs/test-doc.md"\n}',
+            };
+            mockHttp.get.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(true);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'HubSpotHttpError: \n- message: The request was not found.\n- status: 404\n- statusText: Not Found\n- method: get\n- code: ERR_BAD_REQUEST\n- derivedContext: {\n  "request": "https://example.com/docs/test-doc.md"\n}',
+                    },
+                ],
+            });
+        });
+        it('should handle empty content', async () => {
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.get.mockResolvedValue({
+                data: '   ',
+            });
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Document is empty or contains no content.',
+                    },
+                ],
+            });
+        });
+        it('should handle generic errors', async () => {
+            const mockError = new Error('Network error');
+            mockHttp.get.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error fetching documentation: Network error',
+                    },
+                ],
+            });
+        });
+        it('should handle non-Error rejections', async () => {
+            mockHttp.get.mockRejectedValue('String error');
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error fetching documentation: String error',
+                    },
+                ],
+            });
+        });
+    });
+});

package/mcp-server/tools/project/__tests__/DocsSearchTool.test.d.ts

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

package/mcp-server/tools/project/__tests__/DocsSearchTool.test.js

@@ -0,0 +1,210 @@
+import { DocsSearchTool } from '../DocsSearchTool.js';
+import { http } from '@hubspot/local-dev-lib/http';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('@hubspot/local-dev-lib/http');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
+const mockTrackToolUsage = trackToolUsage;
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockHttp = http;
+const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
+describe('mcp-server/tools/project/DocsSearchTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        // @ts-expect-error Not mocking whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        mockTrackToolUsage.mockResolvedValue(undefined);
+        tool = new DocsSearchTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters and enhanced description', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('search-docs', expect.objectContaining({
+                title: 'Search HubSpot Developer Documentation',
+                description: 'Use this first whenever you need details about HubSpot APIs, SDKs, integrations, or developer platform features. This searches the official HubSpot Developer Documentation and returns the most relevant pages, each with a URL for use in `fetch-doc`. Always follow this with a fetch to get the full, authoritative content before making plans or writing answers.',
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const mockInput = {
+            docsSearchQuery: 'test query',
+            absoluteCurrentWorkingDirectory: '/foo',
+        };
+        it('should return auth error message when no account ID is found', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`',
+                    },
+                ],
+            });
+        });
+        it('should return successful results when docs are found', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
+            const mockResponse = {
+                results: [
+                    {
+                        title: 'Test Doc 1',
+                        content: 'Test content 1',
+                        description: 'Test description 1',
+                        url: 'https://example.com/doc1',
+                        score: 0.9,
+                    },
+                    {
+                        title: 'Test Doc 2',
+                        content: 'Test content 2',
+                        description: 'Test description 2',
+                        url: 'https://example.com/doc2',
+                        score: 0.8,
+                    },
+                ],
+            };
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.post.mockResolvedValue({
+                data: mockResponse,
+            });
+            const result = await tool.handler(mockInput);
+            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalled();
+            expect(mockHttp.post).toHaveBeenCalledWith(12345, {
+                url: 'dev/docs/llms/v1/docs-search',
+                data: {
+                    query: 'test query',
+                },
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: expect.stringContaining('Found 2 documentation results:'),
+                    },
+                ],
+            });
+            const resultText = result.content[0].text;
+            expect(resultText).toContain('**Test Doc 1**');
+            expect(resultText).toContain('Test description 1');
+            expect(resultText).toContain('https://example.com/doc1');
+            expect(resultText).toContain('Score: 0.9');
+            expect(resultText).toContain('Test content 1');
+            expect(resultText).toContain('**Test Doc 2**');
+            expect(resultText).toContain('Test description 2');
+            expect(resultText).toContain('https://example.com/doc2');
+            expect(resultText).toContain('Score: 0.8');
+            expect(resultText).toContain('Test content 2');
+        });
+        it('should return no results message when no documentation is found', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
+            const mockResponse = {
+                results: [],
+            };
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.post.mockResolvedValue({
+                data: mockResponse,
+            });
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No documentation found for your query.',
+                    },
+                ],
+            });
+        });
+        it('should return no results message when results is null', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
+            const mockResponse = {
+                results: null,
+            };
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.post.mockResolvedValue({
+                data: mockResponse,
+            });
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No documentation found for your query.',
+                    },
+                ],
+            });
+        });
+        it('should handle HubSpot HTTP errors', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
+            const mockError = {
+                toString: () => 'HubSpot API Error: 404 Not Found',
+            };
+            mockHttp.post.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(true);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'HubSpot API Error: 404 Not Found',
+                    },
+                ],
+            });
+        });
+        it('should handle generic errors', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
+            const mockError = new Error('Network error');
+            mockHttp.post.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error searching documentation: Network error',
+                    },
+                ],
+            });
+        });
+        it('should handle non-Error rejections', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
+            mockHttp.post.mockRejectedValue('String error');
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error searching documentation: String error',
+                    },
+                ],
+            });
+        });
+    });
+});

package/mcp-server/tools/project/__tests__/GetApiUsagePatternsByAppIdTool.test.d.ts

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

package/mcp-server/tools/project/__tests__/GetApiUsagePatternsByAppIdTool.test.js

@@ -0,0 +1,146 @@
+import { GetApiUsagePatternsByAppIdTool } from '../GetApiUsagePatternsByAppIdTool.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { http } from '@hubspot/local-dev-lib/http';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('@hubspot/local-dev-lib/http');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/feedbackTracking');
+const mockTrackToolUsage = trackToolUsage;
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
+const mockHttp = http;
+const mockIsHubSpotHttpError = isHubSpotHttpError;
+describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        // @ts-expect-error Not mocking the whole thing
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        mockTrackToolUsage.mockResolvedValue(undefined);
+        tool = new GetApiUsagePatternsByAppIdTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-api-usage-patterns-by-app-id', expect.objectContaining({
+                title: 'Get API Usage Patterns by App ID',
+                description: expect.stringContaining('Retrieves detailed API usage pattern analytics for a specific HubSpot app'),
+                inputSchema: expect.objectContaining({
+                    appId: expect.objectContaining({
+                        describe: expect.any(Function),
+                    }),
+                    startDate: expect.objectContaining({
+                        optional: expect.any(Function),
+                    }),
+                    endDate: expect.objectContaining({
+                        optional: expect.any(Function),
+                    }),
+                }),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            absoluteCurrentWorkingDirectory: '/test/dir',
+            appId: '12345',
+            startDate: '2025-01-01',
+            endDate: '2025-12-31',
+        };
+        beforeEach(() => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 123456789,
+            });
+            mockIsHubSpotHttpError.mockReturnValue(false);
+        });
+        it('should return API usage patterns successfully', async () => {
+            const mockResponse = {
+                data: {
+                    patternSummaries: {
+                        additionalProp1: {
+                            portalPercentage: 25.5,
+                            numOfPortals: 150,
+                        },
+                        additionalProp2: {
+                            portalPercentage: 18.2,
+                            numOfPortals: 89,
+                        },
+                        additionalProp3: {
+                            portalPercentage: 32.1,
+                            numOfPortals: 201,
+                        },
+                    },
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalledWith();
+            expect(mockHttp.get).toHaveBeenCalledWith(123456789, {
+                url: 'app/feature/utilization/public/v3/insights/app/12345/usage-patterns',
+                params: {
+                    startDate: '2025-01-01',
+                    endDate: '2025-12-31',
+                },
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+        it('should return error when account ID cannot be determined', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`',
+                    },
+                ],
+            });
+            expect(mockHttp.get).not.toHaveBeenCalled();
+        });
+        it('should handle empty usage patterns response', async () => {
+            const mockResponse = {
+                data: {
+                    patternSummaries: {},
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+    });
+});

package/mcp-server/tools/project/__tests__/GetApplicationInfoTool.test.d.ts

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

package/mcp-server/tools/project/__tests__/GetApplicationInfoTool.test.js

@@ -0,0 +1,124 @@
+import { GetApplicationInfoTool } from '../GetApplicationInfoTool.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { http } from '@hubspot/local-dev-lib/http';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('@hubspot/local-dev-lib/http');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/feedbackTracking');
+vi.mock('../../../utils/config');
+const mockTrackToolUsage = trackToolUsage;
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
+const mockHttp = http;
+const mockIsHubSpotHttpError = isHubSpotHttpError;
+describe('mcp-server/tools/project/GetApplicationInfoTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        // @ts-expect-error Not mocking the whole thing
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        mockTrackToolUsage.mockResolvedValue(undefined);
+        tool = new GetApplicationInfoTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-apps-info', expect.objectContaining({
+                title: 'Get Apps Information',
+                description: expect.stringContaining('Retrieves a list of all HubSpot apps available in the current account'),
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = { absoluteCurrentWorkingDirectory: '/test/dir' };
+        beforeEach(() => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 123456789,
+            });
+            mockIsHubSpotHttpError.mockReturnValue(false);
+        });
+        it('should return application information successfully', async () => {
+            const mockResponse = {
+                data: {
+                    applications: [
+                        {
+                            appId: 12345,
+                            appName: 'Test App 1',
+                        },
+                        {
+                            appId: 67890,
+                            appName: 'Test App 2',
+                        },
+                    ],
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalledWith();
+            expect(mockHttp.get).toHaveBeenCalledWith(123456789, {
+                url: 'app/feature/utilization/public/v3/insights/apps',
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+        it('should return error when account ID cannot be determined', async () => {
+            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`',
+                    },
+                ],
+            });
+            expect(mockHttp.get).not.toHaveBeenCalled();
+        });
+        it('should handle empty applications response', async () => {
+            const mockResponse = {
+                data: {
+                    applications: [],
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+    });
+});

package/mcp-server/tools/project/__tests__/GetBuildLogsTool.test.d.ts

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