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

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

@@ -0,0 +1,305 @@
+import { GetBuildLogsTool } from '../GetBuildLogsTool.js';
+import { http } from '@hubspot/local-dev-lib/http';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { getProjectConfig, validateProjectConfig, } from '../../../../lib/projects/config.js';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/cliConfig');
+vi.mock('@hubspot/local-dev-lib/http');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('../../../../lib/projects/config.js');
+vi.mock('../../../utils/feedbackTracking');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
+const mockHttpGet = http.get;
+const mockIsHubSpotHttpError = isHubSpotHttpError;
+const mockGetProjectConfig = getProjectConfig;
+const mockValidateProjectConfig = validateProjectConfig;
+const TEST_ACCOUNT_ID = 123456789;
+const TEST_PROJECT_NAME = 'test-project';
+const TEST_PROJECT_PATH = '/test/project';
+const TEST_WORKING_DIR = '/test';
+const TEST_BUILD_ID = 123;
+const TEST_PLATFORM_VERSION = '2025.2';
+function createMockLog(overrides = {}) {
+    return {
+        lineNumber: 1,
+        logLevel: 'INFO',
+        message: 'Starting build validation',
+        pipelineStepId: 1,
+        pipelineSubstepId: 'test-step',
+        pipelineSubstepName: 'test-component',
+        timestamp: Date.now(),
+        ...overrides,
+    };
+}
+function createMockLogs() {
+    return {
+        pipelineStage: 'BUILD',
+        pipelineStepId: 2,
+        projectName: TEST_PROJECT_NAME,
+        logs: [
+            {
+                pipelineStepId: 2,
+                pipelineSubstepId: 'test-app-id',
+                pipelineStage: 'BUILD',
+                projectName: TEST_PROJECT_NAME,
+                logs: [
+                    createMockLog({
+                        lineNumber: 1,
+                        logLevel: 'INFO',
+                        message: "Starting build validation for app 'Test App'",
+                        pipelineSubstepName: 'test-app',
+                        pipelineSubstepId: 'test-app-id',
+                    }),
+                    createMockLog({
+                        lineNumber: 2,
+                        logLevel: 'INFO',
+                        message: "Successfully validated app configuration for 'Test App'",
+                        pipelineSubstepName: 'test-app',
+                        pipelineSubstepId: 'test-app-id',
+                    }),
+                ],
+            },
+            {
+                pipelineStepId: 2,
+                pipelineSubstepId: 'test-card-id',
+                pipelineStage: 'BUILD',
+                projectName: TEST_PROJECT_NAME,
+                logs: [
+                    createMockLog({
+                        lineNumber: 1,
+                        logLevel: 'INFO',
+                        message: 'Starting card build...',
+                        pipelineSubstepName: 'test-card',
+                        pipelineSubstepId: 'test-card-id',
+                    }),
+                    createMockLog({
+                        lineNumber: 2,
+                        logLevel: 'INFO',
+                        message: 'Validating card configuration...',
+                        pipelineSubstepName: 'test-card',
+                        pipelineSubstepId: 'test-card-id',
+                    }),
+                    createMockLog({
+                        lineNumber: 3,
+                        logLevel: 'ERROR',
+                        message: 'Failed to build card. The preview image file /app/cards/assets/preview.png was not found. Make sure the file exists in /app/cards and try again.',
+                        pipelineSubstepName: 'test-card',
+                        pipelineSubstepId: 'test-card-id',
+                    }),
+                ],
+            },
+            {
+                pipelineStepId: 2,
+                pipelineSubstepId: 'test-webhook-id',
+                pipelineStage: 'BUILD',
+                projectName: TEST_PROJECT_NAME,
+                logs: [
+                    createMockLog({
+                        lineNumber: 1,
+                        logLevel: 'WARN',
+                        message: 'Deprecated API usage detected in webhook configuration',
+                        pipelineSubstepName: 'test-webhook',
+                        pipelineSubstepId: 'test-webhook-id',
+                    }),
+                ],
+            },
+        ],
+    };
+}
+function createLogsResponse(data) {
+    return {
+        data,
+    };
+}
+function createMockProjectConfig(overrides = {}) {
+    return {
+        name: TEST_PROJECT_NAME,
+        srcDir: 'src',
+        platformVersion: TEST_PLATFORM_VERSION,
+        ...overrides,
+    };
+}
+function expectTextContent(result, ...expectedStrings) {
+    expectedStrings.forEach(str => {
+        expect(result.content[1].text).toContain(str);
+    });
+}
+describe('mcp-server/tools/project/GetBuildLogsTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole thing
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        tool = new GetBuildLogsTool(mockMcpServer);
+        // Default mock implementations
+        mockGetConfigDefaultAccountIfExists.mockReturnValue({
+            accountId: TEST_ACCOUNT_ID,
+        });
+        mockIsHubSpotHttpError.mockReturnValue(false);
+        mockGetProjectConfig.mockResolvedValue({
+            projectConfig: createMockProjectConfig(),
+            projectDir: TEST_PROJECT_PATH,
+        });
+        mockValidateProjectConfig.mockImplementation(() => { });
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-build-logs', expect.objectContaining({
+                title: 'Get HubSpot Project Build Logs',
+                description: expect.stringContaining('Retrieves build logs for a specific HubSpot project build'),
+                inputSchema: expect.anything(),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const baseInput = {
+            absoluteProjectPath: TEST_PROJECT_PATH,
+            absoluteCurrentWorkingDirectory: TEST_WORKING_DIR,
+            buildId: TEST_BUILD_ID,
+            logLevel: 'ALL',
+        };
+        describe('error handling', () => {
+            it('should return error when account ID cannot be determined', async () => {
+                mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
+                const result = await tool.handler(baseInput);
+                expect(result).toEqual({
+                    content: [
+                        {
+                            type: 'text',
+                            text: TEST_WORKING_DIR,
+                        },
+                        {
+                            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(mockHttpGet).not.toHaveBeenCalled();
+            });
+            it('should handle HubSpot HTTP errors', async () => {
+                const error = new Error('API Error');
+                mockIsHubSpotHttpError.mockReturnValue(true);
+                mockHttpGet.mockRejectedValue(error);
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, 'API Error');
+            });
+            it('should handle generic errors', async () => {
+                const error = new Error('Generic error');
+                mockIsHubSpotHttpError.mockReturnValue(false);
+                mockHttpGet.mockRejectedValue(error);
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, 'Generic error');
+            });
+            it('should handle empty logs', async () => {
+                const emptyLogsResponse = {
+                    pipelineStage: 'BUILD',
+                    pipelineStepId: 2,
+                    projectName: TEST_PROJECT_NAME,
+                    logs: [],
+                };
+                mockHttpGet.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createLogsResponse(emptyLogsResponse));
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, `No logs found for build #${TEST_BUILD_ID}`, TEST_PROJECT_NAME);
+            });
+        });
+        describe('log fetching', () => {
+            it('should fetch and display all logs', async () => {
+                const mockLogs = createMockLogs();
+                mockHttpGet.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createLogsResponse(mockLogs));
+                const result = await tool.handler(baseInput);
+                expect(mockGetProjectConfig).toHaveBeenCalledWith(TEST_PROJECT_PATH);
+                expect(mockHttpGet).toHaveBeenCalledWith(TEST_ACCOUNT_ID, {
+                    url: `dfs/logging/v1/logs/projects/${TEST_PROJECT_NAME}/builds/${TEST_BUILD_ID}`,
+                });
+                expectTextContent(result, `Logs for build #${TEST_BUILD_ID}`, TEST_PROJECT_NAME, 'ALL level', 'Starting build validation', 'Successfully validated', 'Failed to build card', 'Deprecated API usage');
+            });
+            it('should filter logs by ERROR level', async () => {
+                const mockLogs = createMockLogs();
+                mockHttpGet.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createLogsResponse(mockLogs));
+                const result = await tool.handler({
+                    ...baseInput,
+                    logLevel: 'ERROR',
+                });
+                expectTextContent(result, 'ERROR level', 'Failed to build card', 'preview.png was not found');
+                expect(result.content[1].text).not.toContain('Starting build');
+                expect(result.content[1].text).not.toContain('Deprecated API');
+            });
+            it('should filter logs by WARN level', async () => {
+                const mockLogs = createMockLogs();
+                mockHttpGet.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createLogsResponse(mockLogs));
+                const result = await tool.handler({
+                    ...baseInput,
+                    logLevel: 'WARN',
+                });
+                expectTextContent(result, 'WARN level', 'Deprecated API usage detected');
+                expect(result.content[1].text).not.toContain('Starting build');
+                expect(result.content[1].text).not.toContain('Failed to build card');
+            });
+            it('should filter logs by INFO level', async () => {
+                const mockLogs = createMockLogs();
+                mockHttpGet.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createLogsResponse(mockLogs));
+                const result = await tool.handler({
+                    ...baseInput,
+                    logLevel: 'INFO',
+                });
+                expectTextContent(result, 'INFO level', 'Starting build validation', 'Successfully validated');
+                expect(result.content[1].text).not.toContain('Failed to build card');
+                expect(result.content[1].text).not.toContain('Deprecated API');
+            });
+            it('should show all logs when no logs match filter', async () => {
+                const infoOnlyResponse = {
+                    pipelineStage: 'BUILD',
+                    pipelineStepId: 2,
+                    projectName: TEST_PROJECT_NAME,
+                    logs: [
+                        {
+                            pipelineStepId: 2,
+                            pipelineSubstepId: 'info-only-id',
+                            pipelineStage: 'BUILD',
+                            projectName: TEST_PROJECT_NAME,
+                            logs: [
+                                createMockLog({
+                                    logLevel: 'INFO',
+                                    message: 'Info message only',
+                                    pipelineSubstepId: 'info-only-id',
+                                }),
+                            ],
+                        },
+                    ],
+                };
+                mockHttpGet.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createLogsResponse(infoOnlyResponse));
+                const result = await tool.handler({
+                    ...baseInput,
+                    logLevel: 'ERROR',
+                });
+                expectTextContent(result, `No ERROR level logs found`, `build #${TEST_BUILD_ID}`, 'Showing all logs instead', 'Info message only');
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,240 @@
+import { GetBuildStatusTool } from '../GetBuildStatusTool.js';
+import { fetchProjectBuilds, getBuildStatus, } from '@hubspot/local-dev-lib/api/projects';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { getProjectConfig, validateProjectConfig, } from '../../../../lib/projects/config.js';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('../../../../lib/projects/config.js');
+vi.mock('../../../utils/feedbackTracking');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockFetchProjectBuilds = fetchProjectBuilds;
+const mockGetBuildStatus = getBuildStatus;
+const mockIsHubSpotHttpError = isHubSpotHttpError;
+const mockGetProjectConfig = getProjectConfig;
+const mockValidateProjectConfig = validateProjectConfig;
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
+const TEST_ACCOUNT_ID = 123456789;
+const TEST_PROJECT_NAME = 'test-project';
+const TEST_PROJECT_PATH = '/test/project';
+const TEST_WORKING_DIR = '/test';
+const TEST_PLATFORM_VERSION = '2025.2';
+function createMockBuild(overrides = {}) {
+    return {
+        buildId: 10,
+        status: 'FAILURE',
+        createdAt: '2025-11-18T21:50:50.632Z',
+        enqueuedAt: null,
+        finishedAt: '2025-11-20T22:32:07.008Z',
+        startedAt: '2025-11-18T21:50:50.632Z',
+        subbuildStatuses: [
+            {
+                buildName: 'my-card',
+                buildType: 'CARD',
+                status: 'FAILURE',
+                errorMessage: 'There were errors building this component:\n - The preview image file /app/cards/assets/preview.png was not found. Make sure the file exists in /app/cards and try again.',
+            },
+            {
+                buildName: 'my-app',
+                buildType: 'APPLICATION',
+                status: 'SUCCESS',
+                errorMessage: '',
+            },
+        ],
+        buildErrorMessage: 'The source code for this project is too large. HubSpot projects have a maximum size limit of 50.0 MB.',
+        platformVersion: TEST_PLATFORM_VERSION,
+        deployable: true,
+        deployableState: 'DEPLOYABLE',
+        ...overrides,
+    };
+}
+function createMockProjectConfig(overrides = {}) {
+    return {
+        name: TEST_PROJECT_NAME,
+        srcDir: 'src',
+        platformVersion: TEST_PLATFORM_VERSION,
+        ...overrides,
+    };
+}
+function createBuildListResponse(builds) {
+    return {
+        data: {
+            results: builds,
+            paging: undefined,
+        },
+    };
+}
+function createBuildDetailsResponse(build) {
+    return {
+        data: build,
+    };
+}
+function expectTextContent(result, ...expectedStrings) {
+    expectedStrings.forEach(str => {
+        expect(result.content[1].text).toContain(str);
+    });
+}
+describe('mcp-server/tools/project/GetBuildStatusTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole thing
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        tool = new GetBuildStatusTool(mockMcpServer);
+        // Default mock implementations
+        mockIsHubSpotHttpError.mockReturnValue(false);
+        mockGetProjectConfig.mockResolvedValue({
+            projectConfig: createMockProjectConfig(),
+            projectDir: TEST_PROJECT_PATH,
+        });
+        mockValidateProjectConfig.mockImplementation(() => { });
+        mockGetConfigDefaultAccountIfExists.mockReturnValue({
+            accountId: TEST_ACCOUNT_ID,
+        });
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-build-status', expect.objectContaining({
+                title: 'Get HubSpot Projects Build Status and Errors',
+                description: expect.stringContaining('Retrieves build status and error messages for HubSpot projects'),
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const baseInput = {
+            absoluteProjectPath: TEST_PROJECT_PATH,
+            absoluteCurrentWorkingDirectory: TEST_WORKING_DIR,
+            buildId: undefined,
+            limit: 5,
+        };
+        describe('error handling', () => {
+            it('should return error when account ID cannot be determined', async () => {
+                mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
+                const result = await tool.handler(baseInput);
+                expect(result).toEqual({
+                    content: [
+                        {
+                            type: 'text',
+                            text: TEST_WORKING_DIR,
+                        },
+                        {
+                            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(mockFetchProjectBuilds).not.toHaveBeenCalled();
+            });
+            it('should return error when specific build for provided buildId is not found', async () => {
+                const error = new Error('Build not found');
+                // @ts-expect-error Adding status property
+                error.status = 404;
+                mockIsHubSpotHttpError.mockReturnValue(true);
+                mockGetBuildStatus.mockRejectedValue(error);
+                const result = await tool.handler({ ...baseInput, buildId: 999 });
+                expectTextContent(result, 'Build not found');
+            });
+            it('should handle HubSpot HTTP errors', async () => {
+                const error = new Error('API Error');
+                mockIsHubSpotHttpError.mockReturnValue(true);
+                mockFetchProjectBuilds.mockRejectedValue(error);
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, 'API Error');
+            });
+            it('should handle generic errors', async () => {
+                const error = new Error('Generic error');
+                mockIsHubSpotHttpError.mockReturnValue(false);
+                mockFetchProjectBuilds.mockRejectedValue(error);
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, 'Generic error');
+            });
+        });
+        describe('list view (no buildId)', () => {
+            it('should return recent builds when no buildId is provided', async () => {
+                const mockBuild = createMockBuild();
+                mockFetchProjectBuilds.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createBuildListResponse([mockBuild]));
+                const result = await tool.handler(baseInput);
+                expect(mockGetProjectConfig).toHaveBeenCalledWith(TEST_PROJECT_PATH);
+                expect(mockFetchProjectBuilds).toHaveBeenCalledWith(TEST_ACCOUNT_ID, TEST_PROJECT_NAME, { limit: 5 });
+                expectTextContent(result, `Recent builds for '${TEST_PROJECT_NAME}':`, 'Build #10 - FAILURE', 'The source code for this project is too large');
+            });
+            it('should return error when no builds exist', async () => {
+                mockFetchProjectBuilds.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createBuildListResponse([]));
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, `No builds found for project '${TEST_PROJECT_NAME}'`);
+            });
+            it('should handle successful builds', async () => {
+                const successBuild = createMockBuild({
+                    buildId: 11,
+                    status: 'SUCCESS',
+                    buildErrorMessage: undefined,
+                    subbuildStatuses: [
+                        {
+                            buildName: 'my-app',
+                            buildType: 'APPLICATION',
+                            status: 'SUCCESS',
+                            errorMessage: '',
+                        },
+                    ],
+                });
+                mockFetchProjectBuilds.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createBuildListResponse([successBuild]));
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, 'Build #11 - SUCCESS ✓');
+                expect(result.content[1].text).not.toContain('Error:');
+            });
+            it('should display all subbuilds (success and failure)', async () => {
+                const buildWithSubbuilds = createMockBuild({
+                    subbuildStatuses: [
+                        {
+                            buildName: 'my-webhooks',
+                            buildType: 'WEBHOOKS',
+                            status: 'SUCCESS',
+                        },
+                        {
+                            buildName: 'my-app',
+                            buildType: 'APPLICATION',
+                            status: 'FAILURE',
+                            errorMessage: 'Duplicate UID',
+                        },
+                    ],
+                });
+                mockFetchProjectBuilds.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createBuildListResponse([buildWithSubbuilds]));
+                const result = await tool.handler(baseInput);
+                expectTextContent(result, 'Subbuilds:', '✓ my-webhooks (WEBHOOKS): SUCCESS', '⚠️ my-app (APPLICATION): FAILURE', 'Error: Duplicate UID');
+            });
+        });
+        describe('detail view (with buildId)', () => {
+            it('should return specific build details when buildId is provided', async () => {
+                const mockBuild = createMockBuild();
+                mockGetBuildStatus.mockResolvedValue(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createBuildDetailsResponse(mockBuild));
+                const result = await tool.handler({ ...baseInput, buildId: 10 });
+                expect(mockGetBuildStatus).toHaveBeenCalledWith(TEST_ACCOUNT_ID, TEST_PROJECT_NAME, 10);
+                expectTextContent(result, 'Build #10 Details', 'Status: FAILURE', `Platform Version: ${TEST_PLATFORM_VERSION}`, 'Build Error:');
+            });
+        });
+    });
+});

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

