@hubspot/cli 7.7.30-experimental.0 → 7.7.32-experimental.0

package/lang/en.d.ts

@@ -2569,6 +2569,8 @@ export declare const lib: {
             readonly activeInstallations: (appName: string, installCount: number) => string;
             readonly error: "An error occurred while checking installations for your app";
         };
+        readonly distributionChanged: `Your app's distribution type has been changed from private to marketplace. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${string} change your app's distribution type. This will uninstall your app from all accounts.`;
+        readonly authTypeChanged: `Your app's auth type has been changed from static to oauth. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${string} change your app's auth type. This will uninstall your app from all accounts.`;
     };
     readonly LocalDevWebsocketServer: {
         readonly errors: {
@@ -3380,7 +3382,7 @@ Run ${string} to upgrade to version ${string}`;
         readonly componentsToBeMigrated: (components: string) => string;
         readonly componentsThatWillNotBeMigrated: (components: string) => string;
         readonly sourceContentsMoved: (newLocation: string) => string;
-        readonly projectMigrationWarningTitle: "⚠️ Important: Migrating to platformVersion 2025.2 is irreversible ⚠️";
+        readonly projectMigrationWarningTitle: "Important: Migrating to platformVersion 2025.2 is irreversible";
         readonly projectMigrationWarning: string;
         readonly success: {
             readonly downloadedProject: (projectName: string, projectDest: string) => string;

package/lang/en.js

@@ -5,7 +5,7 @@ import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constant
 import { ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME, GLOBAL_CONFIG_PATH, DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME, } from '@hubspot/local-dev-lib/constants/config';
 import { uiAccountDescription, uiBetaTag, uiCommandReference, uiLink, UI_COLORS, } from '../lib/ui/index.js';
 import { getProjectDetailUrl, getProjectSettingsUrl, getLocalDevUiUrl, } from '../lib/projects/urls.js';
-import { PROJECT_CONFIG_FILE, PROJECT_WITH_APP } from '../lib/constants.js';
+import { APP_DISTRIBUTION_TYPES, APP_AUTH_TYPES, PROJECT_CONFIG_FILE, PROJECT_WITH_APP, } from '../lib/constants.js';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 export const commands = {
     generalErrors: {
@@ -2566,6 +2566,8 @@ export const lib = {
             activeInstallations: (appName, installCount) => `[WARNING] Your app ${chalk.bold(appName)} is installed in ${chalk.bold(`${installCount} ${installCount === 1 ? 'account' : 'accounts'}`)}`,
             error: 'An error occurred while checking installations for your app',
         },
+        distributionChanged: `Your app's distribution type has been changed from ${APP_DISTRIBUTION_TYPES.PRIVATE} to ${APP_DISTRIBUTION_TYPES.MARKETPLACE}. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${chalk.bold('permanantly')} change your app's distribution type. This will uninstall your app from all accounts.`,
+        authTypeChanged: `Your app's auth type has been changed from ${APP_AUTH_TYPES.STATIC} to ${APP_AUTH_TYPES.OAUTH}. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${chalk.bold('permanantly')} change your app's auth type. This will uninstall your app from all accounts.`,
     },
     LocalDevWebsocketServer: {
         errors: {
@@ -3374,7 +3376,7 @@ export const lib = {
         componentsToBeMigrated: (components) => `The following features will be migrated: ${components}`,
         componentsThatWillNotBeMigrated: (components) => `[NOTE] These features are not yet supported for migration but will be available later: ${components}`,
         sourceContentsMoved: (newLocation) => `The contents of your old source directory have been moved to ${newLocation}, move any required files to the new source directory.`,
-        projectMigrationWarningTitle: '⚠️ Important: Migrating to platformVersion 2025.2 is irreversible ⚠️',
+        projectMigrationWarningTitle: 'Important: Migrating to platformVersion 2025.2 is irreversible',
         projectMigrationWarning: uiBetaTag(`Running the ${uiCommandReference('hs project migrate')} command will permanently upgrade your project to platformVersion 2025.2. This action cannot be undone. To ensure you have access to your original files, they will be copied to a new directory (archive) for safekeeping.\n\nThis command will guide you through the process, prompting you to enter the required fields and will download the new project source code into your project source directory.`, false),
         success: {
             downloadedProject: (projectName, projectDest) => `Saved ${projectName} to ${projectDest}`,

package/lib/projects/__tests__/AppDevModeInterface.test.js

@@ -100,6 +100,7 @@ describe('AppDevModeInterface', () => {
             setAppDataForUid: vi.fn(),
             addListener: vi.fn(),
             addUploadWarning: vi.fn(),
+            removeListener: vi.fn(),
         };
         mockLocalDevLogger = {};
         // Mock constructors
@@ -387,6 +388,15 @@ describe('AppDevModeInterface', () => {
             await appDevModeInterface.cleanup();
             expect(UIEDevModeInterface.cleanup).toHaveBeenCalled();
         });
+        it('should remove state listeners', async () => {
+            await appDevModeInterface.cleanup();
+            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('devServerMessage', 
+            // @ts-expect-error access private method for testing
+            appDevModeInterface.onDevServerMessage);
+            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('projectNodes', 
+            // @ts-expect-error
+            appDevModeInterface.onChangeProjectNodes);
+        });
     });
     describe('isAutomaticallyInstallable()', () => {
         it('should return true for static auth app on test account with correct parent', () => {

package/lib/projects/localDev/AppDevModeInterface.d.ts

@@ -11,6 +11,7 @@ declare class AppDevModeInterface {
     _appNode?: AppIRNode | null;
     marketplaceAppInstalls?: number;
     constructor(options: AppDevModeInterfaceConstructorOptions);
+    private getAppNodeFromProjectNodes;
     private get appNode();
     private get appData();
     private set appData(value);
@@ -21,7 +22,10 @@ declare class AppDevModeInterface {
     private autoInstallStaticAuthApp;
     private installAppOrOpenInstallUrl;
     private checkTestAccountAppInstallation;
-    private setUpLocalDevServerMessageListeners;
+    private onDevServerMessage;
+    private onChangeProjectNodes;
+    private setUpStateListeners;
+    private removeStateListeners;
     setup(args: any): Promise<void>;
     start(): Promise<void>;
     fileChange(filePath: string, event: string): Promise<void>;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -30,12 +30,13 @@ class AppDevModeInterface {
             process.exit(EXIT_CODES.ERROR);
         }
     }
+    getAppNodeFromProjectNodes(projectNodes) {
+        return Object.values(projectNodes).find(isAppIRNode) || null;
+    }
     // Assumes only one app per project
     get appNode() {
         if (this._appNode === undefined) {
-            this._appNode =
-                Object.values(this.localDevState.projectNodes).find(isAppIRNode) ||
-                    null;
+            this._appNode = this.getAppNodeFromProjectNodes(this.localDevState.projectNodes);
         }
         return this._appNode;
     }
@@ -175,12 +176,33 @@ class AppDevModeInterface {
         }
         return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
     }
-    setUpLocalDevServerMessageListeners() {
-        this.localDevState.addListener('devServerMessage', message => {
-            if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
-                this.checkTestAccountAppInstallation();
-            }
-        });
+    onDevServerMessage = (message) => {
+        if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
+            this.checkTestAccountAppInstallation();
+        }
+    };
+    onChangeProjectNodes = (nodes) => {
+        const newAppNode = this.getAppNodeFromProjectNodes(nodes);
+        const oldDistribution = this.appNode?.config.distribution;
+        const newDistribution = newAppNode?.config.distribution;
+        const oldAuthType = this.appNode?.config.auth.type;
+        const newAuthType = newAppNode?.config.auth.type;
+        if (newDistribution === APP_DISTRIBUTION_TYPES.MARKETPLACE &&
+            oldDistribution !== APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+            this.localDevState.addUploadWarning(lib.AppDevModeInterface.distributionChanged);
+        }
+        else if (newAuthType === APP_AUTH_TYPES.OAUTH &&
+            oldAuthType !== APP_AUTH_TYPES.OAUTH) {
+            this.localDevState.addUploadWarning(lib.AppDevModeInterface.authTypeChanged);
+        }
+    };
+    setUpStateListeners() {
+        this.localDevState.addListener('devServerMessage', this.onDevServerMessage);
+        this.localDevState.addListener('projectNodes', this.onChangeProjectNodes);
+    }
+    removeStateListeners() {
+        this.localDevState.removeListener('devServerMessage', this.onDevServerMessage);
+        this.localDevState.removeListener('projectNodes', this.onChangeProjectNodes);
     }
     // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
     // In the future, update UIE Dev Server to use LocalDevState
@@ -215,7 +237,7 @@ class AppDevModeInterface {
         catch (e) {
             logError(e);
         }
-        this.setUpLocalDevServerMessageListeners();
+        this.setUpStateListeners();
         return UIEDevModeInterface.setup(args);
     }
     async start() {
@@ -239,6 +261,7 @@ class AppDevModeInterface {
         if (!this.appNode) {
             return;
         }
+        this.removeStateListeners();
         return UIEDevModeInterface.cleanup();
     }
 }

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

@@ -0,0 +1,32 @@
+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;
+    dest: z.ZodOptional<z.ZodString>;
+    functionsFolder: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    endpointMethod: z.ZodOptional<z.ZodEnum<["DELETE", "GET", "PATCH", "POST", "PUT"]>>;
+    endpointPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    functionsFolder?: string | undefined;
+    filename?: string | undefined;
+    endpointMethod?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT" | undefined;
+    endpointPath?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    functionsFolder?: string | undefined;
+    filename?: string | undefined;
+    endpointMethod?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT" | undefined;
+    endpointPath?: string | undefined;
+}>;
+export type HsCreateFunctionInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsCreateFunctionTool extends Tool<HsCreateFunctionInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }: HsCreateFunctionInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,96 @@
+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 { HTTP_METHODS } from '../../../types/Cms.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    dest: z
+        .string()
+        .describe('The destination path where the function should be created on the current computer.')
+        .optional(),
+    functionsFolder: z
+        .string()
+        .describe('Folder name for function creation. Required for non-interactive function creation. If the user has not specified the folder name, ask them to provide it.')
+        .optional(),
+    filename: z
+        .string()
+        .describe('Function filename. Required for non-interactive function creation. If the user has not specified the filename, ask them to provide it.')
+        .optional(),
+    endpointMethod: z
+        .enum(HTTP_METHODS)
+        .describe(`HTTP method for the function endpoint. Must be one of: ${HTTP_METHODS.join(', ')}. Defaults to GET.`)
+        .optional(),
+    endpointPath: z
+        .string()
+        .describe('API endpoint path for the function. Required for non-interactive function creation. If the user has not specified the endpoint path, ask them to provide it.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-hubspot-cms-function';
+export class HsCreateFunctionTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        const content = [];
+        // Require functions folder
+        if (!functionsFolder) {
+            content.push(formatTextContent(`Ask the user to provide the folder name for the function.`));
+        }
+        // Require filename
+        if (!filename) {
+            content.push(formatTextContent(`Ask the user to provide the filename for the function.`));
+        }
+        // Require endpoint path
+        if (!endpointPath) {
+            content.push(formatTextContent(`Ask the user to provide the API endpoint path for the function.`));
+        }
+        // If we have missing required information, return the prompts
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Build the command
+        let command = 'hs create function';
+        if (dest) {
+            command += ` "${dest}"`;
+        }
+        // Add function-specific flags
+        if (functionsFolder) {
+            command = addFlag(command, 'functions-folder', functionsFolder);
+        }
+        if (filename) {
+            command = addFlag(command, 'filename', filename);
+        }
+        if (endpointMethod) {
+            command = addFlag(command, 'endpoint-method', endpointMethod);
+        }
+        else {
+            command = addFlag(command, 'endpoint-method', 'GET');
+        }
+        if (endpointPath) {
+            command = addFlag(command, 'endpoint-path', endpointPath);
+        }
+        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 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,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,26 @@
+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>;
+    templateType: z.ZodOptional<z.ZodEnum<["page-template", "email-template", "partial", "global-partial", "blog-listing-template", "blog-post-template", "search-template", "section"]>>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    templateType?: "page-template" | "email-template" | "partial" | "global-partial" | "blog-listing-template" | "blog-post-template" | "search-template" | "section" | undefined;
+    userSuppliedName?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    templateType?: "page-template" | "email-template" | "partial" | "global-partial" | "blog-listing-template" | "blog-post-template" | "search-template" | "section" | undefined;
+    userSuppliedName?: string | undefined;
+}>;
+export type HsCreateTemplateInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsCreateTemplateTool extends Tool<HsCreateTemplateInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,75 @@
+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 { TEMPLATE_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 template they want to create.')
+        .optional(),
+    dest: z
+        .string()
+        .describe('The destination path where the template should be created on the current computer.')
+        .optional(),
+    templateType: z
+        .enum(TEMPLATE_TYPES)
+        .describe(`Template type for template creation. Must be one of: ${TEMPLATE_TYPES.join(', ')}`)
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-hubspot-cms-template';
+export class HsCreateTemplateTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        const content = [];
+        // Always require a name
+        if (!userSuppliedName) {
+            content.push(formatTextContent(`Ask the user to specify the name of the template they want to create.`));
+        }
+        // Require template type
+        if (!templateType) {
+            content.push(formatTextContent(`Ask the user what template type they want to create. Options are: ${TEMPLATE_TYPES.join(', ')}`));
+        }
+        // If we have missing required information, return the prompts
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Build the command
+        let command = 'hs create template';
+        if (userSuppliedName) {
+            command += ` "${userSuppliedName}"`;
+        }
+        if (dest) {
+            command += ` "${dest}"`;
+        }
+        // Add template type flag
+        if (templateType) {
+            command = addFlag(command, 'template-type', templateType);
+        }
+        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 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,
+        }, this.handler);
+    }
+}

package/mcp-server/tools/cms/HsListFunctionsTool.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;
+    account: z.ZodOptional<z.ZodString>;
+    json: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    json?: boolean | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    json?: boolean | undefined;
+}>;
+export type HsListFunctionsInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsListFunctionsTool extends Tool<HsListFunctionsInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ account, json, absoluteCurrentWorkingDirectory, }: HsListFunctionsInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

package/mcp-server/tools/cms/HsListFunctionsTool.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,
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+    json: z
+        .boolean()
+        .describe('Return raw JSON output instead of formatted table. Useful for programmatic access.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'list-hubspot-cms-serverless-functions';
+export class HsListFunctionsTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ account, json, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        let command = 'hs function list';
+        if (json) {
+            command += ' --json';
+        }
+        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 function list command: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

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

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