@hubspot/cli 7.7.27-experimental.2 → 7.7.29-experimental.0

package/lib/prompts/importDataTestAccountSelectPrompt.d.ts

@@ -0,0 +1,3 @@
+export declare function importDataTestAccountSelectPrompt(parentAccountId: number): Promise<{
+    selectedAccountId: number;
+}>;

package/lib/prompts/importDataTestAccountSelectPrompt.js

@@ -0,0 +1,29 @@
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { promptUser } from './promptUtils.js';
+import { getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { uiAccountDescription } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
+export async function importDataTestAccountSelectPrompt(parentAccountId) {
+    const accounts = getConfigAccounts();
+    if (!accounts) {
+        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noAccountsFound);
+    }
+    const childAccounts = accounts
+        .filter(account => account.parentAccountId === parentAccountId)
+        .map(account => {
+        return {
+            name: uiAccountDescription(getAccountIdentifier(account)),
+            value: getAccountIdentifier(account),
+        };
+    })
+        .filter(account => account.value !== undefined && account.name !== undefined);
+    if (childAccounts.length === 0) {
+        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noChildTestAccountsFound(parentAccountId));
+    }
+    return promptUser({
+        type: 'list',
+        name: 'selectedAccountId',
+        message: '[--account] Select a developer test account:',
+        choices: childAccounts,
+    });
+}

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -151,6 +151,7 @@ async function selectTargetAccountPrompt(defaultAccountId, accountType, choices)
                 accountType,
             }),
             choices,
+            loop: false,
         },
     ]);
     return targetAccountInfo;

package/lib/prompts/promptUtils.d.ts

@@ -1,15 +1,21 @@
 import { Separator as _Separator } from '@inquirer/prompts';
 import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
 export declare const Separator: _Separator;
+export declare const PROMPT_THEME: {
+    prefix: {
+        idle: string;
+    };
+};
 export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
 export declare function confirmPrompt(message: string, options?: {
     defaultAnswer?: boolean;
 }): Promise<boolean>;
