@hubspot/cli 7.9.0 → 7.9.1-experimental.0

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__/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: [

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

@@ -1,12 +1,18 @@
 import { UploadProjectTools } from '../UploadProjectTools.js';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib';
+import { getProjectConfig } from '../../../../lib/projects/config.js';
 import { runCommandInDir } from '../../../utils/project.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../../../../lib/projects/config.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockRunCommandInDir = runCommandInDir;
+const mockGetProjectConfig = getProjectConfig;
+const mockGetAllHsProfiles = getAllHsProfiles;
 describe('mcp-server/tools/project/UploadProjectTools', () => {
     let mockMcpServer;
     let tool;
@@ -20,6 +26,15 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
         mockMcpFeedbackRequest.mockResolvedValue('');
+        mockGetProjectConfig.mockResolvedValue({
+            projectConfig: {
+                srcDir: 'src',
+                name: 'test-project',
+                platformVersion: '2025.2',
+            },
+            projectDir: '/test/project',
+        });
+        mockGetAllHsProfiles.mockResolvedValue([]);
         tool = new UploadProjectTools(mockMcpServer);
     });
     describe('register', () => {
@@ -37,6 +52,7 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
         const input = {
             absoluteCurrentWorkingDirectory: '/test/dir',
             absoluteProjectPath: '/test/project',
+            uploadMessage: 'Test upload message',
         };
         it('should upload project successfully', async () => {
             mockRunCommandInDir.mockResolvedValue({
@@ -44,7 +60,9 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
                 stderr: '',
             });
             const result = await tool.handler(input);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project upload --force-create');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('hs project upload'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--force-create'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--message "Test upload message"'));
             expect(result).toEqual({
                 content: [
                     { type: 'text', text: 'Project uploaded successfully' },
@@ -68,13 +86,44 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
             mockRunCommandInDir.mockRejectedValue(error);
             await expect(tool.handler(input)).rejects.toThrow('Upload failed');
         });
-        it('should use force-create flag', async () => {
+        it('should use force-create and message flags', async () => {
             mockRunCommandInDir.mockResolvedValue({
                 stdout: 'Project created and uploaded',
                 stderr: '',
             });
             await tool.handler(input);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project upload --force-create');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('hs project upload'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--force-create'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--message "Test upload message"'));
+        });
+        it('should use profiles', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project created and uploaded',
+                stderr: '',
+            });
+            await tool.handler({
+                ...input,
+                profile: 'dev',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('hs project upload'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--force-create'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--message "Test upload message"'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--profile "dev"'));
+        });
+        it('should prompt for profile if not specified and the project requires them', async () => {
+            mockGetAllHsProfiles.mockResolvedValue(['prod', 'dev']);
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project created and uploaded',
+                stderr: '',
+            });
+            const result = await tool.handler(input);
+            expect(mockRunCommandInDir).not.toHaveBeenCalled();
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: 'Ask the user which profile they would like to use for the upload.',
+                },
+            ]);
         });
         it('should handle empty stdout and stderr', async () => {
             mockRunCommandInDir.mockResolvedValue({
@@ -95,9 +144,12 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
             const differentInput = {
                 absoluteCurrentWorkingDirectory: '/test/dir',
                 absoluteProjectPath: '/different/path/to/project',
+                uploadMessage: 'Different test upload message',
             };
             await tool.handler(differentInput);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', 'hs project upload --force-create');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', expect.stringContaining('hs project upload'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', expect.stringContaining('--force-create'));
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', expect.stringContaining('--message "Different test upload message"'));
         });
         it('should handle very long output', async () => {
             const longOutput = 'A'.repeat(10000);

package/mcp-server/utils/__tests__/content.test.js

@@ -3,7 +3,6 @@ import { mcpFeedbackRequest } from '../feedbackTracking.js';
 vi.mock('../feedbackTracking');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
 describe('mcp-server/utils/content', () => {
-    const mockWorkingDirectory = '/test/working/directory';
     beforeEach(() => {
         vi.clearAllMocks();
     });
@@ -34,8 +33,8 @@ describe('mcp-server/utils/content', () => {
     describe('formatTextContents', () => {
         it('should format single output without feedback', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('');
-            const result = await formatTextContents(mockWorkingDirectory, 'Test output');
-            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(mockWorkingDirectory);
+            const result = await formatTextContents('Test output');
+            expect(mockMcpFeedbackRequest).toHaveBeenCalled();
             expect(result).toEqual({
                 content: [
                     {
@@ -47,7 +46,7 @@ describe('mcp-server/utils/content', () => {
         });
         it('should format multiple outputs without feedback', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('');
-            const result = await formatTextContents(mockWorkingDirectory, 'First output', 'Second output', 'Third output');
+            const result = await formatTextContents('First output', 'Second output', 'Third output');
             expect(result).toEqual({
                 content: [
                     { type: 'text', text: 'First output' },
@@ -59,8 +58,8 @@ describe('mcp-server/utils/content', () => {
         it('should append feedback message when feedback is returned', async () => {
             const feedbackMessage = 'Please share your feedback!';
             mockMcpFeedbackRequest.mockResolvedValue(feedbackMessage);
-            const result = await formatTextContents(mockWorkingDirectory, 'Command output');
-            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(mockWorkingDirectory);
+            const result = await formatTextContents('Command output');
+            expect(mockMcpFeedbackRequest).toHaveBeenCalled();
             expect(result).toEqual({
                 content: [
                     { type: 'text', text: 'Command output' },
@@ -71,7 +70,7 @@ describe('mcp-server/utils/content', () => {
         it('should append feedback to multiple outputs', async () => {
             const feedbackMessage = 'Feedback request message';
             mockMcpFeedbackRequest.mockResolvedValue(feedbackMessage);
-            const result = await formatTextContents(mockWorkingDirectory, 'First output', 'Second output');
+            const result = await formatTextContents('First output', 'Second output');
             expect(result).toEqual({
                 content: [
                     { type: 'text', text: 'First output' },
@@ -82,7 +81,7 @@ describe('mcp-server/utils/content', () => {
         });
         it('should filter out undefined outputs', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('');
-            const result = await formatTextContents(mockWorkingDirectory, 'First output', undefined, 'Third output', undefined);
+            const result = await formatTextContents('First output', undefined, 'Third output', undefined);
             expect(result).toEqual({
                 content: [
                     { type: 'text', text: 'First output' },
@@ -92,7 +91,7 @@ describe('mcp-server/utils/content', () => {
         });
         it('should not call mcpFeedbackRequest when no outputs provided', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('Feedback message');
-            const result = await formatTextContents(mockWorkingDirectory);
+            const result = await formatTextContents();
             expect(mockMcpFeedbackRequest).not.toHaveBeenCalled();
             expect(result).toEqual({
                 content: [],
@@ -100,24 +99,24 @@ describe('mcp-server/utils/content', () => {
         });
         it('should call mcpFeedbackRequest but not add feedback when all outputs are undefined and feedback is empty', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('');
-            const result = await formatTextContents(mockWorkingDirectory, undefined, undefined);
+            const result = await formatTextContents(undefined, undefined);
             // mcpFeedbackRequest is still called because outputs.length > 0, but content is empty
-            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(mockWorkingDirectory);
+            expect(mockMcpFeedbackRequest).toHaveBeenCalled();
             expect(result).toEqual({
                 content: [],
             });
         });
         it('should handle empty string outputs and still request feedback', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('');
-            const result = await formatTextContents(mockWorkingDirectory, '');
-            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(mockWorkingDirectory);
+            const result = await formatTextContents('');
+            expect(mockMcpFeedbackRequest).toHaveBeenCalled();
             expect(result).toEqual({
                 content: [{ type: 'text', text: '' }],
             });
         });
         it('should not add feedback when empty string is returned from mcpFeedbackRequest', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('');
-            const result = await formatTextContents(mockWorkingDirectory, 'Output 1', 'Output 2');
+            const result = await formatTextContents('Output 1', 'Output 2');
             // Should not have a third content item with empty feedback
             expect(result.content).toHaveLength(2);
             expect(result).toEqual({
@@ -137,7 +136,7 @@ describe('mcp-server/utils/content', () => {
 
     Say: "📝 **Before we continue, would you mind sharing feedback on your experience with the HubSpot Developer MCP?** Your input helps us improve: [Share feedback here](https://app.hubspot.com/l/product-updates/in-beta?rollout=239890)"`;
             mockMcpFeedbackRequest.mockResolvedValue(realisticFeedback);
-            const result = await formatTextContents(mockWorkingDirectory, 'Project created successfully');
+            const result = await formatTextContents('Project created successfully');
             expect(result.content).toHaveLength(2);
             expect(result.content[0]).toEqual({
                 type: 'text',
@@ -149,16 +148,18 @@ describe('mcp-server/utils/content', () => {
             });
             expect(result.content[1].text).toContain('FEEDBACK REQUEST');
         });
-        it('should correctly use absoluteCurrentWorkingDirectory parameter', async () => {
-            const customDirectory = '/custom/working/directory';
+        it('should not require absoluteCurrentWorkingDirectory parameter', async () => {
             mockMcpFeedbackRequest.mockResolvedValue('');
-            await formatTextContents(customDirectory, 'Test output');
-            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(customDirectory);
+            const result = await formatTextContents('Test output');
+            expect(mockMcpFeedbackRequest).toHaveBeenCalled();
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'Test output' }],
+            });
         });
         it('should await mcpFeedbackRequest and handle async properly', async () => {
             const feedbackPromise = Promise.resolve('Async feedback message');
             mockMcpFeedbackRequest.mockReturnValue(feedbackPromise);
-            const result = await formatTextContents(mockWorkingDirectory, 'Output');
+            const result = await formatTextContents('Output');
             expect(result.content).toHaveLength(2);
             expect(result.content[1].text).toBe('Async feedback message');
         });