@hubspot/cli 7.10.0-beta.0 → 7.10.0-beta.1

package/mcp-server/tools/cms/HsCreateTemplateTool.js

@@ -70,6 +70,12 @@ export class HsCreateTemplateTool extends Tool {
             title: 'Create HubSpot CMS Template',
             description: `Creates a new HubSpot CMS template using the hs create template command. Templates can be created non-interactively by specifying templateType. Supports all template types including: ${TEMPLATE_TYPES.join(', ')}.`,
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

package/mcp-server/tools/cms/HsFunctionLogsTool.d.ts

@@ -12,16 +12,16 @@ declare const inputSchemaZodObject: z.ZodObject<{
     endpoint: string;
     absoluteCurrentWorkingDirectory: string;
     account?: string | undefined;
-    limit?: number | undefined;
-    compact?: boolean | undefined;
     latest?: boolean | undefined;
+    compact?: boolean | undefined;
+    limit?: number | undefined;
 }, {
     endpoint: string;
     absoluteCurrentWorkingDirectory: string;
     account?: string | undefined;
-    limit?: number | undefined;
-    compact?: boolean | undefined;
     latest?: boolean | undefined;
+    compact?: boolean | undefined;
+    limit?: number | undefined;
 }>;
 export type HsFunctionLogsInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsFunctionLogsTool extends Tool<HsFunctionLogsInputSchema> {

package/mcp-server/tools/cms/HsFunctionLogsTool.js

@@ -64,6 +64,10 @@ export class HsFunctionLogsTool extends Tool {
             title: 'Get HubSpot CMS serverless function logs for an endpoint',
             description: 'Retrieve logs for HubSpot CMS serverless functions. Use this tool to help debug issues with serverless functions by reading the production logs. Supports various options like latest, compact, and limiting results. Use after listing functions with list-cms-serverless-functions to get the endpoint path.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

package/mcp-server/tools/cms/HsListFunctionsTool.js

@@ -53,6 +53,10 @@ export class HsListFunctionsTool extends Tool {
             title: 'List HubSpot CMS Serverless Functions',
             description: 'Get a list of all serverless functions deployed in a HubSpot portal/account. Shows function routes, HTTP methods, secrets, and timestamps.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

package/mcp-server/tools/cms/HsListTool.js

@@ -53,6 +53,10 @@ export class HsListTool extends Tool {
             title: 'List HubSpot CMS Directory Contents',
             description: 'List remote contents of a HubSpot CMS directory.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

package/mcp-server/tools/index.js

@@ -15,11 +15,13 @@ import { HsCreateTemplateTool } from './cms/HsCreateTemplateTool.js';
 import { HsCreateFunctionTool } from './cms/HsCreateFunctionTool.js';
 import { HsListFunctionsTool } from './cms/HsListFunctionsTool.js';
 import { HsFunctionLogsTool } from './cms/HsFunctionLogsTool.js';
+import { CreateTestAccountTool } from './project/CreateTestAccountTool.js';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
         new CreateProjectTool(mcpServer).register(),
         new GuidedWalkthroughTool(mcpServer).register(),
+        new CreateTestAccountTool(mcpServer).register(),
         new DeployProjectTool(mcpServer).register(),
         new AddFeatureToProjectTool(mcpServer).register(),
         new ValidateProjectTool(mcpServer).register(),

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

@@ -72,6 +72,12 @@ export class AddFeatureToProjectTool extends Tool {
             description: `Adds a feature to an existing HubSpot project.
           Only works for projects with platformVersion '2025.2' and beyond`,
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

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

@@ -88,6 +88,12 @@ export class CreateProjectTool extends Tool {
             title: 'Create HubSpot Project',
             description: 'Creates a HubSpot project with the provided name and outputs it in the provided destination',
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

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

@@ -0,0 +1,41 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { z } from 'zod';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+declare const createTestAccountInputSchema: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    configPath: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    marketingLevel: z.ZodOptional<z.ZodEnum<["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"]>>;
+    opsLevel: z.ZodOptional<z.ZodEnum<["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"]>>;
+    serviceLevel: z.ZodOptional<z.ZodEnum<["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"]>>;
+    salesLevel: z.ZodOptional<z.ZodEnum<["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"]>>;
+    contentLevel: z.ZodOptional<z.ZodEnum<["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"]>>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    marketingLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    opsLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    serviceLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    salesLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    contentLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    configPath?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    marketingLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    opsLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    serviceLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    salesLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    contentLevel?: "FREE" | "STARTER" | "PROFESSIONAL" | "ENTERPRISE" | undefined;
+    configPath?: string | undefined;
+}>;
+export type CreateTestAccountInputSchema = z.infer<typeof createTestAccountInputSchema>;
+export declare class CreateTestAccountTool extends Tool<CreateTestAccountInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteCurrentWorkingDirectory, name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, configPath, }: CreateTestAccountInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,137 @@
+import { Tool } from '../../types.js';
+import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { z } from 'zod';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { addFlag } from '../../utils/command.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { ACCOUNT_LEVEL_CHOICES } from '../../../lib/constants.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    configPath: z
+        .string()
+        .optional()
+        .describe('Path to a test account configuration JSON file. Mutually exclusive with all other parameters.\n\n' +
+        'Config file format:\n' +
+        '{\n' +
+        '  "accountName": "AllHubsProfessional",\n' +
+        '  "description": "Professional test account",\n' +
+        '  "marketingLevel": "PROFESSIONAL",\n' +
+        '  "opsLevel": "PROFESSIONAL",\n' +
+        '  "serviceLevel": "PROFESSIONAL",\n' +
+        '  "salesLevel": "PROFESSIONAL",\n' +
+        '  "contentLevel": "PROFESSIONAL"\n' +
+        '}'),
+    name: z
+        .string()
+        .optional()
+        .describe('Name for the test account. Required when not using configPath.'),
+    description: z
+        .string()
+        .optional()
+        .describe('Description for the test account. Optional.'),
+    marketingLevel: z
+        .enum(ACCOUNT_LEVEL_CHOICES)
+        .optional()
+        .describe(`Marketing Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+    opsLevel: z
+        .enum(ACCOUNT_LEVEL_CHOICES)
+        .optional()
+        .describe(`Operations Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+    serviceLevel: z
+        .enum(ACCOUNT_LEVEL_CHOICES)
+        .optional()
+        .describe(`Service Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+    salesLevel: z
+        .enum(ACCOUNT_LEVEL_CHOICES)
+        .optional()
+        .describe(`Sales Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+    contentLevel: z
+        .enum(ACCOUNT_LEVEL_CHOICES)
+        .optional()
+        .describe(`CMS Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const createTestAccountInputSchema = z.object({ ...inputSchema });
+const toolName = 'create-test-account';
+export class CreateTestAccountTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteCurrentWorkingDirectory, name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, configPath, }) {
+        await trackToolUsage(toolName);
+        let command = 'hs test-account create';
+        const content = [];
+        // Use config file if provided (LLM should check for config first)
+        if (configPath) {
+            command = addFlag(command, 'config-path', configPath);
+        }
+        // Use flags if name is provided (when no config used)
+        else if (name) {
+            command = addFlag(command, 'name', name);
+            if (description) {
+                command = addFlag(command, 'description', description);
+            }
+            if (marketingLevel) {
+                command = addFlag(command, 'marketing-level', marketingLevel);
+            }
+            if (opsLevel) {
+                command = addFlag(command, 'ops-level', opsLevel);
+            }
+            if (serviceLevel) {
+                command = addFlag(command, 'service-level', serviceLevel);
+            }
+            if (salesLevel) {
+                command = addFlag(command, 'sales-level', salesLevel);
+            }
+            if (contentLevel) {
+                command = addFlag(command, 'content-level', contentLevel);
+            }
+        }
+        else {
+            content.push(formatTextContent(`Ask the user for the account config JSON path or the name of the test account to create.`));
+        }
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // No flags or config - command will prompt user interactively
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+        }
+        catch (error) {
+            return formatTextContents(absoluteCurrentWorkingDirectory, error instanceof Error ? error.message : `${error}`);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Create HubSpot Test Account',
+            description: 'Creates a HubSpot developer test account. Test accounts are temporary HubSpot portals used for local development, testing apps, and QA workflows.\n\n' +
+                'WORKFLOW:\n' +
+                '1. Check the current working directory for existing test account config files (e.g., test-account.json, test-portal-config.json)\n' +
+                '2. If config file found:\n' +
+                '   - Show the user what file(s) you found\n' +
+                '   - Ask if they want to use the existing config\n' +
+                '   - If YES: Use configPath parameter only\n' +
+                '   - If NO: Proceed to step 3\n' +
+                '3. If no config file OR user declined:\n' +
+                '   - Ask the user for ALL account details:\n' +
+                '     * Account name (required)\n' +
+                '     * Description (required)\n' +
+                '     * Hub tier levels for each hub (optional, default to ENTERPRISE if not specified)\n' +
+                '   - Call this tool with name, description, and all tier level parameters\n' +
+                '   - IMPORTANT: Always provide all parameters to ensure non-interactive execution\n\n' +
+                'Available Hub Tier Levels: FREE, STARTER, PROFESSIONAL, ENTERPRISE\n' +
+                'Available Hubs: Marketing (marketingLevel), Sales (salesLevel), Service (serviceLevel), Operations (opsLevel), CMS (contentLevel)',
+            inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -45,6 +45,12 @@ export class DeployProjectTool extends Tool {
             title: 'Deploy a build of HubSpot Project',
             description: 'Takes a build number and a project name and deploys that build of the project. DO NOT run this tool unless the user specifies they would like to deploy the project.',
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -45,6 +45,10 @@ export class DocFetchTool extends Tool {
             title: 'Fetch HubSpot Developer Documentation (single file)',
             description: 'Always use this immediately after `search-docs` and before creating a plan, writing code, or answering technical questions. This tool retrieves the full, authoritative content of a HubSpot Developer Documentation page from its URL, ensuring responses are accurate, up-to-date, and grounded in the official docs.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -57,6 +57,10 @@ export class DocsSearchTool extends Tool {
             title: 'Search HubSpot Developer Documentation',
             description: 'Use this first whenever you need details about HubSpot APIs, SDKs, integrations, or developer platform features. This searches the official HubSpot Developer Documentation and returns the most relevant pages, each with a URL for use in `fetch-doc`. Always follow this with a fetch to get the full, authoritative content before making plans or writing answers.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -65,6 +65,10 @@ export class GetApiUsagePatternsByAppIdTool extends Tool {
             title: 'Get API Usage Patterns by App ID',
             description: 'Retrieves detailed API usage pattern analytics for a specific HubSpot application. Requires an appId (string) to identify the target application. Optionally accepts startDate and endDate parameters in YYYY-MM-DD format to filter results within a specific time range. Returns patternSummaries object containing usage statistics including portalPercentage (percentage of portals using this pattern) and numOfPortals (total count of portals) for different usage patterns. This data helps analyze how the application is being used across different HubSpot portals and can inform optimization decisions.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -45,6 +45,10 @@ export class GetApplicationInfoTool extends Tool {
             title: 'Get Applications Information',
             description: 'Retrieves a list of all HubSpot applications available in the current account. Returns an array of applications, where each application contains an appId (numeric identifier) and appName (string). This information is useful for identifying available applications before using other tools that require specific application IDs, such as getting API usage patterns. No input parameters are required - this tool fetches all applications from the HubSpot Insights API.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -53,6 +53,10 @@ export class GetConfigValuesTool extends Tool {
         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,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

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

@@ -44,6 +44,10 @@ export class GuidedWalkthroughTool extends Tool {
             title: 'Guided walkthrough of the CLI',
             description: 'Give the user a guided walkthrough of the HubSpot CLI.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

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

@@ -67,6 +67,12 @@ export class UploadProjectTools extends Tool {
             title: 'Upload HubSpot Project',
             description: 'DO NOT run this tool unless the user specifies they would like to upload the project, it is potentially destructive. Uploads the HubSpot project in current working directory.  If the project does not exist, it will be created. MUST be ran from within the project directory.',
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -30,6 +30,10 @@ export class ValidateProjectTool extends Tool {
             title: 'Validate HubSpot Project',
             description: 'Validates the HubSpot project and its configuration files.  This tool does not need to be ran before uploading the project',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

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

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

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

@@ -0,0 +1,231 @@
+import { CreateTestAccountTool, } from '../CreateTestAccountTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/feedbackTracking');
+const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('mcp-server/tools/project/CreateTestAccountTool', () => {
+    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);
+        mockMcpFeedbackRequest.mockResolvedValue('');
+        tool = new CreateTestAccountTool(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-test-account', expect.objectContaining({
+                title: 'Create HubSpot Test Account',
+                description: expect.stringContaining('Creates a HubSpot developer test account'),
+                inputSchema: expect.any(Object),
+            }), expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+        it('should include all key information in description', () => {
+            tool.register();
+            const registerCall = mockMcpServer.registerTool.mock.calls[0];
+            const config = registerCall[1];
+            expect(config.description).toContain('test account');
+            expect(config.description).toContain('WORKFLOW');
+            expect(config.description).toContain('config file');
+            expect(config.description).toContain('ALL account details');
+            expect(config.description).toContain('non-interactive execution');
+            expect(config.description).toContain('FREE, STARTER, PROFESSIONAL, ENTERPRISE');
+        });
+    });
+    describe('handler', () => {
+        describe('config file approach', () => {
+            const baseInput = {
+                absoluteCurrentWorkingDirectory: '/test/workspace',
+                configPath: './test-account.json',
+            };
+            it('should create test account with config path', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created successfully\nAccount ID: 12345678',
+                    stderr: '',
+                });
+                const result = await tool.handler(baseInput);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'config-path', './test-account.json');
+                expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', 'hs test-account create --config-path "./test-account.json"');
+                expect(result).toEqual({
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Test account created successfully\nAccount ID: 12345678',
+                        },
+                        { type: 'text', text: '' },
+                    ],
+                });
+            });
+            it('should handle absolute config path', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: '/absolute/path/to/config.json',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'config-path', '/absolute/path/to/config.json');
+                expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', 'hs test-account create --config-path "/absolute/path/to/config.json"');
+            });
+            it('should prioritize config path over flags', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './test-account.json',
+                    name: 'FlagAccount',
+                    description: 'This should be ignored',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'config-path', './test-account.json');
+                // Should not call addFlag for name or description
+                expect(mockAddFlag).not.toHaveBeenCalledWith(expect.anything(), 'name', expect.anything());
+            });
+        });
+        describe('flag-based approach', () => {
+            it('should create test account with just account name', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created successfully',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MyTestAccount',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'MyTestAccount');
+                expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', 'hs test-account create --name "MyTestAccount"');
+            });
+            it('should create test account with account name and description', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MyTestAccount',
+                    description: 'Test account for development',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'MyTestAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('name'), 'description', 'Test account for development');
+            });
+            it('should create test account with specific hub levels', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'MixedTierAccount',
+                    marketingLevel: 'PROFESSIONAL',
+                    salesLevel: 'STARTER',
+                    contentLevel: 'FREE',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'MixedTierAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('name'), 'marketing-level', 'PROFESSIONAL');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('marketing-level'), 'sales-level', 'STARTER');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('sales-level'), 'content-level', 'FREE');
+            });
+            it('should create test account with all hub levels specified', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created',
+                    stderr: '',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    name: 'AllHubsAccount',
+                    description: 'Full configuration',
+                    marketingLevel: 'ENTERPRISE',
+                    opsLevel: 'PROFESSIONAL',
+                    serviceLevel: 'STARTER',
+                    salesLevel: 'ENTERPRISE',
+                    contentLevel: 'PROFESSIONAL',
+                };
+                await tool.handler(input);
+                expect(mockAddFlag).toHaveBeenCalledWith('hs test-account create', 'name', 'AllHubsAccount');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'description', 'Full configuration');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'marketing-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'ops-level', 'PROFESSIONAL');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'service-level', 'STARTER');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'sales-level', 'ENTERPRISE');
+                expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'content-level', 'PROFESSIONAL');
+            });
+        });
+        describe('interactive mode', () => {
+            it('should ask for parameters when neither config nor name provided', async () => {
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                };
+                const result = await tool.handler(input);
+                // Should NOT run the command
+                expect(mockRunCommandInDir).not.toHaveBeenCalled();
+                // Should return a message asking for information
+                expect(result).toEqual({
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Ask the user for the account config JSON path or the name of the test account to create.',
+                        },
+                    ],
+                });
+            });
+        });
+        describe('error handling', () => {
+            it('should handle command output with stderr warnings', async () => {
+                mockRunCommandInDir.mockResolvedValue({
+                    stdout: 'Test account created successfully',
+                    stderr: 'Warning: Some non-critical warning message',
+                });
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './test-account.json',
+                };
+                const result = await tool.handler(input);
+                expect(result).toEqual({
+                    content: [
+                        { type: 'text', text: 'Test account created successfully' },
+                        {
+                            type: 'text',
+                            text: 'Warning: Some non-critical warning message',
+                        },
+                    ],
+                });
+            });
+            it('should handle command execution errors', async () => {
+                const error = new Error('Failed to create test account');
+                mockRunCommandInDir.mockRejectedValue(error);
+                const input = {
+                    absoluteCurrentWorkingDirectory: '/test/workspace',
+                    configPath: './test-account.json',
+                };
+                const result = await tool.handler(input);
+                expect(result).toEqual({
+                    content: [{ type: 'text', text: 'Failed to create test account' }],
+                });
+            });
+        });
+    });
+});