@hubspot/cli 7.7.22-experimental.0 → 7.7.24-experimental.0

package/lib/ui/index.d.ts

@@ -1,9 +1,14 @@
+type TerminalSupport = {
+    hyperlinks: boolean;
+    color: boolean;
+};
 export declare const UI_COLORS: {
     SORBET: string;
     MARIGOLD: string;
     MARIGOLD_DARK: string;
 };
 export declare function uiLine(): void;
+export declare function getTerminalUISupport(): TerminalSupport;
 export declare function uiLink(linkText: string, url: string): string;
 export declare function uiAccountDescription(accountId?: number | null, bold?: boolean): string;
 export declare function uiInfoSection(title: string, logContent: () => void): void;
@@ -17,3 +22,4 @@ export declare function uiCommandDisabledBanner(command: string, url?: string, m
 export declare function uiDeprecatedDescription(message: string, command: string, url?: string): undefined;
 export declare function uiDeprecatedMessage(command: string, url?: string, message?: string): void;
 export declare function indent(level: number): string;
+export {};

package/lib/ui/index.js

@@ -13,7 +13,7 @@ export const UI_COLORS = {
 export function uiLine() {
     logger.log('-'.repeat(50));
 }
-function getTerminalUISupport() {
+export function getTerminalUISupport() {
     return {
         hyperlinks: supportsHyperlinkModule.stdout,
         color: supportsColor.stdout.hasBasic,
@@ -79,9 +79,8 @@ export function uiFeatureHighlight(features, title) {
     });
 }
 export function uiBetaTag(message, log = true) {
-    const terminalUISupport = getTerminalUISupport();
     const tag = i18n(`lib.ui.betaTag`);
-    const result = `${terminalUISupport.color ? chalk.hex(UI_COLORS.SORBET)(tag) : tag} ${message}`;
+    const result = `${tag} ${message}`;
     if (log) {
         logger.log(result);
         return;
@@ -89,9 +88,8 @@ export function uiBetaTag(message, log = true) {
     return result;
 }
 export function uiDeprecatedTag(message, log = true) {
-    const terminalUISupport = getTerminalUISupport();
     const tag = i18n(`lib.ui.deprecatedTag`);
-    const result = `${terminalUISupport.color ? chalk.yellow(tag) : tag} ${message}`;
+    const result = `${tag} ${message}`;
     if (log) {
         logger.log(result);
         return;

package/lib/yargsUtils.d.ts

@@ -13,3 +13,4 @@ export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>,
     };
     useJSONOutputOptions?: boolean;
 }): (yargs: Argv) => Promise<Argv<T>>;
+export declare function getExclusiveConflicts(options: string[]): Record<string, string[]>;

package/lib/yargsUtils.js

@@ -34,3 +34,9 @@ export function makeYargsBuilder(callback, command, describe, options = {}) {
         return result;
     };
 }
+export function getExclusiveConflicts(options) {
+    return options.reduce((acc, curr) => {
+        acc[curr] = options.filter(s => s !== curr);
+        return acc;
+    }, {});
+}

package/mcp-server/tools/index.js

@@ -1,16 +1,18 @@
 import { UploadProjectTools } from './project/UploadProjectTools.js';
 import { CreateProjectTool } from './project/CreateProjectTool.js';
 import { GuidedWalkthroughTool } from './project/GuidedWalkthroughTool.js';
-import { DeployProject } from './project/DeployProject.js';
-import { AddFeatureToProject } from './project/AddFeatureToProject.js';
+import { DeployProjectTool } from './project/DeployProjectTool.js';
+import { AddFeatureToProjectTool } from './project/AddFeatureToProjectTool.js';
 import { ValidateProjectTool } from './project/ValidateProjectTool.js';
+import { GetConfigValuesTool } from './project/GetConfigValuesTool.js';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
         new CreateProjectTool(mcpServer).register(),
         new GuidedWalkthroughTool(mcpServer).register(),
-        new DeployProject(mcpServer).register(),
-        new AddFeatureToProject(mcpServer).register(),
+        new DeployProjectTool(mcpServer).register(),
+        new AddFeatureToProjectTool(mcpServer).register(),
         new ValidateProjectTool(mcpServer).register(),
+        new GetConfigValuesTool(mcpServer).register(),
     ];
 }

package/mcp-server/tools/project/{AddFeatureToProject.d.ts → AddFeatureToProjectTool.d.ts}

@@ -6,22 +6,22 @@ declare const inputSchemaZodObject: z.ZodObject<{
     addApp: z.ZodBoolean;
     distribution: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"marketplace">, z.ZodLiteral<"private">]>>;
     auth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"static">, z.ZodLiteral<"oauth">]>>;