-export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, }: {
+export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, loop, }: {
     choices: PromptChoices<T>;
     when?: PromptWhen;
     defaultAnswer?: string | number | boolean;
     validate?: (input: T[]) => (boolean | string) | Promise<boolean | string>;
+    loop?: boolean;
 }): Promise<T>;
 export declare function inputPrompt(message: string, { when, validate, defaultAnswer, }?: {
     when?: boolean | (() => boolean);

package/lib/prompts/promptUtils.js

@@ -1,6 +1,8 @@
 import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
 import { EXIT_CODES } from '../enums/exitCodes.js';
+import chalk from 'chalk';
 export const Separator = new _Separator();
+export const PROMPT_THEME = { prefix: { idle: chalk.green('?') } };
 function isUserCancellationError(error) {
     return error instanceof Error && error.name === 'ExitPromptError';
 }
@@ -102,6 +104,8 @@ function handleRawListPrompt(config) {
         choices: choices,
         pageSize: config.pageSize,
         default: config.default,
+        loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleNumberPrompt(config) {
@@ -109,6 +113,7 @@ function handleNumberPrompt(config) {
         message: config.message,
         default: config.default,
         validate: config.validate,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handlePasswordPrompt(config) {
@@ -116,6 +121,7 @@ function handlePasswordPrompt(config) {
         message: config.message,
         mask: '*',
         validate: config.validate,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleCheckboxPrompt(config) {
@@ -125,6 +131,8 @@ function handleCheckboxPrompt(config) {
         choices: choices,
         pageSize: config.pageSize,
         validate: config.validate,
+        loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleConfirmPrompt(config) {
@@ -138,6 +146,7 @@ function handleInputPrompt(config) {
         default: config.default,
         validate: config.validate,
         transformer: config.transformer,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleSelectPrompt(config) {
@@ -147,6 +156,8 @@ function handleSelectPrompt(config) {
         choices: choices,
         default: config.default,
         pageSize: config.pageSize,
+        loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 export async function confirmPrompt(message, options = {}) {
@@ -154,10 +165,11 @@ export async function confirmPrompt(message, options = {}) {
     const choice = await confirm({
         message,
         default: defaultAnswer,
+        theme: PROMPT_THEME,
     });
     return choice;
 }
-export async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
+export async function listPrompt(message, { choices, when, defaultAnswer, validate, loop, }) {
     const { choice } = await promptUser({
         name: 'choice',
         type: 'list',
@@ -166,6 +178,7 @@ export async function listPrompt(message, { choices, when, defaultAnswer, valida
         when,
         default: defaultAnswer,
         validate,
+        loop,
     });
     return choice;
 }

package/lib/ui/__tests__/removeAnsiCodes.test.d.ts

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

package/lib/ui/__tests__/removeAnsiCodes.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import chalk from 'chalk';
+import { removeAnsiCodes } from '../removeAnsiCodes.js';
+describe('removeAnsiCodes', () => {
+    describe('basic functionality', () => {
+        it('should remove ANSI codes from colored text', () => {
+            const coloredText = chalk.red('Error message');
+            const cleanText = removeAnsiCodes(coloredText);
+            expect(cleanText).toBe('Error message');
+        });
+        it('should return unchanged text when no ANSI codes are present', () => {
+            const plainText = 'This is plain text';
+            const result = removeAnsiCodes(plainText);
+            expect(result).toBe('This is plain text');
+        });
+        it('should handle empty strings', () => {
+            const result = removeAnsiCodes('');
+            expect(result).toBe('');
+        });
+    });
+    describe('background colors', () => {
+        it('should remove background color codes', () => {
+            const text = chalk.bgRed('Text with red background');
+            expect(removeAnsiCodes(text)).toBe('Text with red background');
+        });
+        it('should remove multiple background colors', () => {
+            const text = chalk.bgBlue('Blue bg') + ' ' + chalk.bgYellow('Yellow bg');
+            expect(removeAnsiCodes(text)).toBe('Blue bg Yellow bg');
+        });
+    });
+    describe('text formatting', () => {
+        it('should remove bold formatting', () => {
+            const text = chalk.bold('Bold text');
+            expect(removeAnsiCodes(text)).toBe('Bold text');
+        });
+    });
+    describe('combined styles', () => {
+        it('should remove multiple formatting styles', () => {
+            const text = chalk.bold.red('Bold red text');
+            expect(removeAnsiCodes(text)).toBe('Bold red text');
+        });
+        it('should remove complex combinations', () => {
+            const text = chalk.bold.underline.red.bgYellow('Complex styling');
+            expect(removeAnsiCodes(text)).toBe('Complex styling');
+        });
+        it('should handle chained styles', () => {
+            const text = chalk.red('Red') + chalk.green(' Green') + chalk.blue(' Blue');
+            expect(removeAnsiCodes(text)).toBe('Red Green Blue');
+        });
+    });
+    describe('multiline text', () => {
+        it('should remove ANSI codes from multiline text', () => {
+            const text = chalk.red('Line 1\n') + chalk.green('Line 2\n') + chalk.blue('Line 3');
+            const expected = 'Line 1\nLine 2\nLine 3';
+            expect(removeAnsiCodes(text)).toBe(expected);
+        });
+        it('should handle mixed formatted and plain lines', () => {
+            const text = chalk.bold('Formatted line\n') +
+                'Plain line\n' +
+                chalk.italic('Another formatted line');
+            const expected = 'Formatted line\nPlain line\nAnother formatted line';
+            expect(removeAnsiCodes(text)).toBe(expected);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle text with only ANSI codes (no visible text)', () => {
+            const text = chalk.red('');
+            expect(removeAnsiCodes(text)).toBe('');
+        });
+        it('should handle multiple consecutive ANSI codes', () => {
+            // Create text with multiple style applications
+            const text = chalk.red(chalk.bold(chalk.underline('Heavily styled')));
+            expect(removeAnsiCodes(text)).toBe('Heavily styled');
+        });
+        it('should handle mixed content with spaces and special characters', () => {
+            const text = chalk.green('Success:') + ' ' + chalk.red('Error!') + ' @#$%^&*()';
+            expect(removeAnsiCodes(text)).toBe('Success: Error! @#$%^&*()');
+        });
+        it('should handle text with tabs and newlines', () => {
+            const text = chalk.yellow('\tTabbed text\n') + chalk.cyan('New line text');
+            expect(removeAnsiCodes(text)).toBe('\tTabbed text\nNew line text');
+        });
+    });
+});

package/lib/ui/index.js

@@ -65,16 +65,13 @@ export function uiCommandReference(command, withQuotes = true) {
 }
 export function uiFeatureHighlight(features, title) {
     uiInfoSection(title ? title : i18n(`lib.ui.featureHighlight.defaultTitle`), () => {
-        features.forEach((c, i) => {
-            const featureKey = `lib.ui.featureHighlight.featureKeys.${c}`;
+        features.forEach(feature => {
+            const featureKey = `lib.ui.featureHighlight.featureKeys.${feature}`;
             const message = i18n(`${featureKey}.message`, {
                 command: uiCommandReference(i18n(`${featureKey}.command`)),
                 link: uiLink(i18n(`${featureKey}.linkText`), i18n(`${featureKey}.url`)),
             });
-            if (i !== 0) {
-                logger.log('');
-            }
-            logger.log(message);
+            logger.log(`  - ${message}`);
         });
     });
 }

package/lib/ui/removeAnsiCodes.d.ts

@@ -0,0 +1 @@
+export declare function removeAnsiCodes(str: string): string;

package/lib/ui/removeAnsiCodes.js

@@ -0,0 +1,4 @@
+const ANSI_CODE_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+export function removeAnsiCodes(str) {
+    return str.replace(ANSI_CODE_REGEX, '');
+}

package/mcp-server/server.js

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { registerProjectTools } from './tools/index.js';
+import { registerProjectTools, registerCmsTools } from './tools/index.js';
 const server = new McpServer({
     name: 'HubSpot CLI MCP Server',
     version: '0.0.1',
@@ -11,6 +11,7 @@ const server = new McpServer({
     },
 });
 registerProjectTools(server);
+registerCmsTools(server);
 // Start receiving messages on stdin and sending messages on stdout
 const transport = new StdioServerTransport();
 server.connect(transport);

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

@@ -0,0 +1,38 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    userSuppliedName: z.ZodOptional<z.ZodString>;
+    dest: z.ZodOptional<z.ZodString>;
+    moduleLabel: z.ZodOptional<z.ZodString>;
+    reactType: z.ZodOptional<z.ZodBoolean>;
+    contentTypes: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    global: z.ZodOptional<z.ZodBoolean>;
+    availableForNewContent: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    global?: boolean | undefined;
+    moduleLabel?: string | undefined;
+    reactType?: 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;
+    contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
+    userSuppliedName?: string | undefined;
+}>;
+export type HsCreateModuleInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsCreateModuleTool extends Tool<HsCreateModuleInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }: HsCreateModuleInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,118 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { addFlag } from '../../utils/command.js';
+import { CONTENT_TYPES } from '../../../types/Cms.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    userSuppliedName: z
+        .string()
+        .describe('REQUIRED - If not specified by the user, DO NOT choose. Ask the user to specify the name of the module they want to create.')
+        .optional(),
+    dest: z
+        .string()
+        .describe('The destination path where the module should be created on the current computer.')
+        .optional(),
+    moduleLabel: z
+        .string()
+        .describe('Label for module creation. Required for non-interactive module creation. If not provided, ask the user to provide it.')
+        .optional(),
+    reactType: z
+        .boolean()
+        .describe('Whether to create a React module. If the user has not specified that they want a React module, DO NOT choose for them, ask them what type of module they want to create HubL or React.')
+        .optional(),
+    contentTypes: z
+        .string()
+        .refine(val => {
+        if (!val)
+            return true; // optional
+        const types = val.split(',').map(t => t.trim().toUpperCase());
+        return types.every(type => CONTENT_TYPES.includes(type));
+    }, {
+        message: `Content types must be a comma-separated list of valid values: ${CONTENT_TYPES.join(', ')}`,
+    })
+        .describe(`Content types where the module can be used. Comma-separated list. Valid values: ${CONTENT_TYPES.join(', ')}. Defaults to "ANY".`)
+        .optional(),
+    global: z
+        .boolean()
+        .describe('Whether the module is global. Defaults to false.')
+        .optional(),
+    availableForNewContent: z
+        .boolean()
+        .describe('Whether the module is available for new content. Defaults to true.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-hubspot-cms-module';
+export class HsCreateModuleTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        const content = [];
+        // Always require a name
+        if (!userSuppliedName) {
+            content.push(formatTextContent(`Ask the user to specify the name of the module they want to create.`));
+        }
+        // Require module label
+        if (!moduleLabel) {
+            content.push(formatTextContent(`Ask the user to provide a label for the module.`));
+        }
+        // Ask about React vs HubL if not specified
+        if (reactType === undefined) {
+            content.push(formatTextContent(`Ask the user what type of module they want to create: HubL or React?`));
+        }
+        // If we have missing required information, return the prompts
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Build the command
+        let command = 'hs create module';
+        if (userSuppliedName) {
+            command += ` "${userSuppliedName}"`;
+        }
+        if (dest) {
+            command += ` "${dest}"`;
+        }
+        // Add module-specific flags
+        if (moduleLabel) {
+            command = addFlag(command, 'module-label', moduleLabel);
+        }
+        if (reactType !== undefined) {
+            command = addFlag(command, 'react-type', reactType);
+        }
+        if (contentTypes) {
+            command = addFlag(command, 'content-types', contentTypes);
+        }
+        else {
+            command = addFlag(command, 'content-types', 'ANY');
+        }
+        if (global !== undefined) {
+            command = addFlag(command, 'global', global);
+        }
+        if (availableForNewContent !== undefined) {
+            command = addFlag(command, 'available-for-new-content', availableForNewContent);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    path?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    path?: string | undefined;
+}>;
+export type HsListInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsListTool extends Tool<HsListInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ path, account, absoluteCurrentWorkingDirectory, }: HsListInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { addFlag } from '../../utils/command.js';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    path: z
+        .string()
+        .describe('The remote directory path in the HubSpot CMS to list contents. If not specified, lists the root directory.')
+        .optional(),
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'list-hubspot-cms-remote-contents';
+export class HsListTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ path, account, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        let command = 'hs list';
+        if (path) {
+            command += ` ${path}`;
+        }
+        if (account) {
+            command = addFlag(command, 'account', account);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing hs list command: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'List HubSpot CMS Directory Contents',
+            description: 'List remote contents of a HubSpot CMS directory.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

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