@hubspot/cli 7.9.0 → 7.9.1-experimental.0

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

@@ -0,0 +1,454 @@
+import { CreateTestAccountTool, } from '../CreateTestAccountTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import fs from 'fs';
+import * as config from '@hubspot/local-dev-lib/config';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
+vi.mock('fs');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+const mockReadFileSync = fs.readFileSync;
+const mockGetConfigAccountByName = vi.spyOn(config, 'getConfigAccountByName');
+describe('mcp-server/tools/project/CreateTestAccountTool', () => {
+    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);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        tool = new CreateTestAccountTool(mockMcpServer);
+        // Mock addFlag to simulate command building
+        mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
+        // Mock fs.readFileSync for config file tests
+        mockReadFileSync.mockReturnValue(JSON.stringify({
+            accountName: 'TestAccountFromConfig',
+            description: 'Test description',
+            marketingLevel: 'PROFESSIONAL',
+        }));
+        // @ts-expect-error breaking things
+        mockGetConfigAccountByName.mockReturnValue(undefined);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-test-account', expect.objectContaining({
+                title: 'Create HubSpot Test Account',
+                description: expect.stringContaining('Creates a HubSpot developer test account'),
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+        it('should include all key information in description', () => {
+            tool.register();
+            const registerCall = mockMcpServer.registerTool.mock.calls[0];
+            const config = registerCall[1];
+            expect(config.description).toContain('test account');
+            expect(config.description).toContain('WORKFLOW');
+            expect(config.description).toContain('config file');
+            expect(config.description).toContain('ALL account details');
+            expect(config.description).toContain('non-interactive execution');
+            expect(config.description).toContain('FREE, STARTER, PROFESSIONAL, ENTERPRISE');
+        });
+    });
+    describe('handler', () => {
+        describe('config file approach', () => {
+            const baseInput = {
+                absoluteCurrentWorkingDirectory: '/test/workspace',
+                configPath: './test-account.json',
+                description: 'Test account',
+                marketingLevel: 'ENTERPRISE',
+                opsLevel: 'ENTERPRISE',
+                serviceLevel: 'ENTERPRISE',
+                salesLevel: 'ENTERPRISE',
+                contentLevel: 'ENTERPRISE',
+            };
+            it('should create test account with config path', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created successfully\nAccount ID: 12345678',
+                    stderr: '',
+                });
+                const result = await tool.handler(baseInput);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'config-path', './test-account.json');
+                expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', 'hs test-account create --config-path "./test-account.json"');
+                expect(result).toEqual({
+                    content: [
+                        { type: 'text', text: '/test/workspace' },
+                        {
+                            type: 'text',
+                            text: 'Test account created successfully\nAccount ID: 12345678',
+                        },
+                        { type: 'text', text: '' },
+                    ],
+                });
+            });
+            it('should handle absolute config path', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: '/absolute/path/to/config.json',
+                    description: 'Test account',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'config-path', '/absolute/path/to/config.json');
+                expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', 'hs test-account create --config-path "/absolute/path/to/config.json"');
+            });
+            it('should prioritize config path over flags', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './test-account.json',
+                    name: 'FlagAccount',
+                    description: 'This should be ignored',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'config-path', './test-account.json');
+                // Should not call addFlag for name or description
+                expect(mockAddFlag).not.toHaveBeenCalledWith(expect.anything(), 'name', expect.anything());
+            });
+            it('should return helpful error when config file does not exist', async () => {
+                mockReadFileSync.mockImplementation(() => {
+                    throw new Error("ENOENT: no such file or directory, open './missing-config.json'");
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './missing-config.json',
+                };
+                const result = await tool.handler(input);
+                expect(mockRunCommandInDir).not.toHaveBeenCalled();
+                expect(result).toEqual({
+                    content: [
+                        {
+                            type: 'text',
+                            text: expect.stringContaining('Failed to read or parse config file at "./missing-config.json"'),
+                        },
+                    ],
+                });
+                expect(result.content[0]).toHaveProperty('text', expect.stringContaining('Please ensure the file exists and contains valid JSON'));
+            });
+            it('should return helpful error when config file contains invalid JSON', async () => {
+                mockReadFileSync.mockReturnValue('{ invalid json }');
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './invalid-config.json',
+                };
+                const result = await tool.handler(input);
+                expect(mockRunCommandInDir).not.toHaveBeenCalled();
+                expect(result).toEqual({
+                    content: [
+                        {
+                            type: 'text',
+                            text: expect.stringContaining('Failed to read or parse config file at "./invalid-config.json"'),
+                        },
+                    ],
+                });
+            });
+        });
+        describe('flag-based approach', () => {
+            it('should create test account with name and all defaults', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created successfully',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MyTestAccount',
+                    description: '',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'MyTestAccount');
+            });
+            it('should add all flags with defaults when only name is provided', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created successfully',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MyTestAccount',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'MyTestAccount');
+                // Implementation uses name as fallback for description, and adds all hub levels with ENTERPRISE defaults
+                expect(mockAddFlag).toHaveBeenCalledTimes(7);
+                expect(mockRunCommandInDir).toHaveBeenCalled();
+            });
+            it('should create test account with account name and description', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MyTestAccount',
+                    description: 'Test account for development',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'MyTestAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('name'), 'description', 'Test account for development');
+            });
+            it('should create test account with specific hub levels', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MixedTierAccount',
+                    description: 'Test account',
+                    marketingLevel: 'PROFESSIONAL',
+                    salesLevel: 'STARTER',
+                    contentLevel: 'FREE',
+                    serviceLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'MixedTierAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('name'), 'marketing-level', 'PROFESSIONAL');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('marketing-level'), 'sales-level', 'STARTER');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('sales-level'), 'content-level', 'FREE');
+            });
+            it('should create test account with all hub levels specified', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'AllHubsAccount',
+                    description: 'Full configuration',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'PROFESSIONAL',
+                    serviceLevel: 'STARTER',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'PROFESSIONAL',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'AllHubsAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'description', 'Full configuration');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'marketing-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'ops-level', 'PROFESSIONAL');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'service-level', 'STARTER');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'sales-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'content-level', 'PROFESSIONAL');
+            });
+        });
+        describe('handler defaults', () => {
+            it('should use ENTERPRISE defaults for all hub levels when not specified', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'DefaultLevelsAccount',
+                    description: '',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'DefaultLevelsAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'marketing-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'ops-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'service-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'sales-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'content-level', 'ENTERPRISE');
+            });
+            it('should use name as fallback for description when description is empty', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'NoDescriptionAccount',
+                    description: '',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'NoDescriptionAccount');
+                // Implementation uses name as fallback for description
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'description', 'NoDescriptionAccount');
+            });
+            it('should use defaults for some hub levels while respecting explicit values', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'PartialLevelsAccount',
+                    description: '',
+                    marketingLevel: 'FREE',
+                    salesLevel: 'STARTER',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'PartialLevelsAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'marketing-level', 'FREE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'sales-level', 'STARTER');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'ops-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'service-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'content-level', 'ENTERPRISE');
+            });
+            it('should add all hub level flags when defaults are applied', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created with defaults',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MinimalAccount',
+                    description: '',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                const result = await tool.handler(input);
+                expect(mockRunCommandInDir).toHaveBeenCalled();
+                expect(mockAddFlag).toHaveBeenCalledTimes(7);
+                expect(result.content[1]).toEqual({
+                    type: 'text',
+                    text: 'Test account created with defaults',
+                });
+            });
+            it('should use ENTERPRISE defaults when values are undefined', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'BypassedDefaultsAccount',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'BypassedDefaultsAccount');
+                expect(mockAddFlag).toHaveBeenCalledTimes(7);
+            });
+        });
+        describe('interactive mode', () => {
+            it('should ask for parameters when neither config nor name provided', async () => {
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    description: 'Test account',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                const result = await tool.handler(input);
+                // Should NOT run the command
+                expect(mockRunCommandInDir).not.toHaveBeenCalled();
+                // Should return a message asking for information
+                expect(result).toEqual({
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Ask the user for the account config JSON path or the name of the test account to create.',
+                        },
+                    ],
+                });
+            });
+        });
+        describe('error handling', () => {
+            it('should handle command output with stderr warnings', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created successfully',
+                    stderr: 'Warning: Some non-critical warning message',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './test-account.json',
+                    description: 'Test account',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                const result = await tool.handler(input);
+                expect(result).toEqual({
+                    content: [
+                        { type: 'text', text: '/test/workspace' },
+                        { type: 'text', text: 'Test account created successfully' },
+                        {
+                            type: 'text',
+                            text: 'Warning: Some non-critical warning message',
+                        },
+                    ],
+                });
+            });
+            it('should handle command execution errors', async () => {
+                const error = new Error('Failed to create test account');
+                mockRunCommandInDir.mockRejectedValue(error);
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './test-account.json',
+                    description: 'Test account',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'ENTERPRISE',
+                    serviceLevel: 'ENTERPRISE',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'ENTERPRISE',
+                };
+                const result = await tool.handler(input);
+                expect(result).toEqual({
+                    content: [
+                        { type: 'text', text: '/test/workspace' },
+                        { type: 'text', text: 'Failed to create test account' },
+                    ],
+                });
+            });
+        });
+    });
+});

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

