@hubspot/cli 7.9.0-beta.0 → 7.9.0-beta.2

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

@@ -1,10 +1,13 @@
 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';
 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('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockHttp = http;
 const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
 describe('mcp-server/tools/project/DocFetchTool', () => {
@@ -19,21 +22,23 @@ describe('mcp-server/tools/project/DocFetchTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new DocFetchTool(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('fetch-doc', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('fetch-doc', expect.objectContaining({
                 title: 'Fetch HubSpot Developer Documentation (single file)',
-                description: 'Always use this immediately after `search-docs` and before creating a plan, writing code, or answering technical questions. This tool retrieves the full, authoritative content of a HubSpot Developer Documentation page from its URL, ensuring responses are accurate, up-to-date, and grounded in the official docs.',
+                description: expect.stringContaining('Always use this immediately after `search-docs`'),
                 inputSchema: expect.any(Object),
-            }, tool.handler);
+            }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });
     describe('handler', () => {
         const mockInput = {
+            absoluteCurrentWorkingDirectory: '/test/dir',
             docUrl: 'https://example.com/docs/test-doc',
         };
         it('should successfully fetch and return markdown content', async () => {

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

@@ -2,11 +2,14 @@ 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 { 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('../../../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);
@@ -22,16 +25,17 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new DocsSearchTool(mockMcpServer);
     });
     describe('register', () => {
-        it('should register tool with correct parameters', () => {
+        it('should register tool with correct parameters and enhanced description', () => {
             const result = tool.register();
             expect(mockMcpServer.registerTool).toHaveBeenCalledWith('search-docs', {
                 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),
-            }, tool.handler);
+            }, expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });

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

@@ -3,11 +3,14 @@ import { z } from 'zod';
 import { getAccountId } 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';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('@hubspot/local-dev-lib/http');
 vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockGetAccountId = getAccountId;
 const mockHttp = http;
 const mockIsHubSpotHttpError = isHubSpotHttpError;
@@ -23,14 +26,15 @@ describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new GetApiUsagePatternsByAppIdTool(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-api-usage-patterns-by-app-id', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-api-usage-patterns-by-app-id', expect.objectContaining({
                 title: 'Get API Usage Patterns by App ID',
-                description: 'Retrieves detailed API usage pattern analytics for a specific HubSpot application. Requires an appId (string) to identify the target application. Optionally accepts startDate and endDate parameters in YYYY-MM-DD format to filter results within a specific time range. Returns patternSummaries object containing usage statistics including portalPercentage (percentage of portals using this pattern) and numOfPortals (total count of portals) for different usage patterns. This data helps analyze how the application is being used across different HubSpot portals and can inform optimization decisions.',
+                description: expect.stringContaining('Retrieves detailed API usage pattern analytics for a specific HubSpot application'),
                 inputSchema: expect.objectContaining({
                     appId: expect.objectContaining({
                         describe: expect.any(Function),
@@ -42,7 +46,7 @@ describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
                         optional: expect.any(Function),
                     }),
                 }),
-            }, tool.handler);
+            }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });
@@ -79,6 +83,7 @@ describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
     });
     describe('handler', () => {
         const input = {
+            absoluteCurrentWorkingDirectory: '/test/dir',
             appId: '12345',
             startDate: '2025-01-01',
             endDate: '2025-12-31',

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

@@ -2,11 +2,14 @@ import { GetApplicationInfoTool } from '../GetApplicationInfoTool.js';
 import { getAccountId } 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';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../utils/toolUsageTracking');
 vi.mock('@hubspot/local-dev-lib/http');
 vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockGetAccountId = getAccountId;
 const mockHttp = http;
 const mockIsHubSpotHttpError = isHubSpotHttpError;
@@ -22,21 +25,22 @@ describe('mcp-server/tools/project/GetApplicationInfoTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new GetApplicationInfoTool(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-applications-info', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-applications-info', expect.objectContaining({
                 title: 'Get Applications Information',
-                description: 'Retrieves a list of all HubSpot applications available in the current account. Returns an array of applications, where each application contains an appId (numeric identifier) and appName (string). This information is useful for identifying available applications before using other tools that require specific application IDs, such as getting API usage patterns. No input parameters are required - this tool fetches all applications from the HubSpot Insights API.',
-                inputSchema: {},
-            }, tool.handler);
+                description: expect.stringContaining('Retrieves a list of all HubSpot applications available in the current account'),
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });
     describe('handler', () => {
-        const input = {};
+        const input = { absoluteCurrentWorkingDirectory: '/test/dir' };
         beforeEach(() => {
             mockGetAccountId.mockReturnValue(123456789);
             mockIsHubSpotHttpError.mockReturnValue(false);

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

@@ -1,10 +1,13 @@
 import { GetConfigValuesTool } from '../GetConfigValuesTool.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
 import { getAccountIdFromCliConfig } from '../../../utils/cliConfig.js';
+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('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockGetIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
 const mockMapToInternalType = mapToInternalType;
 const mockGetAccountIdFromCliConfig = getAccountIdFromCliConfig;
@@ -20,12 +23,13 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new GetConfigValuesTool(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-feature-config-schema', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-feature-config-schema', expect.objectContaining({
                 title: 'Fetch the JSON Schema for component',
                 description: expect.stringContaining('Fetches and returns the JSON schema for the provided feature'),
                 inputSchema: expect.objectContaining({
@@ -36,7 +40,7 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
                         describe: expect.any(Function),
                     }),
                 }),
-            }, tool.handler);
+            }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });

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

@@ -1,9 +1,12 @@
 import { GuidedWalkthroughTool } from '../GuidedWalkthroughTool.js';
 import { execAsync } from '../../../utils/command.js';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/command');
 vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
 const mockExecAsync = execAsync;
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
 describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
     let mockMcpServer;
     let tool;
@@ -16,16 +19,17 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new GuidedWalkthroughTool(mockMcpServer);
     });
     describe('register', () => {
-        it('should register tool with correct parameters', () => {
+        it('should register tool with correct parameters and enhanced description', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('guided-walkthrough-cli', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('guided-walkthrough-cli', expect.objectContaining({
                 title: 'Guided walkthrough of the CLI',
-                description: 'Give the user a guided walkthrough of the HubSpot CLI.',
+                description: expect.stringContaining('Give the user a guided walkthrough of the HubSpot CLI'),
                 inputSchema: expect.any(Object),
-            }, tool.handler);
+            }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });
@@ -36,7 +40,10 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
                 stdout: helpOutput,
                 stderr: '',
             });
-            const result = await tool.handler({ command: 'hs init' });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: 'hs init',
+            });
             expect(mockExecAsync).toHaveBeenCalledWith('hs init --help');
             expect(result.content).toHaveLength(1);
             expect(result.content[0].text).toContain(helpOutput);
