@hubspot/cli 7.7.23-experimental.0 → 7.7.25-experimental.0

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

@@ -1,10 +1,9 @@
 import { CreateProjectTool, } from '../CreateProjectTool.js';
-import { runCommandInDir } from '../../../utils/project.js';
+import { runCommandInDir } from '../../../utils/command.js';
 import { addFlag } from '../../../utils/command.js';
-import { APP_DISTRIBUTION_TYPES } from '../../../../lib/constants.js';
-import { EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../../lib/projects/create/v3.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('../../../utils/command');
 vi.mock('../../../../lib/constants');
 vi.mock('../../../../lib/projects/create/v3');

package/mcp-server/tools/project/__tests__/{DeployProject.test.js → DeployProjectTool.test.js}

@@ -1,8 +1,8 @@
-import { DeployProject } from '../DeployProject.js';
-import { runCommandInDir } from '../../../utils/project.js';
+import { DeployProjectTool } from '../DeployProjectTool.js';
+import { runCommandInDir } from '../../../utils/command.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/command');
 vi.mock('../../../utils/toolUsageTracking');
 const mockRunCommandInDir = runCommandInDir;
@@ -19,7 +19,7 @@ describe('mcp-server/tools/project/DeployProject', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new DeployProject(mockMcpServer);
+        tool = new DeployProjectTool(mockMcpServer);
         // Mock addFlag to simulate command building
         mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
     });

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

@@ -0,0 +1,198 @@
+import { GetConfigValuesTool } from '../GetConfigValuesTool.js';
+import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/toolUsageTracking');
+const mockGetIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
+const mockMapToInternalType = mapToInternalType;
+const mockGetAccountId = getAccountId;
+describe('mcp-server/tools/project/GetConfigValuesTool', () => {
+    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 GetConfigValuesTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-hubspot-project-feature-config-schema', {
+                title: 'Fetch the JSON Schema for component',
+                description: expect.stringContaining('Fetches and returns the JSON schema for the provided feature'),
+                inputSchema: expect.objectContaining({
+                    platformVersion: expect.objectContaining({
+                        describe: expect.any(Function),
+                    }),
+                    featureType: expect.objectContaining({
+                        describe: expect.any(Function),
+                    }),
+                }),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            platformVersion: '2025.2',
+            featureType: 'card',
+        };
+        beforeEach(() => {
+            mockGetAccountId.mockReturnValue(123456789);
+        });
+        it('should return config schema when component type exists', async () => {
+            const mockSchema = {
+                'internal-card-type': {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string' },
+                        description: { type: 'string' },
+                    },
+                },
+            };
+            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
+            mockMapToInternalType.mockReturnValue('internal-card-type');
+            const result = await tool.handler(input);
+            expect(mockGetIntermediateRepresentationSchema).toHaveBeenCalledWith({
+                platformVersion: '2025.2',
+                projectSourceDir: '',
+                accountId: 123456789,
+            });
+            expect(mockMapToInternalType).toHaveBeenCalledWith('card');
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            config: {
+                                type: 'object',
+                                properties: {
+                                    title: { type: 'string' },
+                                    description: { type: 'string' },
+                                },
+                            },
+                        }),
+                    },
+                ],
+            });
+        });
+        it('should return error message when component type does not exist in schema', async () => {
+            const mockSchema = {
+                'other-type': {
+                    type: 'object',
+                    properties: {},
+                },
+            };
+            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
+            mockMapToInternalType.mockReturnValue('internal-card-type');
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Unable to locate JSON schema for type card',
+                    },
+                ],
+            });
+        });
+        it('should return error message when getIntermediateRepresentationSchema throws', async () => {
+            mockGetIntermediateRepresentationSchema.mockRejectedValue(new Error('Schema fetch failed'));
+            mockMapToInternalType.mockReturnValue('internal-card-type');
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Unable to locate JSON schema for type card',
+                    },
+                ],
+            });
+        });
+        it('should return error message when mapToInternalType throws', async () => {
+            const mockSchema = {};
+            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
+            mockMapToInternalType.mockImplementation(() => {
+                throw new Error('Mapping failed');
+            });
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Unable to locate JSON schema for type card',
+                    },
+                ],
+            });
+        });
+        it('should handle null account id', async () => {
+            mockGetAccountId.mockReturnValue(null);
+            mockGetIntermediateRepresentationSchema.mockRejectedValue(new Error('No account ID'));
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Unable to locate JSON schema for type card',
+                    },
+                ],
+            });
+        });
+        it('should handle empty schema object', async () => {
+            const mockSchema = {};
+            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
+            mockMapToInternalType.mockReturnValue('internal-card-type');
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Unable to locate JSON schema for type card',
+                    },
+                ],
+            });
+        });
+        it('should handle complex nested schema structures', async () => {
+            const complexSchema = {
+                'internal-card-type': {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', maxLength: 100 },
+                        metadata: {
+                            type: 'object',
+                            properties: {
+                                author: { type: 'string' },
+                                tags: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                },
+                            },
+                            required: ['author'],
+                        },
+                    },
+                    required: ['title'],
+                },
+            };
+            mockGetIntermediateRepresentationSchema.mockResolvedValue(complexSchema);
+            mockMapToInternalType.mockReturnValue('internal-card-type');
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            config: complexSchema['internal-card-type'],
+                        }),
+                    },
+                ],
+            });
+        });
+    });
+});

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