@@ -2,12 +2,15 @@ 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('../../utils/toolUsageTracking');
+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', () => {
@@ -23,6 +26,7 @@ describe('mcp-server/tools/project/DocFetchTool', () => {
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
         mockMcpFeedbackRequest.mockResolvedValue('');
+        mockTrackToolUsage.mockResolvedValue(undefined);
         tool = new DocFetchTool(mockMcpServer);
     });
     describe('register', () => {

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

@@ -1,18 +1,18 @@
 import { DocsSearchTool } from '../DocsSearchTool.js';
 import { http } from '@hubspot/local-dev-lib/http';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getAccountIdFromCliConfig } from '../../../utils/cliConfig.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.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/cliConfig.js');
 vi.mock('../../../utils/feedbackTracking');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockHttp = http;
-const mockGetAccountIdFromCliConfig = getAccountIdFromCliConfig;
 const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
 describe('mcp-server/tools/project/DocsSearchTool', () => {
     let mockMcpServer;
     let tool;
@@ -31,11 +31,11 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
     describe('register', () => {
         it('should register tool with correct parameters and enhanced description', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('search-docs', {
+            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.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });
@@ -45,7 +45,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             absoluteCurrentWorkingDirectory: '/foo',
         };
         it('should return auth error message when no account ID is found', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(null);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await tool.handler(mockInput);
             expect(result).toEqual({
                 content: [
@@ -57,7 +57,9 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should return successful results when docs are found', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
             const mockResponse = {
                 results: [
                     {
@@ -81,7 +83,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
                 data: mockResponse,
             });
             const result = await tool.handler(mockInput);
-            expect(mockGetAccountIdFromCliConfig).toHaveBeenCalledWith('/foo');
+            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalled();
             expect(mockHttp.post).toHaveBeenCalledWith(12345, {
                 url: 'dev/docs/llms/v1/docs-search',
                 data: {
@@ -109,7 +111,9 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             expect(resultText).toContain('Test content 2');
         });
         it('should return no results message when no documentation is found', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
             const mockResponse = {
                 results: [],
             };
@@ -128,7 +132,9 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should return no results message when results is null', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
             const mockResponse = {
                 results: null,
             };
@@ -147,7 +153,9 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle HubSpot HTTP errors', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
             const mockError = {
                 toString: () => 'HubSpot API Error: 404 Not Found',
             };
@@ -164,7 +172,9 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle generic errors', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
             const mockError = new Error('Network error');
             mockHttp.post.mockRejectedValue(mockError);
             mockIsHubSpotHttpError.mockReturnValue(false);
@@ -179,7 +189,9 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle non-Error rejections', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 12345,
+            });
             mockHttp.post.mockRejectedValue('String error');
             mockIsHubSpotHttpError.mockReturnValue(false);
             const result = await tool.handler(mockInput);

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

@@ -1,6 +1,6 @@
 import { GetApiUsagePatternsByAppIdTool } from '../GetApiUsagePatternsByAppIdTool.js';
 import { z } from 'zod';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+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';
@@ -11,7 +11,7 @@ vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../utils/feedbackTracking');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockGetAccountId = getAccountId;
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
 const mockHttp = http;
 const mockIsHubSpotHttpError = isHubSpotHttpError;
 describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
@@ -89,7 +89,9 @@ describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
             endDate: '2025-12-31',
         };
         beforeEach(() => {
-            mockGetAccountId.mockReturnValue(123456789);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 123456789,
+            });
             mockIsHubSpotHttpError.mockReturnValue(false);
         });
         it('should return API usage patterns successfully', async () => {
@@ -118,7 +120,7 @@ describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             mockHttp.get.mockResolvedValue(mockResponse);
             const result = await tool.handler(input);
-            expect(mockGetAccountId).toHaveBeenCalledWith();
+            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalledWith();
             expect(mockHttp.get).toHaveBeenCalledWith(123456789, {
                 url: 'app/feature/utilization/public/v3/insights/app/12345/usage-patterns',
                 params: {
@@ -136,7 +138,7 @@ describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
             });
         });
         it('should return error when account ID cannot be determined', async () => {
-            mockGetAccountId.mockReturnValue(null);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await tool.handler(input);
             expect(result).toEqual({
                 content: [