@hubspot/cli 7.9.0-experimental.0 → 7.9.1-experimental.0

package/lib/validation.js

@@ -4,16 +4,17 @@ import { uiLogger } from '../lib/ui/logger.js';
 import { CMS_PUBLISH_MODE } from '@hubspot/local-dev-lib/constants/files';
 import { API_KEY_AUTH_METHOD, OAUTH_AUTH_METHOD, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
 import { commaSeparatedValues } from '@hubspot/local-dev-lib/text';
-import { getConfigPath, getAccountConfig, getAccountId, loadConfigFromEnvironment, } from '@hubspot/local-dev-lib/config';
+import { getConfigFilePath, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
 import { getOauthManager } from '@hubspot/local-dev-lib/oauth';
 import { accessTokenForPersonalAccessKey } from '@hubspot/local-dev-lib/personalAccessKey';
 import { getAbsoluteFilePath, getCwd, getExt, } from '@hubspot/local-dev-lib/path';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
 import { getCmsPublishMode } from './commonOpts.js';
 import { logError } from './errorHandlers/index.js';
 import { lib } from '../lang/en.js';
 export async function validateAccount(options) {
     const { derivedAccountId, userProvidedAccount } = options;
-    const accountId = getAccountId(derivedAccountId);
+    const accountId = derivedAccountId;
     if (!accountId) {
         if (userProvidedAccount) {
             uiLogger.error(lib.validation.accountNotFoundInConfig(userProvidedAccount));
@@ -23,33 +24,34 @@ export async function validateAccount(options) {
         }
         return false;
     }
-    if (userProvidedAccount && loadConfigFromEnvironment()) {
+    if (userProvidedAccount &&
+        process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG]) {
         throw new Error(lib.validation.userProvidedAccount);
     }
-    const accountConfig = getAccountConfig(accountId);
+    const accountConfig = getConfigAccountById(accountId);
     if (!accountConfig) {
         uiLogger.error(lib.validation.accountNotConfigured(accountId));
         return false;
     }
-    const { authType, auth, apiKey, personalAccessKey } = accountConfig;
+    const { authType } = accountConfig;
     if (typeof authType === 'string' && authType !== authType.toLowerCase()) {
-        uiLogger.error(lib.validation.invalidAuthType(authType, accountId, getConfigPath() || '', commaSeparatedValues([
+        uiLogger.error(lib.validation.invalidAuthType(authType, accountId, getConfigFilePath(), commaSeparatedValues([
             PERSONAL_ACCESS_KEY_AUTH_METHOD,
             OAUTH_AUTH_METHOD,
             API_KEY_AUTH_METHOD,
         ].map(method => method.value))));
     }
     if (authType === 'oauth2') {
-        if (typeof auth !== 'object') {
+        if (typeof accountConfig.auth !== 'object') {
             uiLogger.error(lib.validation.oauth2ConfigMissing(accountId));
             return false;
         }
-        const { clientId, clientSecret, tokenInfo } = auth;
+        const { clientId, clientSecret, tokenInfo } = accountConfig.auth;
         if (!clientId || !clientSecret || !tokenInfo || !tokenInfo.refreshToken) {
             uiLogger.error(lib.validation.oauth2ConfigIncorrect(accountId));
             return false;
         }
-        const oauth = getOauthManager(accountId, accountConfig);
+        const oauth = getOauthManager(accountConfig);
         try {
             let accessToken;
             if (oauth) {
@@ -66,7 +68,7 @@ export async function validateAccount(options) {
         }
     }
     else if (authType === 'personalaccesskey') {
-        if (!personalAccessKey) {
+        if (!accountConfig.personalAccessKey) {
             uiLogger.error(lib.validation.personalAccessKeyMissing(accountId));
             return false;
         }
@@ -82,7 +84,7 @@ export async function validateAccount(options) {
             return false;
         }
     }
-    else if (!apiKey) {
+    else if (!accountConfig.apiKey) {
         uiLogger.error(lib.validation.authConfigurationMissing(accountId));
         return false;
     }

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

@@ -80,10 +80,10 @@ export class HsCreateFunctionTool extends Tool {
         }
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
-            return formatTextContents(absoluteCurrentWorkingDirectory, error instanceof Error ? error.message : `${error}`);
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
         }
     }
     register() {
@@ -91,6 +91,12 @@ export class HsCreateFunctionTool extends Tool {
             title: 'Create HubSpot CMS Serverless Function',
             description: `Creates a new HubSpot CMS serverless function using the hs create function command. Functions can be created non-interactively by specifying functionsFolder, filename, and endpointPath. Supports all HTTP methods (${HTTP_METHODS.join(', ')}).`,
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

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

@@ -13,20 +13,20 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     absoluteCurrentWorkingDirectory: string;
     dest?: string | undefined;
+    global?: boolean | undefined;
     moduleLabel?: string | undefined;
     reactType?: boolean | undefined;
-    global?: boolean | undefined;
-    availableForNewContent?: boolean | undefined;
     contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
     userSuppliedName?: string | undefined;
 }, {
     absoluteCurrentWorkingDirectory: string;
     dest?: string | undefined;
+    global?: boolean | undefined;
     moduleLabel?: string | undefined;
     reactType?: boolean | undefined;
-    global?: boolean | undefined;
-    availableForNewContent?: boolean | undefined;
     contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
     userSuppliedName?: string | undefined;
 }>;
 export type HsCreateModuleInputSchema = z.infer<typeof inputSchemaZodObject>;

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

@@ -102,10 +102,10 @@ export class HsCreateModuleTool extends Tool {
         }
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
-            return formatTextContents(absoluteCurrentWorkingDirectory, error instanceof Error ? error.message : `${error}`);
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
         }
     }
     register() {
@@ -113,6 +113,12 @@ export class HsCreateModuleTool extends Tool {
             title: 'Create HubSpot CMS Module',
             description: 'Creates a new HubSpot CMS module using the hs create module command. Modules can be created non-interactively by specifying moduleLabel and other module options. You can create either HubL or React modules by setting the reactType parameter.',
             inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
         }, this.handler);
     }
 }

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

@@ -59,10 +59,10 @@ export class HsCreateTemplateTool extends Tool {
         }
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
-            return formatTextContents(absoluteCurrentWorkingDirectory, error instanceof Error ? error.message : `${error}`);
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
         }
     }
     register() {
@@ -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

@@ -52,11 +52,11 @@ export class HsFunctionLogsTool extends Tool {
         }
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            return formatTextContents(absoluteCurrentWorkingDirectory, `Error executing hs logs command: ${errorMessage}`);
+            return formatTextContents(`Error executing hs logs command: ${errorMessage}`);
         }
     }
     register() {
@@ -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

@@ -34,7 +34,7 @@ export class HsListFunctionsTool extends Tool {
         }
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -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

@@ -34,7 +34,7 @@ export class HsListTool extends Tool {
         }
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -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/cms/__tests__/HsCreateFunctionTool.test.js

@@ -10,6 +10,7 @@ vi.mock('../../../utils/toolUsageTracking', () => ({
     trackToolUsage: vi.fn(),
 }));
 vi.mock('../../../utils/feedbackTracking');
+vi.mock('@hubspot/local-dev-lib/config');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockRunCommandInDir = runCommandInDir;
 const mockAddFlag = addFlag;

package/mcp-server/tools/index.js

@@ -9,17 +9,20 @@ import { DocsSearchTool } from './project/DocsSearchTool.js';
 import { DocFetchTool } from './project/DocFetchTool.js';
 import { GetApiUsagePatternsByAppIdTool } from './project/GetApiUsagePatternsByAppIdTool.js';
 import { GetApplicationInfoTool } from './project/GetApplicationInfoTool.js';
+import { GetBuildStatusTool } from './project/GetBuildStatusTool.js';
 import { HsListTool } from './cms/HsListTool.js';
 import { HsCreateModuleTool } from './cms/HsCreateModuleTool.js';
 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(),
@@ -28,6 +31,7 @@ export function registerProjectTools(mcpServer) {
         new DocFetchTool(mcpServer).register(),
         new GetApiUsagePatternsByAppIdTool(mcpServer).register(),
         new GetApplicationInfoTool(mcpServer).register(),
+        new GetBuildStatusTool(mcpServer).register(),
     ];
 }
 export function registerCmsTools(mcpServer) {

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

@@ -26,7 +26,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type AddFeatureInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class AddFeatureToProjectTool extends Tool<AddFeatureInputSchema> {
     constructor(mcpServer: McpServer);
-    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }: AddFeatureInputSchema): Promise<TextContentResponse>;
+    handler({ absoluteProjectPath, distribution, auth, features, addApp, }: AddFeatureInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -35,7 +35,7 @@ export class AddFeatureToProjectTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }) {
+    async handler({ absoluteProjectPath, distribution, auth, features, addApp, }) {
         try {
             await trackToolUsage(toolName);
             let command = `hs project add`;
@@ -60,10 +60,10 @@ export class AddFeatureToProjectTool extends Tool {
             // If features isn't provided, pass an empty array to bypass the prompt
             command = addFlag(command, 'features', features || []);
             const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
-            return formatTextContents(absoluteCurrentWorkingDirectory, error instanceof Error ? error.message : `${error}`);
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
         }
     }
     register() {
@@ -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

@@ -77,10 +77,10 @@ export class CreateProjectTool extends Tool {
         command = addFlag(command, 'features', features || []);
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
-            return formatTextContents(absoluteCurrentWorkingDirectory, error instanceof Error ? error.message : `${error}`);
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
         }
     }
     register() {
@@ -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,150 @@
+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';
+import fs from 'fs';
+import { getConfigAccountByName } from '@hubspot/local-dev-lib/config';
+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. Required when not using configPath.'),
+    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) {
+            let configJson;
+            try {
+                const config = fs.readFileSync(configPath, 'utf8');
+                configJson = JSON.parse(config);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        formatTextContent(`Failed to read or parse config file at "${configPath}": ${errorMessage}. Please ensure the file exists and contains valid JSON.`),
+                    ],
+                };
+            }
+            if (configJson.accountName) {
+                const account = getConfigAccountByName(configJson.accountName);
+                if (account) {
+                    content.push(formatTextContent(`The account name "${configJson.accountName}" already exists in the CLI config. Please use a different name.`));
+                }
+            }
+            command = addFlag(command, 'config-path', configPath);
+        }
+        // Use flags if name is provided (when no config used)
+        else if (name) {
+            const account = getConfigAccountByName(name);
+            if (account) {
+                content.push(formatTextContent(`The account name "${name}" already exists in the CLI config. Please use a different name.`));
+            }
+            command = addFlag(command, 'name', name);
+            command = addFlag(command, 'description', description || name);
+            command = addFlag(command, 'marketing-level', marketingLevel || 'ENTERPRISE');
+            command = addFlag(command, 'ops-level', opsLevel || 'ENTERPRISE');
+            command = addFlag(command, 'service-level', serviceLevel || 'ENTERPRISE');
+            command = addFlag(command, 'sales-level', salesLevel || 'ENTERPRISE');
+            command = addFlag(command, 'content-level', contentLevel || 'ENTERPRISE');
+        }
+        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 (optional, defaults to account name if not specified)\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.d.ts

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

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

@@ -21,7 +21,7 @@ export class DeployProjectTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildNumber, }) {
+    async handler({ absoluteProjectPath, buildNumber, }) {
         await trackToolUsage(toolName);
         let command = `hs project deploy`;
         const content = [];
@@ -38,13 +38,19 @@ export class DeployProjectTool extends Tool {
             };
         }
         const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
-        return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+        return formatTextContents(stdout, stderr);
     }
     register() {
         return this.mcpServer.registerTool(toolName, {
             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.d.ts

@@ -14,7 +14,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class DocFetchTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
-    handler({ docUrl, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ docUrl }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};