@hubspot/cli 7.7.0-experimental.2 → 7.7.0

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

@@ -0,0 +1,57 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { execAsync } from '../../utils/command.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const nextCommands = {
+    'hs init': 'hs auth',
+    'hs auth': 'hs project create',
+    'hs project create': 'hs project upload',
+    'hs project upload': 'hs project dev',
+};
+const inputSchema = {
+    command: z
+        .union([
+        z.literal('hs init'),
+        z.literal('hs auth'),
+        z.literal('hs project create'),
+        z.literal('hs project upload'),
+    ])
+        .describe('The command to learn more about.  Start with `hs init`')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'guided-walkthrough-cli';
+export class GuidedWalkthroughTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ command }) {
+        await trackToolUsage(toolName);
+        if (command) {
+            const { stdout } = await execAsync(`${command} --help`);
+            return formatTextContents(`Display this help output for the user amd wait for them to acknowledge: ${stdout}. ${nextCommands[command] ? `Once they are ready, A good command to look at next is ${nextCommands[command]}` : ''}`);
+        }
+        return formatTextContents('Is there another command you would like to learn more about?');
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Guided walkthrough of the CLI',
+            description: 'Give the user a guided walkthrough of the HubSpot CLI.',
+            inputSchema: {
+                command: z
+                    .union([
+                    z.literal('hs init'),
+                    z.literal('hs auth'),
+                    z.literal('hs project create'),
+                    z.literal('hs project upload'),
+                ])
+                    .describe('The command to learn more about.  Start with `hs init`')
+                    .optional(),
+            },
+        }, this.handler);
+    }
+}

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

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

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

@@ -0,0 +1,31 @@
+import { Tool } from '../../types.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { absoluteProjectPath } from './constants.js';
+import z from 'zod';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteProjectPath,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'upload-project';
+export class UploadProjectTools extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteProjectPath, }) {
+        await trackToolUsage(toolName);
+        const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, `hs project upload --force-create`);
+        return formatTextContents(stdout, stderr);
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Upload HubSpot Project',
+            description: 'DO NOT run this tool unless the user specifies they would like to upload the project, it is potentially destructive. Uploads the HubSpot project in current working directory.  If the project does not exist, it will be created. MUST be ran from within the project directory.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { absoluteProjectPath } from './constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteProjectPath,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'validate-project';
+export class ValidateProjectTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteProjectPath, }) {
+        await trackToolUsage(toolName);
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, 'hs project validate');
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Validate HubSpot Project',
+            description: 'Validates the HubSpot project and its configuration files.  This tool does not need to be ran before uploading the project',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

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

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