@@ -1,7 +1,7 @@
 import { UploadProjectTools } from '../UploadProjectTools.js';
-import { runCommandInDir } from '../../../utils/project.js';
+import { runCommandInDir } 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;
 describe('mcp-server/tools/project/UploadProjectTools', () => {

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

@@ -1,7 +1,7 @@
 import { ValidateProjectTool, } from '../ValidateProjectTool.js';
-import { runCommandInDir } from '../../../utils/project.js';
+import { runCommandInDir } 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;
 describe('mcp-server/tools/project/ValidateProjectTool', () => {

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

@@ -1,3 +1,4 @@
 import z from 'zod';
 export declare const absoluteProjectPath: z.ZodString;
 export declare const absoluteCurrentWorkingDirectory: z.ZodString;
+export declare const features: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">, z.ZodLiteral<"workflow-action">]>, "many">>;

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

@@ -5,3 +5,14 @@ export const absoluteProjectPath = z
 export const absoluteCurrentWorkingDirectory = z
     .string()
     .describe('The absolute path to the current working directory.');
+export const features = z
+    .array(z
+    .union([
+    z.literal('card'),
+    z.literal('settings'),
+    z.literal('app-function'),
+    z.literal('webhooks'),
+    z.literal('workflow-action'),
+])
+    .describe('The features to include in the project, multiple options can be selected'))
+    .optional();

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

@@ -1,7 +1,17 @@
-import { addFlag } from '../command.js';
-vi.mock('child_process');
-vi.mock('util');
+import { addFlag, runCommandInDir, execAsync } from '../command.js';
+import fs from 'fs';
+import path from 'path';
+vi.mock('../command');
+vi.mock('fs');
+vi.mock('path');
+const mockExecAsync = execAsync;
+const mockExistsSync = fs.existsSync;
+const mockMkdirSync = fs.mkdirSync;
+const mockResolve = path.resolve;
 describe('mcp-server/utils/command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
     describe('addFlag', () => {
         it('should add string flag to command', () => {
             const result = addFlag('hs project create', 'name', 'test-project');
@@ -42,4 +52,67 @@ describe('mcp-server/utils/command', () => {
             expect(result).toBe('hs project create --features "card with spaces" "settings"');
         });
     });
+    describe('runCommandInDir', () => {
+        const mockDirectory = '/test/directory';
+        const mockCommand = 'npm install';
+        const mockResolvedPath = '/resolved/test/directory';
+        beforeEach(() => {
+            mockResolve.mockReturnValue(mockResolvedPath);
+        });
+        it('should run command in existing directory', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).not.toHaveBeenCalled();
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should create directory if it does not exist', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(false);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should propagate execAsync errors', async () => {
+            const error = new Error('Command failed');
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockRejectedValue(error);
+            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should handle stderr in results', async () => {
+            const expectedResult = {
+                stdout: 'some output',
+                stderr: 'warning message',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(result.stdout).toBe('some output');
+            expect(result.stderr).toBe('warning message');
+        });
+    });
 });

package/mcp-server/utils/command.d.ts

@@ -1,3 +1,9 @@
 import { exec } from 'node:child_process';
+export interface CommandResults {
+    stderr: string;
+    stdout: string;
+}
 export declare const execAsync: typeof exec.__promisify__;
+export declare function wrapCommand(commandString: string): string;
 export declare function addFlag(command: string, flagName: string, value: string | number | boolean | string[]): string;
+export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/command.js

@@ -1,9 +1,28 @@
 import util from 'util';
 import { exec } from 'node:child_process';
+import path from 'path';
+import fs from 'fs';
 export const execAsync = util.promisify(exec);
+export function wrapCommand(commandString) {
+    if (process.env.HUBSPOT_MCP_STANDALONE_MODE) {
+        return `npx -y --package=@hubspot/cli@7.7.25-experimental.0 ${commandString}`;
+    }
+    return commandString;
+}
 export function addFlag(command, flagName, value) {
     if (Array.isArray(value)) {
         return `${command} --${flagName} ${value.map(item => `"${item}"`).join(' ')}`;
     }
     return `${command} --${flagName} "${value}"`;
 }
+export async function runCommandInDir(directory, command) {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory);
+    }
+    return execAsync(wrapCommand(command), {
+        cwd: path.resolve(directory),
+        env: {
+            ...process.env,
+        },
+    });
+}

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.7.23-experimental.0",
+    "version": "7.7.25-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "type": "module",
     "dependencies": {
         "@hubspot/local-dev-lib": "3.16.0",
-        "@hubspot/project-parsing-lib": "0.5.3",
+        "@hubspot/project-parsing-lib": "0.6.0",
         "@hubspot/serverless-dev-runtime": "7.0.6",
         "@hubspot/theme-preview-dev-server": "0.0.10",
         "@hubspot/ui-extensions-dev-server": "0.9.4",

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

@@ -1,79 +0,0 @@
-import { runCommandInDir } from '../project.js';
-import { execAsync } from '../command.js';
-import fs from 'fs';
-import path from 'path';
-vi.mock('../command');
-vi.mock('fs');
-vi.mock('path');
-const mockExecAsync = execAsync;
-const mockExistsSync = fs.existsSync;
-const mockMkdirSync = fs.mkdirSync;
-const mockResolve = path.resolve;
-describe('mcp-server/utils/project', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('runCommandInDir', () => {
-        const mockDirectory = '/test/directory';
-        const mockCommand = 'npm install';
-        const mockResolvedPath = '/resolved/test/directory';
-        beforeEach(() => {
-            mockResolve.mockReturnValue(mockResolvedPath);
-        });
-        it('should run command in existing directory', async () => {
-            const expectedResult = {
-                stdout: 'command output',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockMkdirSync).not.toHaveBeenCalled();
-            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            expect(result).toEqual(expectedResult);
-        });
-        it('should create directory if it does not exist', async () => {
-            const expectedResult = {
-                stdout: 'command output',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(false);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            expect(result).toEqual(expectedResult);
-        });
-        it('should propagate execAsync errors', async () => {
-            const error = new Error('Command failed');
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockRejectedValue(error);
-            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should handle stderr in results', async () => {
-            const expectedResult = {
-                stdout: 'some output',
-                stderr: 'warning message',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(result.stdout).toBe('some output');
-            expect(result.stderr).toBe('warning message');
-        });
-    });
-});

package/mcp-server/utils/project.d.ts

@@ -1,5 +0,0 @@
-export interface CommandResults {
-    stderr: string;
-    stdout: string;
-}
-export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/project.js

@@ -1,14 +0,0 @@
-import { execAsync } from './command.js';
-import path from 'path';
-import fs from 'fs';
-export async function runCommandInDir(directory, command) {
-    if (!fs.existsSync(directory)) {
-        fs.mkdirSync(directory);
-    }
-    return execAsync(command, {
-        cwd: path.resolve(directory),
-        env: {
-            ...process.env,
-        },
-    });
-}