@@ -48,7 +55,10 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
                 stdout: helpOutput,
                 stderr: '',
             });
-            const result = await tool.handler({ command: 'hs auth' });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: 'hs auth',
+            });
             expect(mockExecAsync).toHaveBeenCalledWith('hs auth --help');
             expect(result.content[0].text).toContain(helpOutput);
             expect(result.content[0].text).toContain('hs project create');
@@ -59,7 +69,10 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
                 stdout: helpOutput,
                 stderr: '',
             });
-            const result = await tool.handler({ command: 'hs project create' });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: 'hs project create',
+            });
             expect(mockExecAsync).toHaveBeenCalledWith('hs project create --help');
             expect(result.content[0].text).toContain(helpOutput);
             expect(result.content[0].text).toContain('hs project upload');
@@ -70,7 +83,10 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
                 stdout: helpOutput,
                 stderr: '',
             });
-            const result = await tool.handler({ command: 'hs project upload' });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: 'hs project upload',
+            });
             expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --help');
             expect(result.content[0].text).toContain(helpOutput);
             expect(result.content[0].text).toContain('hs project dev');
@@ -82,12 +98,17 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
                 stderr: '',
             });
             // Test with a command that doesn't have a next command
-            const result = await tool.handler({ command: 'hs project upload' });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: 'hs project upload',
+            });
             expect(result.content[0].text).toContain(helpOutput);
             expect(result.content[0].text).toContain('hs project dev');
         });
         it('should handle no command provided', async () => {
-            const result = await tool.handler({});
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
             expect(mockExecAsync).not.toHaveBeenCalled();
             expect(result.content).toEqual([
                 {
@@ -97,7 +118,10 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
             ]);
         });
         it('should handle undefined command', async () => {
-            const result = await tool.handler({ command: undefined });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: undefined,
+            });
             expect(mockExecAsync).not.toHaveBeenCalled();
             expect(result.content).toEqual([
                 {
@@ -109,7 +133,10 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
         it('should handle execAsync errors', async () => {
             const error = new Error('Command not found');
             mockExecAsync.mockRejectedValue(error);
-            await expect(tool.handler({ command: 'hs init' })).rejects.toThrow('Command not found');
+            await expect(tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: 'hs init',
+            })).rejects.toThrow('Command not found');
         });
         it('should format help text with proper instructions', async () => {
             const helpOutput = 'Usage: hs init\nOptions:\n  --help  Show help';
@@ -117,7 +144,10 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
                 stdout: helpOutput,
                 stderr: '',
             });
-            const result = await tool.handler({ command: 'hs init' });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                command: 'hs init',
+            });
             expect(result.content[0].text).toContain('Display this help output for the user amd wait for them to acknowledge:');
             expect(result.content[0].text).toContain(helpOutput);
             expect(result.content[0].text).toContain('Once they are ready, A good command to look at next is hs auth');

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

