@hubspot/cli 7.6.0-beta.1 → 7.6.0-beta.11

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-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__/GuidedWalkthroughTool.test.d.ts

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

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

@@ -0,0 +1,126 @@
+import { GuidedWalkthroughTool } from '../GuidedWalkthroughTool.js';
+import { execAsync } from '../../../utils/command.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/command');
+vi.mock('../../../utils/toolUsageTracking');
+const mockExecAsync = 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(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 {};

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

@@ -0,0 +1,107 @@
+import { UploadProjectTools } from '../UploadProjectTools.js';
+import { runCommandInDir } from '../../../utils/project.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/toolUsageTracking');
+const mockRunCommandInDir = runCommandInDir;
+describe('mcp-server/tools/project/UploadProjectTools', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error noy mocking whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new UploadProjectTools(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('upload-hubspot-project', {
+                title: 'Upload HubSpot Project',
+                description: expect.stringContaining('Uploads the HubSpot project in current working directory.'),
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            absoluteProjectPath: '/test/project',
+        };
+        it('should upload project successfully', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project uploaded successfully',
+                stderr: '',
+            });
+            const result = await tool.handler(input);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project upload --force-create');
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Project uploaded successfully' },
+                    { type: 'text', text: '' },
+                ],
+            });
+        });
+        it('should handle upload with warnings', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project uploaded with warnings',
+                stderr: 'Warning: some files were ignored',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'Project uploaded with warnings' },
+                { type: 'text', text: 'Warning: some files were ignored' },
+            ]);
+        });
+        it('should handle upload errors', async () => {
+            const error = new Error('Upload failed');
+            mockRunCommandInDir.mockRejectedValue(error);
+            await expect(tool.handler(input)).rejects.toThrow('Upload failed');
+        });
+        it('should use force-create flag', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project created and uploaded',
+                stderr: '',
+            });
+            await tool.handler(input);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project upload --force-create');
+        });
+        it('should handle empty stdout and stderr', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: '' },
+                { type: 'text', text: '' },
+            ]);
+        });
+        it('should work with different project paths', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Upload complete',
+                stderr: '',
+            });
+            const differentInput = {
+                absoluteProjectPath: '/different/path/to/project',
+            };
+            await tool.handler(differentInput);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', 'hs project upload --force-create');
+        });
+        it('should handle very long output', async () => {
+            const longOutput = 'A'.repeat(10000);
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: longOutput,
+                stderr: 'Long stderr output',
+            });
+            const result = await tool.handler(input);
+            expect(result.content[0].text).toBe(longOutput);
+            expect(result.content[1].text).toBe('Long stderr output');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,110 @@
+import { ValidateProjectTool, } from '../ValidateProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/toolUsageTracking');
+const mockRunCommandInDir = runCommandInDir;
+describe('mcp-server/tools/project/ValidateProjectTool', () => {
+    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 ValidateProjectTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('validate-hubspot-project', {
+                title: expect.stringContaining('Validate HubSpot Project'),
+                description: expect.stringContaining('Validates the HubSpot project and its configuration files.'),
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            absoluteProjectPath: '/test/project',
+        };
+        it('should validate project successfully', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project validation successful',
+                stderr: '',
+            });
+            const result = await tool.handler(input);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project validate');
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Project validation successful' },
+                    { type: 'text', text: '' },
+                ],
+            });
+        });
+        it('should handle validation with warnings', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project is valid',
+                stderr: 'Warning: some files may need updates',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'Project is valid' },
+                { type: 'text', text: 'Warning: some files may need updates' },
+            ]);
+        });
+        it('should handle validation errors', async () => {
+            const error = new Error('Validation failed');
+            mockRunCommandInDir.mockRejectedValue(error);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'Validation failed' }],
+            });
+        });
+        it('should handle non-Error rejection', async () => {
+            mockRunCommandInDir.mockRejectedValue('String error');
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'String error' }],
+            });
+        });
+        it('should handle empty stdout and stderr', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'stdout',
+                stderr: 'stderr',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'stdout' },
+                { type: 'text', text: 'stderr' },
+            ]);
+        });
+        it('should work with different project paths', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Validation complete',
+                stderr: '',
+            });
+            const differentInput = {
+                absoluteProjectPath: '/different/path/to/project',
+            };
+            await tool.handler(differentInput);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', 'hs project validate');
+        });
+        it('should handle validation errors with stderr', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '',
+                stderr: 'Error: Missing required configuration file',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: '' },
+                { type: 'text', text: 'Error: Missing required configuration file' },
+            ]);
+        });
+    });
+});

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

@@ -1,3 +1,6 @@
 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">>;
+export declare const docsSearchQuery: z.ZodString;
+export declare const docUrl: z.ZodString;

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

@@ -1,13 +1,24 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.absoluteCurrentWorkingDirectory = exports.absoluteProjectPath = void 0;
-const zod_1 = __importDefault(require("zod"));
-exports.absoluteProjectPath = zod_1.default
+import z from 'zod';
+export const absoluteProjectPath = z
     .string()
     .describe('The absolute path to the project directory.');
-exports.absoluteCurrentWorkingDirectory = zod_1.default
+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();
+export const docsSearchQuery = z
+    .string()
+    .describe('The query to search the HubSpot Developer Documentation for.');
+export const docUrl = z
+    .string()
+    .describe('The URL of the HubSpot Developer Documentation to fetch.');

package/mcp-server/types.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tool = void 0;
-class Tool {
+export class Tool {
     mcpServer;
     constructor(mcpServer) {
         this.mcpServer = mcpServer;
@@ -14,4 +11,3 @@ class Tool {
         throw new Error('Must implement handler');
     }
 }
-exports.Tool = Tool;

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

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

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

@@ -0,0 +1,45 @@
+import { addFlag } from '../command.js';
+vi.mock('child_process');
+vi.mock('util');
+describe('mcp-server/utils/command', () => {
+    describe('addFlag', () => {
+        it('should add string flag to command', () => {
+            const result = addFlag('hs project create', 'name', 'test-project');
+            expect(result).toBe('hs project create --name "test-project"');
+        });
+        it('should add number flag to command', () => {
+            const result = addFlag('hs project deploy', 'build', 123);
+            expect(result).toBe('hs project deploy --build "123"');
+        });
+        it('should add boolean flag to command', () => {
+            const result = addFlag('hs project upload', 'watch', true);
+            expect(result).toBe('hs project upload --watch "true"');
+        });
+        it('should add array flag to command', () => {
+            const result = addFlag('hs project create', 'features', [
+                'card',
+                'settings',
+            ]);
+            expect(result).toBe('hs project create --features "card" "settings"');
+        });
+        it('should handle empty array', () => {
+            const result = addFlag('hs project create', 'features', []);
+            expect(result).toBe('hs project create --features ');
+        });
+        it('should handle array with one item', () => {
+            const result = addFlag('hs project create', 'features', ['card']);
+            expect(result).toBe('hs project create --features "card"');
+        });
+        it('should handle special characters in string values', () => {
+            const result = addFlag('hs project create', 'name', 'my-project with spaces');
+            expect(result).toBe('hs project create --name "my-project with spaces"');
+        });
+        it('should handle special characters in array values', () => {
+            const result = addFlag('hs project create', 'features', [
+                'card with spaces',
+                'settings',
+            ]);
+            expect(result).toBe('hs project create --features "card with spaces" "settings"');
+        });
+    });
+});

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

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