-    features: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">]>, "many">>;
+    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">>;
 }, "strip", z.ZodTypeAny, {
     absoluteProjectPath: string;
     addApp: boolean;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
+    features?: ("card" | "settings" | "app-function" | "webhooks" | "workflow-action")[] | undefined;
 }, {
     absoluteProjectPath: string;
     addApp: boolean;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
+    features?: ("card" | "settings" | "app-function" | "webhooks" | "workflow-action")[] | undefined;
 }>;
 export type AddFeatureInputSchema = z.infer<typeof inputSchemaZodObject>;
-export declare class AddFeatureToProject extends Tool<AddFeatureInputSchema> {
+export declare class AddFeatureToProjectTool extends Tool<AddFeatureInputSchema> {
     constructor(mcpServer: McpServer);
     handler({ absoluteProjectPath, distribution, auth, features, addApp, }: AddFeatureInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;

package/mcp-server/tools/project/{AddFeatureToProject.js → AddFeatureToProjectTool.js}

@@ -2,8 +2,8 @@ import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../lib/constants.js';
 import { addFlag } from '../../utils/command.js';
-import { absoluteProjectPath } from './constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { absoluteProjectPath, features } from './constants.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {
@@ -23,23 +23,14 @@ const inputSchema = {
         z.literal(APP_AUTH_TYPES.OAUTH),
     ]))
         .describe('Static uses a static non changing authentication token, and is only available for private distribution. If not specified by the user, do not choose for them.  This cannot be changed after a project is uploaded.'),
-    features: z
-        .array(z
-        .union([
-        z.literal('card'),
-        z.literal('settings'),
-        z.literal('app-function'),
-        z.literal('webhooks'),
-    ])
-        .describe('The features to include in the project, multiple options can be selected'))
-        .optional(),
+    features,
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({
     ...inputSchema,
 });
 const toolName = 'add-feature-to-hubspot-project';
-export class AddFeatureToProject extends Tool {
+export class AddFeatureToProjectTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
@@ -77,7 +68,8 @@ export class AddFeatureToProject extends Tool {
     register() {
         return this.mcpServer.registerTool(toolName, {
             title: 'Add feature to HubSpot Project',
-            description: 'Adds a feature to an existing HubSpot project',
+            description: `Adds a feature to an existing HubSpot project. 
+          Only works for projects with platformVersion '2025.2' and beyond`,
             inputSchema,
         }, this.handler);
     }

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

@@ -8,7 +8,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     projectBase: z.ZodUnion<[z.ZodLiteral<"empty">, z.ZodLiteral<"app">]>;
     distribution: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"marketplace">, z.ZodLiteral<"private">]>>;
     auth: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"static">, z.ZodLiteral<"oauth">]>>>;
-    features: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">]>, "many">>;
+    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">>;
 }, "strip", z.ZodTypeAny, {
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
@@ -16,7 +16,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     name?: string | undefined;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
+    features?: ("card" | "settings" | "app-function" | "webhooks" | "workflow-action")[] | undefined;
 }, {
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
@@ -24,7 +24,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     name?: string | undefined;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
+    features?: ("card" | "settings" | "app-function" | "webhooks" | "workflow-action")[] | undefined;
 }>;
 export type CreateProjectInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class CreateProjectTool extends Tool<CreateProjectInputSchema> {

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

@@ -1,10 +1,9 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
-import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../lib/constants.js';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../lib/constants.js';
 import { addFlag } from '../../utils/command.js';
-import { EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../lib/projects/create/v3.js';
-import { absoluteCurrentWorkingDirectory } from './constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { absoluteCurrentWorkingDirectory, features } from './constants.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {
@@ -32,16 +31,7 @@ const inputSchema = {
     ]))
         .describe('Static uses a static non changing authentication token, and is only available for private distribution. If not specified by the user, do not choose for them.  This cannot be changed after a project is uploaded.')
         .optional(),
-    features: z
-        .array(z
-        .union([
-        z.literal('card'),
-        z.literal('settings'),
-        z.literal('app-function'),
-        z.literal('webhooks'),
-    ])
-        .describe('The features to include in the project, multiple options can be selected'))
-        .optional(),
+    features,
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });

