@hubspot/cli 7.9.0 → 7.9.1-experimental.0

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

@@ -4,7 +4,7 @@ import { formatTextContents } from '../../utils/content.js';
 import { absoluteCurrentWorkingDirectory } from './constants.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
 import { isV2Project } from '../../../lib/projects/platformVersion.js';
-import { getAccountIdFromCliConfig } from '../../utils/cliConfig.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
     platformVersion: z
@@ -23,15 +23,15 @@ export class GetConfigValuesTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }) {
+    async handler({ platformVersion, featureType, }) {
         try {
             if (!isV2Project(platformVersion)) {
-                return formatTextContents(absoluteCurrentWorkingDirectory, `Can only be used on projects with a minimum platformVersion of 2025.2`);
+                return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
             }
-            const accountId = getAccountIdFromCliConfig(absoluteCurrentWorkingDirectory);
+            const accountId = getConfigDefaultAccountIfExists()?.accountId;
             if (!accountId) {
                 const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
-                return formatTextContents(absoluteCurrentWorkingDirectory, authErrorMessage);
+                return formatTextContents(authErrorMessage);
             }
             const schema = await getIntermediateRepresentationSchema({
                 platformVersion,
@@ -40,11 +40,11 @@ export class GetConfigValuesTool extends Tool {
             });
             const internalComponentType = mapToInternalType(featureType);
             if (schema[internalComponentType]) {
-                return formatTextContents(absoluteCurrentWorkingDirectory, JSON.stringify({ config: schema[internalComponentType] }));
+                return formatTextContents(JSON.stringify({ config: schema[internalComponentType] }));
             }
         }
         catch (error) { }
-        return formatTextContents(absoluteCurrentWorkingDirectory, `Unable to locate JSON schema for type ${featureType}`);
+        return formatTextContents(`Unable to locate JSON schema for type ${featureType}`);
     }
     register() {
         return this.mcpServer.registerTool(toolName, {
@@ -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.d.ts

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

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

@@ -31,19 +31,23 @@ export class GuidedWalkthroughTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteCurrentWorkingDirectory, command, }) {
+    async handler({ command }) {
         await trackToolUsage(toolName);
         if (command) {
             const { stdout } = await execAsync(`${command} --help`);
-            return formatTextContents(absoluteCurrentWorkingDirectory, `Display this help output for the user amd wait for them to acknowledge: ${stdout}. ${nextCommands[command] ? `Once they are ready, A good command to look at next is ${nextCommands[command]}` : ''}`);
+            return formatTextContents(`Display this help output for the user amd wait for them to acknowledge: ${stdout}. ${nextCommands[command] ? `Once they are ready, A good command to look at next is ${nextCommands[command]}` : ''}`);
         }
-        return formatTextContents(absoluteCurrentWorkingDirectory, 'Is there another command you would like to learn more about?');
+        return formatTextContents('Is there another command you would like to learn more about?');
     }
     register() {
         return this.mcpServer.registerTool(toolName, {
             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.d.ts

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

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

@@ -1,12 +1,22 @@
+import path from 'path';
+import z from 'zod';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib';
+import { getProjectConfig } from '../../../lib/projects/config.js';
 import { Tool } from '../../types.js';
 import { runCommandInDir } from '../../utils/project.js';
 import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
-import z from 'zod';
-import { formatTextContents } from '../../utils/content.js';
+import { formatTextContent, formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { addFlag } from '../../utils/command.js';
 const inputSchema = {
     absoluteProjectPath,
     absoluteCurrentWorkingDirectory,
+    uploadMessage: z
+        .string()
+        .describe('A 1 sentence message that concisely describes the changes that are being uploaded.'),
+    profile: z
+        .optional(z.string())
+        .describe('CRITICAL: If the user has not explicitly specified a profile name, you MUST ask them which profile to use. NEVER automatically choose a profile based on files you see in the directory (e.g., seeing "hsprofile.prod.json" does NOT mean you should use "prod"). The profile to be used for the upload. All projects configured to use profiles must specify a profile when uploading. Profile files have the following format: "hsprofile.<profile>.json".'),
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({
@@ -17,16 +27,52 @@ export class UploadProjectTools extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, }) {
+    async handler({ absoluteProjectPath, profile, uploadMessage, }) {
         await trackToolUsage(toolName);
-        const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, `hs project upload --force-create`);
-        return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+        let command = addFlag('hs project upload', 'force-create', true);
+        const content = [];
+        if (uploadMessage) {
+            command = addFlag(command, 'message', uploadMessage);
+        }
+        if (profile) {
+            command = addFlag(command, 'profile', profile);
+        }
+        else {
+            let hasProfiles = false;
+            try {
+                const { projectConfig } = await getProjectConfig(absoluteProjectPath);
+                if (projectConfig) {
+                    const profiles = await getAllHsProfiles(path.join(absoluteProjectPath, projectConfig.srcDir));
+                    hasProfiles = profiles.length > 0;
+                }
+            }
+            catch (e) {
+                // If any of these checks fail, the safest thing to do is to assume there are no profiles.
+                hasProfiles = false;
+            }
+            if (hasProfiles) {
+                content.push(formatTextContent(`Ask the user which profile they would like to use for the upload.`));
+            }
+        }
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
+        return formatTextContents(stdout, stderr);
     }
     register() {
         return this.mcpServer.registerTool(toolName, {
             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.d.ts

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

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

@@ -15,14 +15,14 @@ export class ValidateProjectTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, }) {
+    async handler({ absoluteProjectPath, }) {
         await trackToolUsage(toolName);
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, 'hs project validate');
-            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() {
@@ -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 {};