@hubspot/cli 7.7.27-experimental.2 → 7.7.28-experimental.0

package/lib/ui/__tests__/removeAnsiCodes.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import chalk from 'chalk';
+import { removeAnsiCodes } from '../removeAnsiCodes.js';
+describe('removeAnsiCodes', () => {
+    describe('basic functionality', () => {
+        it('should remove ANSI codes from colored text', () => {
+            const coloredText = chalk.red('Error message');
+            const cleanText = removeAnsiCodes(coloredText);
+            expect(cleanText).toBe('Error message');
+        });
+        it('should return unchanged text when no ANSI codes are present', () => {
+            const plainText = 'This is plain text';
+            const result = removeAnsiCodes(plainText);
+            expect(result).toBe('This is plain text');
+        });
+        it('should handle empty strings', () => {
+            const result = removeAnsiCodes('');
+            expect(result).toBe('');
+        });
+    });
+    describe('background colors', () => {
+        it('should remove background color codes', () => {
+            const text = chalk.bgRed('Text with red background');
+            expect(removeAnsiCodes(text)).toBe('Text with red background');
+        });
+        it('should remove multiple background colors', () => {
+            const text = chalk.bgBlue('Blue bg') + ' ' + chalk.bgYellow('Yellow bg');
+            expect(removeAnsiCodes(text)).toBe('Blue bg Yellow bg');
+        });
+    });
+    describe('text formatting', () => {
+        it('should remove bold formatting', () => {
+            const text = chalk.bold('Bold text');
+            expect(removeAnsiCodes(text)).toBe('Bold text');
+        });
+    });
+    describe('combined styles', () => {
+        it('should remove multiple formatting styles', () => {
+            const text = chalk.bold.red('Bold red text');
+            expect(removeAnsiCodes(text)).toBe('Bold red text');
+        });
+        it('should remove complex combinations', () => {
+            const text = chalk.bold.underline.red.bgYellow('Complex styling');
+            expect(removeAnsiCodes(text)).toBe('Complex styling');
+        });
+        it('should handle chained styles', () => {
+            const text = chalk.red('Red') + chalk.green(' Green') + chalk.blue(' Blue');
+            expect(removeAnsiCodes(text)).toBe('Red Green Blue');
+        });
+    });
+    describe('multiline text', () => {
+        it('should remove ANSI codes from multiline text', () => {
+            const text = chalk.red('Line 1\n') + chalk.green('Line 2\n') + chalk.blue('Line 3');
+            const expected = 'Line 1\nLine 2\nLine 3';
+            expect(removeAnsiCodes(text)).toBe(expected);
+        });
+        it('should handle mixed formatted and plain lines', () => {
+            const text = chalk.bold('Formatted line\n') +
+                'Plain line\n' +
+                chalk.italic('Another formatted line');
+            const expected = 'Formatted line\nPlain line\nAnother formatted line';
+            expect(removeAnsiCodes(text)).toBe(expected);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle text with only ANSI codes (no visible text)', () => {
+            const text = chalk.red('');
+            expect(removeAnsiCodes(text)).toBe('');
+        });
+        it('should handle multiple consecutive ANSI codes', () => {
+            // Create text with multiple style applications
+            const text = chalk.red(chalk.bold(chalk.underline('Heavily styled')));
+            expect(removeAnsiCodes(text)).toBe('Heavily styled');
+        });
+        it('should handle mixed content with spaces and special characters', () => {
+            const text = chalk.green('Success:') + ' ' + chalk.red('Error!') + ' @#$%^&*()';
+            expect(removeAnsiCodes(text)).toBe('Success: Error! @#$%^&*()');
+        });
+        it('should handle text with tabs and newlines', () => {
+            const text = chalk.yellow('\tTabbed text\n') + chalk.cyan('New line text');
+            expect(removeAnsiCodes(text)).toBe('\tTabbed text\nNew line text');
+        });
+    });
+});

package/lib/ui/index.js