@@ -1,16 +1,16 @@
 import { GetConfigValuesTool } from '../GetConfigValuesTool.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
-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/project-parsing-lib');
-vi.mock('../../../utils/cliConfig.js');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockGetIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
 const mockMapToInternalType = mapToInternalType;
-const mockGetAccountIdFromCliConfig = getAccountIdFromCliConfig;
+const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
 describe('mcp-server/tools/project/GetConfigValuesTool', () => {
     let mockMcpServer;
     let tool;
@@ -51,7 +51,9 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
             absoluteCurrentWorkingDirectory: '/foo',
         };
         beforeEach(() => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(123456789);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue({
+                accountId: 123456789,
+            });
         });
         it('should return config schema when component type exists', async () => {
             const mockSchema = {
@@ -66,7 +68,7 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
             mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
             mockMapToInternalType.mockReturnValue('internal-card-type');
             const result = await tool.handler(input);
-            expect(mockGetAccountIdFromCliConfig).toHaveBeenCalledWith('/foo');
+            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalled();
             expect(mockGetIntermediateRepresentationSchema).toHaveBeenCalledWith({
                 platformVersion: '2025.2',
                 projectSourceDir: '',
@@ -139,7 +141,7 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
             });
         });
         it('should handle null account id', async () => {
-            mockGetAccountIdFromCliConfig.mockReturnValue(null);
+            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await tool.handler(input);
             expect(result).toEqual({
                 content: [