@@ -1,8 +1,11 @@
 import { UploadProjectTools } from '../UploadProjectTools.js';
 import { runCommandInDir } from '../../../utils/project.js';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockRunCommandInDir = runCommandInDir;
 describe('mcp-server/tools/project/UploadProjectTools', () => {
     let mockMcpServer;
@@ -16,21 +19,23 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new UploadProjectTools(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('upload-project', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('upload-project', expect.objectContaining({
                 title: 'Upload HubSpot Project',
                 description: expect.stringContaining('Uploads the HubSpot project in current working directory.'),
                 inputSchema: expect.any(Object),
-            }, tool.handler);
+            }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });
     describe('handler', () => {
         const input = {
+            absoluteCurrentWorkingDirectory: '/test/dir',
             absoluteProjectPath: '/test/project',
         };
         it('should upload project successfully', async () => {
@@ -88,6 +93,7 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
                 stderr: '',
             });
             const differentInput = {
+                absoluteCurrentWorkingDirectory: '/test/dir',
                 absoluteProjectPath: '/different/path/to/project',
             };
             await tool.handler(differentInput);

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

@@ -1,8 +1,11 @@
 import { ValidateProjectTool, } from '../ValidateProjectTool.js';
 import { runCommandInDir } from '../../../utils/project.js';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockRunCommandInDir = runCommandInDir;
 describe('mcp-server/tools/project/ValidateProjectTool', () => {
     let mockMcpServer;
@@ -16,21 +19,23 @@ describe('mcp-server/tools/project/ValidateProjectTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        mockMcpFeedbackRequest.mockResolvedValue('');
         tool = new ValidateProjectTool(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('validate-project', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('validate-project', expect.objectContaining({
                 title: expect.stringContaining('Validate HubSpot Project'),
                 description: expect.stringContaining('Validates the HubSpot project and its configuration files.'),
                 inputSchema: expect.any(Object),
-            }, tool.handler);
+            }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);
         });
     });
     describe('handler', () => {
         const input = {
+            absoluteCurrentWorkingDirectory: '/test/dir',
             absoluteProjectPath: '/test/project',
         };
         it('should validate project successfully', async () => {
@@ -90,6 +95,7 @@ describe('mcp-server/tools/project/ValidateProjectTool', () => {
                 stderr: '',
             });
             const differentInput = {
+                absoluteCurrentWorkingDirectory: '/test/dir',
                 absoluteProjectPath: '/different/path/to/project',
             };
             await tool.handler(differentInput);

package/mcp-server/utils/__tests__/content.test.d.ts

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

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

@@ -0,0 +1,166 @@
+import { formatTextContents, formatTextContent } from '../content.js';
+import { mcpFeedbackRequest } from '../feedbackTracking.js';
+vi.mock('../feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+describe('mcp-server/utils/content', () => {
+    const mockWorkingDirectory = '/test/working/directory';
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('formatTextContent', () => {
+        it('should format a single text string', () => {
+            const result = formatTextContent('Test message');
+            expect(result).toEqual({
+                type: 'text',
+                text: 'Test message',
+            });
+        });
+        it('should handle empty string', () => {
+            const result = formatTextContent('');
+            expect(result).toEqual({
+                type: 'text',
+                text: '',
+            });
+        });
+        it('should handle multiline text', () => {
+            const multilineText = 'Line 1\nLine 2\nLine 3';
+            const result = formatTextContent(multilineText);
+            expect(result).toEqual({
+                type: 'text',
+                text: multilineText,
+            });
+        });
+    });
+    describe('formatTextContents', () => {
+        it('should format single output without feedback', async () => {
+            mockMcpFeedbackRequest.mockResolvedValue('');
+            const result = await formatTextContents(mockWorkingDirectory, 'Test output');
+            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(mockWorkingDirectory);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Test output',
+                    },
+                ],
+            });
+        });
+        it('should format multiple outputs without feedback', async () => {
+            mockMcpFeedbackRequest.mockResolvedValue('');
+            const result = await formatTextContents(mockWorkingDirectory, 'First output', 'Second output', 'Third output');
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'First output' },
+                    { type: 'text', text: 'Second output' },
+                    { type: 'text', text: 'Third output' },
+                ],
+            });
+        });
+        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);
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Command output' },
+                    { type: 'text', text: feedbackMessage },
+                ],
+            });
+        });
+        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');
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'First output' },
+                    { type: 'text', text: 'Second output' },
+                    { type: 'text', text: feedbackMessage },
+                ],
+            });
+        });
+        it('should filter out undefined outputs', async () => {
+            mockMcpFeedbackRequest.mockResolvedValue('');
+            const result = await formatTextContents(mockWorkingDirectory, 'First output', undefined, 'Third output', undefined);
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'First output' },
+                    { type: 'text', text: 'Third output' },
+                ],
+            });
+        });
+        it('should not call mcpFeedbackRequest when no outputs provided', async () => {
+            mockMcpFeedbackRequest.mockResolvedValue('Feedback message');
+            const result = await formatTextContents(mockWorkingDirectory);
+            expect(mockMcpFeedbackRequest).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                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);
+            // mcpFeedbackRequest is still called because outputs.length > 0, but content is empty
+            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(mockWorkingDirectory);
+            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);
+            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');
+            // Should not have a third content item with empty feedback
+            expect(result.content).toHaveLength(2);
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Output 1' },
+                    { type: 'text', text: 'Output 2' },
+                ],
+            });
+        });
+        it('should handle feedback request with realistic threshold message', async () => {
+            const realisticFeedback = `
+
+    ---
+
+    IMPORTANT - FEEDBACK REQUEST FOR THIS RESPONSE ONLY:
+    This message appears only once. If you see this text in the tool output, you MUST include the following feedback request in your response to the user. If this text is NOT in the tool output, do NOT ask for feedback.
+
+    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');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0]).toEqual({
+                type: 'text',
+                text: 'Project created successfully',
+            });
+            expect(result.content[1]).toEqual({
+                type: 'text',
+                text: realisticFeedback,
+            });
+            expect(result.content[1].text).toContain('FEEDBACK REQUEST');
+        });
+        it('should correctly use absoluteCurrentWorkingDirectory parameter', async () => {
+            const customDirectory = '/custom/working/directory';
+            mockMcpFeedbackRequest.mockResolvedValue('');
+            await formatTextContents(customDirectory, 'Test output');
+            expect(mockMcpFeedbackRequest).toHaveBeenCalledWith(customDirectory);
+        });
+        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');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[1].text).toBe('Async feedback message');
+        });
+    });
+});

package/mcp-server/utils/__tests__/feedbackTracking.test.d.ts

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