@@ -65,16 +65,13 @@ export function uiCommandReference(command, withQuotes = true) {
 }
 export function uiFeatureHighlight(features, title) {
     uiInfoSection(title ? title : i18n(`lib.ui.featureHighlight.defaultTitle`), () => {
-        features.forEach((c, i) => {
-            const featureKey = `lib.ui.featureHighlight.featureKeys.${c}`;
+        features.forEach(feature => {
+            const featureKey = `lib.ui.featureHighlight.featureKeys.${feature}`;
             const message = i18n(`${featureKey}.message`, {
                 command: uiCommandReference(i18n(`${featureKey}.command`)),
                 link: uiLink(i18n(`${featureKey}.linkText`), i18n(`${featureKey}.url`)),
             });
-            if (i !== 0) {
-                logger.log('');
-            }
-            logger.log(message);
+            logger.log(`  - ${message}`);
         });
     });
 }

package/lib/ui/removeAnsiCodes.d.ts

@@ -0,0 +1 @@
+export declare function removeAnsiCodes(str: string): string;

package/lib/ui/removeAnsiCodes.js

@@ -0,0 +1,4 @@
+const ANSI_CODE_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+export function removeAnsiCodes(str) {
+    return str.replace(ANSI_CODE_REGEX, '');
+}

package/mcp-server/server.js

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { registerProjectTools } from './tools/index.js';
+import { registerProjectTools, registerCmsTools } from './tools/index.js';
 const server = new McpServer({
     name: 'HubSpot CLI MCP Server',
     version: '0.0.1',
@@ -11,6 +11,7 @@ const server = new McpServer({
     },
 });
 registerProjectTools(server);
+registerCmsTools(server);
 // Start receiving messages on stdin and sending messages on stdout
 const transport = new StdioServerTransport();
 server.connect(transport);

package/mcp-server/tools/cms/HsListTool.d.ts

@@ -0,0 +1,23 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    path?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    path?: string | undefined;
+}>;
+export type HsListInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsListTool extends Tool<HsListInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ path, account, absoluteCurrentWorkingDirectory, }: HsListInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

package/mcp-server/tools/cms/HsListTool.js

@@ -0,0 +1,58 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { addFlag } from '../../utils/command.js';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    path: z
+        .string()
+        .describe('The remote directory path in the HubSpot CMS to list contents. If not specified, lists the root directory.')
+        .optional(),
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'list-hubspot-cms-remote-contents';
+export class HsListTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ path, account, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        let command = 'hs list';
+        if (path) {
+            command += ` ${path}`;
+        }
+        if (account) {
+            command = addFlag(command, 'account', account);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing hs list command: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'List HubSpot CMS Directory Contents',
+            description: 'List remote contents of a HubSpot CMS directory.',
+            inputSchema,
+        }, this.handler);
+    }
+}

package/mcp-server/tools/cms/__tests__/HsListTool.test.d.ts

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

package/mcp-server/tools/cms/__tests__/HsListTool.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsListTool } from '../HsListTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../utils/toolUsageTracking', () => ({
+    trackToolUsage: vi.fn(),
+}));
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('HsListTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new HsListTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-hubspot-cms-remote-contents', {
+                title: 'List HubSpot CMS Directory Contents',
+                description: 'List remote contents of a HubSpot CMS directory.',
+                inputSchema: expect.any(Object),
+            }, expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should execute hs list command with no parameters', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'file1.html\nfile2.js\nfolder/',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('file1.html\nfile2.js\nfolder/');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with path parameter', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'nested-file.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                path: '/my-modules',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list /my-modules');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('nested-file.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with account parameter', async () => {
+            mockAddFlag.mockReturnValue('hs list --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'account-specific-files.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs list', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('account-specific-files.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with both path and account parameters', async () => {
+            mockAddFlag.mockReturnValue('hs list /my-path --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'path-and-account-files.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                path: '/my-path',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs list /my-path', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list /my-path --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('path-and-account-files.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Command failed'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Error executing hs list command: Command failed');
+        });
+        it('should handle stderr output', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'file1.html',
+                stderr: 'Warning: Some warning message',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('file1.html');
+            expect(result.content[1].text).toContain('Warning: Some warning message');
+        });
+    });
+});

package/mcp-server/tools/index.d.ts

@@ -1,2 +1,3 @@
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerProjectTools(mcpServer: McpServer): RegisteredTool[];
+export declare function registerCmsTools(mcpServer: McpServer): RegisteredTool[];

package/mcp-server/tools/index.js

@@ -5,6 +5,9 @@ import { DeployProjectTool } from './project/DeployProjectTool.js';
 import { AddFeatureToProjectTool } from './project/AddFeatureToProjectTool.js';
 import { ValidateProjectTool } from './project/ValidateProjectTool.js';
 import { GetConfigValuesTool } from './project/GetConfigValuesTool.js';
