@hubspot/cli 7.7.19-experimental.3 → 7.7.20-experimental.0

package/lib/yargsUtils.d.ts

@@ -1,5 +1,6 @@
 import { Argv } from 'yargs';
-export declare function hasFlag(flag: string, argv?: string[]): boolean;
+import { hasFlag } from './utils/hasFlag';
+export { hasFlag };
 export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
     useGlobalOptions?: boolean;
     useAccountOptions?: boolean;

package/lib/yargsUtils.js

@@ -1,20 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasFlag = hasFlag;
+exports.hasFlag = void 0;
 exports.makeYargsBuilder = makeYargsBuilder;
-const process_1 = __importDefault(require("process"));
 const commonOpts_1 = require("./commonOpts");
-// See https://github.com/sindresorhus/has-flag/blob/main/index.js (License: https://github.com/sindresorhus/has-flag/blob/main/license)
-function hasFlag(flag, argv = process_1.default.argv) {
-    const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
-    const position = argv.indexOf(prefix + flag);
-    const terminatorPosition = argv.indexOf('--');
-    return (position !== -1 &&
-        (terminatorPosition === -1 || position < terminatorPosition));
-}
+const hasFlag_1 = require("./utils/hasFlag");
+Object.defineProperty(exports, "hasFlag", { enumerable: true, get: function () { return hasFlag_1.hasFlag; } });
 function makeYargsBuilder(callback, command, describe, options = {}) {
     return async function (yargs) {
         if (options.useGlobalOptions) {

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

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

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AddFeatureToProject_1 = require("../AddFeatureToProject");
+const project_1 = require("../../../utils/project");
+const command_1 = require("../../../utils/command");
+const constants_1 = require("../../../../lib/constants");
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../../lib/constants');
+const mockRunCommandInDir = project_1.runCommandInDir;
+const mockAddFlag = command_1.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 AddFeatureToProject_1.AddFeatureToProject(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-hubspot-project', {
+                title: 'Add feature to HubSpot Project',
+                description: '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: constants_1.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: constants_1.APP_DISTRIBUTION_TYPES.MARKETPLACE,
+                auth: constants_1.APP_AUTH_TYPES.OAUTH,
+                features: ['webhooks'],
+            };
+            await tool.handler(input);
+            expect(mockAddFlag).toHaveBeenCalledWith('hs project add', 'distribution', constants_1.APP_DISTRIBUTION_TYPES.MARKETPLACE);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'auth', constants_1.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,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CreateProjectTool_1 = require("../CreateProjectTool");
+const project_1 = require("../../../utils/project");
+const command_1 = require("../../../utils/command");
+const constants_1 = require("../../../../lib/constants");
+const v3_1 = require("../../../../lib/projects/create/v3");
+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');
+const mockRunCommandInDir = project_1.runCommandInDir;
+const mockAddFlag = command_1.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_1.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-hubspot-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: v3_1.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', v3_1.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: v3_1.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: v3_1.PROJECT_WITH_APP,
+                distribution: constants_1.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__/DeployProject.test.d.ts

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

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DeployProject_1 = require("../DeployProject");
+const project_1 = require("../../../utils/project");
+const command_1 = require("../../../utils/command");
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+const mockRunCommandInDir = project_1.runCommandInDir;
+const mockAddFlag = command_1.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 DeployProject_1.DeployProject(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-hubspot-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__/GuidedWalkthroughTool.test.d.ts

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

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const GuidedWalkthroughTool_1 = require("../GuidedWalkthroughTool");
+const command_1 = require("../../../utils/command");
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/command');
+const mockExecAsync = command_1.execAsync;
+describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new GuidedWalkthroughTool_1.GuidedWalkthroughTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('guided-walkthrough-hubspot-cli', {
+                title: 'Guided walkthrough of the CLI',
+                description: 'Give the user a guided walkthrough of the HubSpot CLI.',
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should show help for hs init command', async () => {
+            const helpOutput = 'Usage: hs init [options]\nInitialize HubSpot CLI';
+            mockExecAsync.mockResolvedValue({
+                stdout: helpOutput,
+                stderr: '',
+            });
+            const result = await tool.handler({ command: 'hs init' });
+            expect(mockExecAsync).toHaveBeenCalledWith('hs init --help');
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain(helpOutput);
+            expect(result.content[0].text).toContain('hs auth');
+        });
+        it('should show help for hs auth command', async () => {
+            const helpOutput = 'Usage: hs auth [options]\nAuthenticate with HubSpot';
+            mockExecAsync.mockResolvedValue({
+                stdout: helpOutput,
+                stderr: '',
+            });
+            const result = await tool.handler({ 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');
+        });
+        it('should show help for hs project create command', async () => {
+            const helpOutput = 'Usage: hs project create [options]\nCreate a new project';
+            mockExecAsync.mockResolvedValue({
+                stdout: helpOutput,
+                stderr: '',
+            });
+            const result = await tool.handler({ 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');
+        });
+        it('should show help for hs project upload command', async () => {
+            const helpOutput = 'Usage: hs project upload [options]\nUpload project to HubSpot';
+            mockExecAsync.mockResolvedValue({
+                stdout: helpOutput,
+                stderr: '',
+            });
+            const result = await tool.handler({ 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');
+        });
+        it('should handle command without next step', async () => {
+            const helpOutput = 'Usage: hs project dev [options]\nStart development server';
+            mockExecAsync.mockResolvedValue({
+                stdout: helpOutput,
+                stderr: '',
+            });
+            // Test with a command that doesn't have a next command
+            const result = await tool.handler({ 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({});
+            expect(mockExecAsync).not.toHaveBeenCalled();
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: 'Is there another command you would like to learn more about?',
+                },
+            ]);
+        });
+        it('should handle undefined command', async () => {
+            const result = await tool.handler({ command: undefined });
+            expect(mockExecAsync).not.toHaveBeenCalled();
+            expect(result.content).toEqual([
+                {
+                    type: 'text',
+                    text: 'Is there another command you would like to learn more about?',
+                },
+            ]);
+        });
+        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');
+        });
+        it('should format help text with proper instructions', async () => {
+            const helpOutput = 'Usage: hs init\nOptions:\n  --help  Show help';
+            mockExecAsync.mockResolvedValue({
+                stdout: helpOutput,
+                stderr: '',
+            });
+            const result = await tool.handler({ 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.d.ts

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