@hubspot/cli 7.10.0-beta.1 → 7.10.0-experimental.0

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

@@ -2,14 +2,20 @@ 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;
@@ -26,6 +32,14 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
         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', () => {
@@ -54,6 +68,12 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
             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({
@@ -65,6 +85,7 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 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',
@@ -81,6 +102,12 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 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');
@@ -96,15 +123,57 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                     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 just account name', async () => {
+            it('should create test account with name and all defaults', async () => {
                 mockRunCommandInDir.mockResolvedValue({
                     stdout: 'Test account created successfully',
                     stderr: '',
@@ -112,10 +181,30 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 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');
-                expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', '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({
@@ -126,6 +215,11 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                     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');
@@ -139,9 +233,12 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 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');
@@ -174,10 +271,120 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 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
@@ -202,10 +409,17 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 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',
@@ -220,10 +434,19 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 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: 'Failed to create test account' }],
+                    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;
@@ -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: [

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

@@ -1,5 +1,5 @@
 import { GetApplicationInfoTool } from '../GetApplicationInfoTool.js';
-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';
@@ -10,7 +10,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/GetApplicationInfoTool', () => {
@@ -42,7 +42,9 @@ describe('mcp-server/tools/project/GetApplicationInfoTool', () => {
     describe('handler', () => {
         const input = { absoluteCurrentWorkingDirectory: '/test/dir' };
         beforeEach(() => {
-            mockGetAccountId.mockReturnValue(123456789);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 123456789,
+            });
             mockIsHubSpotHttpError.mockReturnValue(false);
         });
         it('should return application information successfully', async () => {
@@ -67,7 +69,7 @@ describe('mcp-server/tools/project/GetApplicationInfoTool', () => {
             // 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/apps',
             });
@@ -81,7 +83,7 @@ describe('mcp-server/tools/project/GetApplicationInfoTool', () => {
             });
         });
         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: [

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

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