+import { DocsSearchTool } from './project/DocsSearchTool.js';
+import { DocFetchTool } from './project/DocFetchTool.js';
+import { HsListTool } from './cms/HsListTool.js';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
@@ -14,5 +17,10 @@ export function registerProjectTools(mcpServer) {
         new AddFeatureToProjectTool(mcpServer).register(),
         new ValidateProjectTool(mcpServer).register(),
         new GetConfigValuesTool(mcpServer).register(),
+        new DocsSearchTool(mcpServer).register(),
+        new DocFetchTool(mcpServer).register(),
     ];
 }
+export function registerCmsTools(mcpServer) {
+    return [new HsListTool(mcpServer).register()];
+}

package/mcp-server/tools/project/DocFetchTool.d.ts

@@ -0,0 +1,17 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    docUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docUrl: string;
+}, {
+    docUrl: string;
+}>;
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocFetchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docUrl }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,49 @@
+import z from 'zod';
+import { Tool } from '../../types.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { docUrl } from './constants.js';
+import { http } from '@hubspot/local-dev-lib/http/unauthed';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+const inputSchema = {
+    docUrl,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'fetch-hubspot-doc';
+export class DocFetchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docUrl }) {
+        await trackToolUsage(toolName);
+        try {
+            // Append .md extension to the URL
+            const markdownUrl = `${docUrl}.md`;
+            const response = await http.get({
+                url: markdownUrl,
+            });
+            const content = response.data;
+            if (!content || content.trim().length === 0) {
+                return formatTextContents('Document is empty or contains no content.');
+            }
+            return formatTextContents(content);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error fetching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Fetch HubSpot Developer Documentation (single file)',
+            description: 'Always use this immediately after `search-hubspot-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.',
+            inputSchema,
+        }, this.handler);
+    }
+}

package/mcp-server/tools/project/DocsSearchTool.d.ts

@@ -0,0 +1,26 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    docsSearchQuery: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docsSearchQuery: string;
+}, {
+    docsSearchQuery: string;
+}>;
+export interface DocsSearchResponse {
+    results: {
+        title: string;
+        content: string;
+        description: string;
+        url: string;
+        score: number;
+    }[];
+}
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocsSearchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,62 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import z from 'zod';
+import { Tool } from '../../types.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { docsSearchQuery } from './constants.js';
+import { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+const inputSchema = {
+    docsSearchQuery,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'search-hubspot-docs';
+export class DocsSearchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docsSearchQuery, }) {
+        await trackToolUsage(toolName, { mode: docsSearchQuery });
+        loadConfig(getConfigPath());
+        const accountId = getAccountId();
+        if (!accountId) {
+            const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
+            return formatTextContents(authErrorMessage);
+        }
+        try {
+            const response = await http.post(accountId, {
+                url: 'dev/docs/llms/v1/docs-search',
+                data: {
+                    query: docsSearchQuery,
+                },
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return formatTextContents('No documentation found for your query.');
+            }
+            const formattedResults = results
+                .map(result => `**${result.title}**\n${result.description}\nURL: ${result.url}\nScore: ${result.score}\n\n${result.content}\n---\n`)
+                .join('\n');
+            const successMessage = `Found ${results.length} documentation results:\n\n${formattedResults}`;
+            return formatTextContents(successMessage);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle different status codes
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error searching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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-hubspot-doc`. Always follow this with a fetch to get the full, authoritative content before making plans or writing answers.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -2,7 +2,7 @@ import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { formatTextContents } from '../../utils/content.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
 import { useV3Api } from '../../../lib/projects/buildAndDeploy.js';
 const inputSchema = {
     platformVersion: z
@@ -16,7 +16,7 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({
     ...inputSchema,
 });
-const toolName = 'get-hubspot-project-feature-config-schema';
+const toolName = 'get-hubspot-feature-config-schema';
 export class GetConfigValuesTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
@@ -26,6 +26,7 @@ export class GetConfigValuesTool extends Tool {
             if (!useV3Api(platformVersion)) {
                 return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
             }
+            loadConfig(getConfigPath());
             const schema = await getIntermediateRepresentationSchema({
                 platformVersion,
                 projectSourceDir: '',

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

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