package/mcp-server/tools/project/{DeployProject.d.ts → DeployProjectTool.d.ts}

@@ -12,7 +12,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     buildNumber?: number | undefined;
 }>;
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
-export declare class DeployProject extends Tool<InputSchemaType> {
+export declare class DeployProjectTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
     handler({ absoluteProjectPath, buildNumber, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;

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

@@ -2,7 +2,7 @@ import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { addFlag } from '../../utils/command.js';
 import { absoluteProjectPath } from './constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {
@@ -16,7 +16,7 @@ const inputSchemaZodObject = z.object({
     ...inputSchema,
 });
 const toolName = 'deploy-hubspot-project';
-export class DeployProject extends Tool {
+export class DeployProjectTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }

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

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

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

@@ -0,0 +1,51 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { formatTextContents } from '../../utils/content.js';
+import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { useV3Api } from '../../../lib/projects/buildAndDeploy.js';
+const inputSchema = {
+    platformVersion: z
+        .string()
+        .describe('The platform version for the project. Located in the hsproject.json file.'),
+    featureType: z
+        .string()
+        .describe('The type of the component to fetch the JSON schema for. This will be the `type` field in the -hsmeta.json file'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'get-hubspot-project-feature-config-schema';
+export class GetConfigValuesTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ platformVersion, featureType, }) {
+        try {
+            if (!useV3Api(platformVersion)) {
+                return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
+            }
+            const schema = await getIntermediateRepresentationSchema({
+                platformVersion,
+                projectSourceDir: '',
+                accountId: getAccountId(),
+            });
+            const internalComponentType = mapToInternalType(featureType);
+            if (schema[internalComponentType]) {
+                return formatTextContents(JSON.stringify({ config: schema[internalComponentType] }));
+            }
+        }
+        catch (error) { }
+        return formatTextContents(`Unable to locate JSON schema for type ${featureType}`);
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Fetch the JSON Schema for component',
+            description: `Fetches and returns the JSON schema for the provided feature 'type' found in -hsmeta.json file. 
+        This should be called before editing a '-hsmeta.json' file to get the list of possible values and restrictions on those values.    
+        This will only work for projects with platformVersion 2025.2 and beyond`,
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -1,5 +1,5 @@
 import { Tool } from '../../types.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { absoluteProjectPath } from './constants.js';
 import z from 'zod';
 import { formatTextContents } from '../../utils/content.js';

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

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteProjectPath } from './constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {

package/mcp-server/tools/project/__tests__/{AddFeatureToProject.test.js → AddFeatureToProjectTool.test.js}

@@ -1,9 +1,9 @@
-import { AddFeatureToProject, } from '../AddFeatureToProject.js';
-import { runCommandInDir } from '../../../utils/project.js';
+import { AddFeatureToProjectTool, } from '../AddFeatureToProjectTool.js';
+import { runCommandInDir } from '../../../utils/command.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('../../../utils/command');
 vi.mock('../../../../lib/constants');
 vi.mock('../../../utils/toolUsageTracking');
@@ -21,18 +21,18 @@ describe('mcp-server/tools/project/AddFeatureToProject', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new AddFeatureToProject(mockMcpServer);
+        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-hubspot-project', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('add-feature-to-hubspot-project', expect.objectContaining({
                 title: 'Add feature to HubSpot Project',
-                description: 'Adds a feature to an existing HubSpot project',
+                description: expect.stringContaining('Adds a feature to an existing HubSpot project'),
                 inputSchema: expect.any(Object),
-            }, tool.handler);
+            }), tool.handler);
             expect(result).toBe(mockRegisteredTool);
         });
     });

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', () => {