@@ -0,0 +1,151 @@
+import { AddFeatureToProjectTool, } from '../AddFeatureToProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../../lib/constants.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../../lib/constants');
+vi.mock('../../../utils/toolUsageTracking');
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('mcp-server/tools/project/AddFeatureToProject', () => {
+    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 AddFeatureToProjectTool(mockMcpServer);
+        // Mock addFlag to simulate command building
+        mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('add-feature-to-project', expect.objectContaining({
+                title: 'Add feature to HubSpot Project',
+                description: expect.stringContaining('Adds a feature to an existing HubSpot project'),
+                inputSchema: expect.any(Object),
+            }), tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const baseInput = {
+            absoluteProjectPath: '/test/project',
+            addApp: false,
+        };
+        it('should handle successful command execution without app', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Feature added successfully',
+                stderr: '',
+            });
+            const result = await tool.handler(baseInput);
+            expect(mockAddFlag).toHaveBeenCalledWith('hs project add', 'features', []);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.any(String));
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Feature added successfully' },
+                    { type: 'text', text: '' },
+                ],
+            });
+        });
+        it('should handle successful command execution with features', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Features added successfully',
+                stderr: '',
+            });
+            const input = {
+                ...baseInput,
+                features: ['card', 'settings'],
+            };
+            await tool.handler(input);
+            expect(mockAddFlag).toHaveBeenCalledWith('hs project add', 'features', [
+                'card',
+                'settings',
+            ]);
+        });
+        it('should prompt for distribution and auth when adding app without both', async () => {
+            const input = {
+                ...baseInput,
+                addApp: true,
+            };
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: expect.stringContaining('Ask the user how they would you like to distribute the application'),
+                },
+                {
+                    type: 'text',
+                    text: expect.stringContaining('Ask the user which auth type they would like to use'),
+                },
+            ]);
+        });
+        it('should prompt for auth when adding app without auth', async () => {
+            const input = {
+                ...baseInput,
+                addApp: true,
+                distribution: APP_DISTRIBUTION_TYPES.PRIVATE,
+            };
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: expect.stringContaining('Ask the user which auth type they would like to use'),
+                },
+            ]);
+        });
+        it('should add distribution and auth flags when provided', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'App feature added',
+                stderr: '',
+            });
+            const input = {
+                ...baseInput,
+                addApp: true,
+                distribution: APP_DISTRIBUTION_TYPES.MARKETPLACE,
+                auth: APP_AUTH_TYPES.OAUTH,
+                features: ['webhooks'],
+            };
+            await tool.handler(input);
+            expect(mockAddFlag).toHaveBeenCalledWith('hs project add', 'distribution', APP_DISTRIBUTION_TYPES.MARKETPLACE);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'auth', APP_AUTH_TYPES.OAUTH);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'features', [
+                'webhooks',
+            ]);
+        });
+        it('should handle command execution error', async () => {
+            const error = new Error('Command failed');
+            mockRunCommandInDir.mockRejectedValue(error);
+            const result = await tool.handler(baseInput);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'Command failed' }],
+            });
+        });
+        it('should handle non-Error rejection', async () => {
+            mockRunCommandInDir.mockRejectedValue('String error');
+            const result = await tool.handler(baseInput);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'String error' }],
+            });
+        });
+        it('should handle stderr in results', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Success with warnings',
+                stderr: 'Warning: something happened',
+            });
+            const result = await tool.handler(baseInput);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'Success with warnings' },
+                { type: 'text', text: 'Warning: something happened' },
+            ]);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,127 @@
+import { CreateProjectTool, } from '../CreateProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../../lib/constants.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../../lib/constants');
+vi.mock('../../../../lib/projects/create/v3');
+vi.mock('../../../utils/toolUsageTracking');
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('mcp-server/tools/project/CreateProjectTool', () => {
+    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);
+        tool = new CreateProjectTool(mockMcpServer);
+        // Mock addFlag to simulate command building
+        mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-project', {
+                title: 'Create HubSpot Project',
+                description: 'Creates a HubSpot project with the provided name and outputs it in the provided destination',
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const baseInput = {
+            absoluteCurrentWorkingDirectory: '/test/workspace',
+            name: 'test-project',
+            destination: './test-dest',
+            projectBase: EMPTY_PROJECT,
+        };
+        it('should handle successful command execution', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler(baseInput);
+            expect(mockAddFlag).toHaveBeenCalledWith('hs project create', 'platform-version', '2025.2');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'name', 'test-project');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'dest', './test-dest');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'project-base', EMPTY_PROJECT);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', expect.any(String));
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Project created successfully' },
+                    { type: 'text', text: '' },
+                ],
+            });
+        });
+        it('should handle command execution error', async () => {
+            const error = new Error('Command failed');
+            mockRunCommandInDir.mockRejectedValue(error);
+            const result = await tool.handler(baseInput);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'Command failed' }],
+            });
+        });
+        it('should prompt for distribution and auth when creating app project without both', async () => {
+            const input = {
+                ...baseInput,
+                projectBase: PROJECT_WITH_APP,
+            };
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: expect.stringContaining('Ask the user how they would you like to distribute the application?'),
+                },
+                {
+                    type: 'text',
+                    text: expect.stringContaining('Ask the user which auth type they would like to use?'),
+                },
+            ]);
+        });
+        it('should prompt for auth when creating app project without auth', async () => {
+            const input = {
+                ...baseInput,
+                projectBase: PROJECT_WITH_APP,
+                distribution: APP_DISTRIBUTION_TYPES.PRIVATE,
+            };
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: expect.stringContaining('Ask the user which auth type they would like to use?'),
+                },
+            ]);
+        });
+        it('should add features flag when features are provided', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project created',
+                stderr: '',
+            });
+            const input = {
+                ...baseInput,
+                features: ['card', 'settings'],
+            };
+            await tool.handler(input);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'features', [
+                'card',
+                'settings',
+            ]);
+        });
+        it('should handle non-Error rejection', async () => {
+            mockRunCommandInDir.mockRejectedValue('String error');
+            const result = await tool.handler(baseInput);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'String error' }],
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,119 @@
+import { DeployProjectTool } from '../DeployProjectTool.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');
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('mcp-server/tools/project/DeployProject', () => {
+    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 DeployProjectTool(mockMcpServer);
+        // Mock addFlag to simulate command building
+        mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('deploy-project', {
+                title: 'Deploy a build of HubSpot Project',
+                description: expect.stringContaining('Takes a build number and a project name and deploys that build of the project'),
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const baseInput = {
+            absoluteProjectPath: '/test/project',
+        };
+        it('should deploy project with specified build number', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project deployed successfully',
+                stderr: '',
+            });
+            const input = {
+                ...baseInput,
+                buildNumber: 123,
+            };
+            const result = await tool.handler(input);
+            expect(mockAddFlag).toHaveBeenCalledWith('hs project deploy', 'build', 123);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--build "123"'));
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Project deployed successfully' },
+                    { type: 'text', text: '' },
+                ],
+            });
+        });
+        it('should prompt for build number when not provided', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Build 1: Created 2023-01-01\nBuild 2: Created 2023-01-02',
+                stderr: '',
+            });
+            const result = await tool.handler(baseInput);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project list-builds --limit 100');
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: expect.stringContaining('Ask the user which build number they would like to deploy?'),
+                },
+            ]);
+            expect(result.content[0].text).toContain('Build 1: Created 2023-01-01');
+        });
+        it('should handle deployment with stderr', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Deployed successfully',
+                stderr: 'Warning: deprecated feature used',
+            });
+            const input = {
+                ...baseInput,
+                buildNumber: 456,
+            };
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'Deployed successfully' },
+                { type: 'text', text: 'Warning: deprecated feature used' },
+            ]);
+        });
+        it('should handle errors during list-builds command', async () => {
+            const error = new Error('Failed to list builds');
+            mockRunCommandInDir.mockRejectedValue(error);
+            // The error would be thrown and caught by the calling code
+            await expect(tool.handler(baseInput)).rejects.toThrow('Failed to list builds');
+        });
+        it('should handle errors during deploy command', async () => {
+            const error = new Error('Deployment failed');
+            mockRunCommandInDir.mockRejectedValue(error);
+            const input = {
+                ...baseInput,
+                buildNumber: 789,
+            };
+            await expect(tool.handler(input)).rejects.toThrow('Deployment failed');
+        });
+        it('should prompt for build when buildNumber is 0 (falsy)', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Build 0: Initial build\nBuild 1: Latest build',
+                stderr: '',
+            });
+            const input = {
+                ...baseInput,
+                buildNumber: 0, // This is falsy, so it will prompt
+            };
+            const result = await tool.handler(input);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project list-builds --limit 100');
+            expect(result.content[0].text).toContain('Ask the user which build number they would like to deploy?');
+        });
+    });
+});

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

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