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

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

@@ -18,7 +18,7 @@ export class DocFetchTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ docUrl, absoluteCurrentWorkingDirectory, }) {
+    async handler({ docUrl }) {
         await trackToolUsage(toolName);
         try {
             // Append .md extension to the URL
@@ -28,16 +28,16 @@ export class DocFetchTool extends Tool {
             });
             const content = response.data;
             if (!content || content.trim().length === 0) {
-                return formatTextContents(absoluteCurrentWorkingDirectory, 'Document is empty or contains no content.');
+                return formatTextContents('Document is empty or contains no content.');
             }
-            return formatTextContents(absoluteCurrentWorkingDirectory, content);
+            return formatTextContents(content);
         }
         catch (error) {
             if (isHubSpotHttpError(error)) {
-                return formatTextContents(absoluteCurrentWorkingDirectory, error.toString());
+                return formatTextContents(error.toString());
             }
             const errorMessage = `Error fetching documentation: ${error instanceof Error ? error.message : String(error)}`;
-            return formatTextContents(absoluteCurrentWorkingDirectory, errorMessage);
+            return formatTextContents(errorMessage);
         }
     }
     register() {
@@ -45,6 +45,10 @@ export class DocFetchTool extends Tool {
             title: 'Fetch HubSpot Developer Documentation (single file)',
             description: 'Always use this immediately after `search-docs` and before creating a plan, writing code, or answering technical questions. This tool retrieves the full, authoritative content of a HubSpot Developer Documentation page from its URL, ensuring responses are accurate, up-to-date, and grounded in the official docs.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -23,7 +23,7 @@ export interface DocsSearchResponse {
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class DocsSearchTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
-    handler({ absoluteCurrentWorkingDirectory, docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -5,7 +5,7 @@ import { formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { absoluteCurrentWorkingDirectory, docsSearchQuery, } from './constants.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getAccountIdFromCliConfig } from '../../utils/cliConfig.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
     docsSearchQuery,
@@ -19,12 +19,12 @@ export class DocsSearchTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteCurrentWorkingDirectory, docsSearchQuery, }) {
+    async handler({ docsSearchQuery, }) {
         await trackToolUsage(toolName, { mode: docsSearchQuery });
-        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);
         }
         try {
             const response = await http.post(accountId, {
@@ -35,21 +35,21 @@ export class DocsSearchTool extends Tool {
             });
             const results = response.data.results;
             if (!results || results.length === 0) {
-                return formatTextContents(absoluteCurrentWorkingDirectory, 'No documentation found for your query.');
+                return formatTextContents('No documentation found for your query.');
             }
             const formattedResults = results
                 .map(result => `**${result.title}**\n${result.description}\nURL: ${result.url}\nScore: ${result.score}\n\n${result.content}\n---\n`)
                 .join('\n');
             const successMessage = `Found ${results.length} documentation results:\n\n${formattedResults}`;
-            return formatTextContents(absoluteCurrentWorkingDirectory, successMessage);
+            return formatTextContents(successMessage);
         }
         catch (error) {
             if (isHubSpotHttpError(error)) {
                 // Handle different status codes
-                return formatTextContents(absoluteCurrentWorkingDirectory, error.toString());
+                return formatTextContents(error.toString());
             }
             const errorMessage = `Error searching documentation: ${error instanceof Error ? error.message : String(error)}`;
-            return formatTextContents(absoluteCurrentWorkingDirectory, errorMessage);
+            return formatTextContents(errorMessage);
         }
     }
     register() {
@@ -57,6 +57,10 @@ export class DocsSearchTool extends Tool {
             title: 'Search HubSpot Developer Documentation',
             description: 'Use this first whenever you need details about HubSpot APIs, SDKs, integrations, or developer platform features. This searches the official HubSpot Developer Documentation and returns the most relevant pages, each with a URL for use in `fetch-doc`. Always follow this with a fetch to get the full, authoritative content before making plans or writing answers.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

@@ -20,7 +20,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type GetApiUsagePatternsByAppIdInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class GetApiUsagePatternsByAppIdTool extends Tool<GetApiUsagePatternsByAppIdInputSchema> {
     constructor(mcpServer: McpServer);
-    handler({ absoluteCurrentWorkingDirectory, appId, startDate, endDate, }: GetApiUsagePatternsByAppIdInputSchema): Promise<TextContentResponse>;
+    handler({ appId, startDate, endDate, }: GetApiUsagePatternsByAppIdInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -4,7 +4,7 @@ import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { http } from '@hubspot/local-dev-lib/http';
 import { formatTextContents } from '../../utils/content.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { absoluteCurrentWorkingDirectory } from './constants.js';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
@@ -30,14 +30,14 @@ export class GetApiUsagePatternsByAppIdTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteCurrentWorkingDirectory, appId, startDate, endDate, }) {
+    async handler({ appId, startDate, endDate, }) {
         await trackToolUsage(toolName);
         try {
             // Get account ID from CLI config
-            const accountId = getAccountId();
+            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 response = await http.get(accountId, {
                 url: `app/feature/utilization/public/v3/insights/app/${appId}/usage-patterns`,
@@ -49,15 +49,15 @@ export class GetApiUsagePatternsByAppIdTool extends Tool {
             // Format the response for display
             const { data } = response;
             const formattedResult = JSON.stringify(data, null, 2);
-            return formatTextContents(absoluteCurrentWorkingDirectory, formattedResult);
+            return formatTextContents(formattedResult);
         }
         catch (error) {
             if (isHubSpotHttpError(error)) {
                 // Handle HubSpot-specific HTTP errors
-                return formatTextContents(absoluteCurrentWorkingDirectory, error.toString());
+                return formatTextContents(error.toString());
             }
             const errorMessage = `${error instanceof Error ? error.message : String(error)}`;
-            return formatTextContents(absoluteCurrentWorkingDirectory, errorMessage);
+            return formatTextContents(errorMessage);
         }
     }
     register() {
@@ -65,6 +65,10 @@ export class GetApiUsagePatternsByAppIdTool extends Tool {
             title: 'Get API Usage Patterns by App ID',
             description: 'Retrieves detailed API usage pattern analytics for a specific HubSpot application. Requires an appId (string) to identify the target application. Optionally accepts startDate and endDate parameters in YYYY-MM-DD format to filter results within a specific time range. Returns patternSummaries object containing usage statistics including portalPercentage (percentage of portals using this pattern) and numOfPortals (total count of portals) for different usage patterns. This data helps analyze how the application is being used across different HubSpot portals and can inform optimization decisions.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

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

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

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

@@ -4,7 +4,7 @@ import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { http } from '@hubspot/local-dev-lib/http';
 import { formatTextContents } from '../../utils/content.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { absoluteCurrentWorkingDirectory } from './constants.js';
 const inputSchema = { absoluteCurrentWorkingDirectory };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -14,14 +14,14 @@ export class GetApplicationInfoTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteCurrentWorkingDirectory, }) {
+    async handler({}) {
         await trackToolUsage(toolName);
         try {
             // Get account ID from CLI config
-            const accountId = getAccountId();
+            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 response = await http.get(accountId, {
                 url: `app/feature/utilization/public/v3/insights/apps`,
@@ -29,15 +29,15 @@ export class GetApplicationInfoTool extends Tool {
             // Format the response for display
             const { data } = response;
             const formattedResult = JSON.stringify(data, null, 2);
-            return formatTextContents(absoluteCurrentWorkingDirectory, formattedResult);
+            return formatTextContents(formattedResult);
         }
         catch (error) {
             if (isHubSpotHttpError(error)) {
                 // Handle HubSpot-specific HTTP errors
-                return formatTextContents(absoluteCurrentWorkingDirectory, error.toString());
+                return formatTextContents(error.toString());
             }
             const errorMessage = `${error instanceof Error ? error.message : String(error)}`;
-            return formatTextContents(absoluteCurrentWorkingDirectory, errorMessage);
+            return formatTextContents(errorMessage);
         }
     }
     register() {
@@ -45,6 +45,10 @@ export class GetApplicationInfoTool extends Tool {
             title: 'Get Applications Information',
             description: 'Retrieves a list of all HubSpot applications available in the current account. Returns an array of applications, where each application contains an appId (numeric identifier) and appName (string). This information is useful for identifying available applications before using other tools that require specific application IDs, such as getting API usage patterns. No input parameters are required - this tool fetches all applications from the HubSpot Insights API.',
             inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
         }, this.handler);
     }
 }

package/mcp-server/tools/project/GetBuildStatusTool.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<{
+    absoluteProjectPath: z.ZodString;
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    buildId: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    absoluteProjectPath: string;
+    absoluteCurrentWorkingDirectory: string;
+    buildId?: number | undefined;
+}, {
+    absoluteProjectPath: string;
+    absoluteCurrentWorkingDirectory: string;
+    limit?: number | undefined;
+    buildId?: number | undefined;
+}>;
+export type GetBuildStatusInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class GetBuildStatusTool extends Tool<GetBuildStatusInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, limit, }: GetBuildStatusInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,164 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { formatTextContents } from '../../utils/content.js';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { fetchProjectBuilds, getBuildStatus, } from '@hubspot/local-dev-lib/api/projects';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import moment from 'moment';
+import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+const TOOL_NAME = 'get-build-status';
+const inputSchema = {
+    absoluteProjectPath,
+    absoluteCurrentWorkingDirectory,
+    buildId: z
+        .number()
+        .optional()
+        .describe('Optional: Specific build ID to inspect. If omitted, shows recent builds to help identify the latest build.'),
+    limit: z
+        .number()
+        .optional()
+        .default(3)
+        .describe('Number of recent builds to fetch when buildId is not specified.'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+function getStatusIcon(status) {
+    return status === 'SUCCESS' ? '✓' : '⚠️';
+}
+function formatDuration(startedAt, finishedAt) {
+    const duration = moment.duration(moment(finishedAt).diff(moment(startedAt)));
+    const days = Math.floor(duration.asDays());
+    const hours = duration.hours();
+    const minutes = duration.minutes();
+    const seconds = duration.seconds();
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (seconds > 0 || parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+function formatSubbuilds(subbuilds, indent = '  ') {
+    const lines = [];
+    subbuilds.forEach(sub => {
+        const icon = getStatusIcon(sub.status);
+        lines.push(`${indent}${icon} ${sub.buildName} (${sub.buildType}): ${sub.status}`);
+        if (sub.errorMessage) {
+            lines.push(`${indent}  Error: ${sub.errorMessage}`);
+        }
+    });
+    return lines;
+}
+function formatBuildList(builds) {
+    const lines = [];
+    builds.forEach((build, index) => {
+        const icon = getStatusIcon(build.status);
+        const timeAgo = moment(build.finishedAt).fromNow();
+        const duration = formatDuration(build.startedAt, build.finishedAt);
+        lines.push(`Build #${build.buildId} - ${build.status} ${icon}`);
+        lines.push(`  Finished: ${timeAgo} (Duration: ${duration})`);
+        if (build.uploadMessage) {
+            lines.push(`  Message: ${build.uploadMessage}`);
+        }
+        if (build.status === 'FAILURE' && build.buildErrorMessage) {
+            lines.push(`  Error: ${build.buildErrorMessage}`);
+        }
+        if (build.subbuildStatuses.length > 0) {
+            lines.push(`  Subbuilds:`);
+            lines.push(...formatSubbuilds(build.subbuildStatuses, '    '));
+        }
+        if (index < builds.length - 1) {
+            lines.push('');
+        }
+    });
+    return lines.join('\n');
+}
+function formatBuildDetails(build) {
+    const lines = [];
+    const icon = getStatusIcon(build.status);
+    lines.push(`Build #${build.buildId} Details\n`);
+    lines.push(`Status: ${build.status} ${icon}`);
+    lines.push(`Platform Version: ${build.platformVersion}`);
+    lines.push(`Started: ${moment(build.startedAt).format('YYYY-MM-DD HH:mm:ss UTC')}`);
+    lines.push(`Finished: ${moment(build.finishedAt).format('YYYY-MM-DD HH:mm:ss UTC')}`);
+    lines.push(`Duration: ${formatDuration(build.startedAt, build.finishedAt)}`);
+    if (build.uploadMessage) {
+        lines.push(`\nUpload Message:\n${build.uploadMessage}`);
+    }
+    if (build.buildErrorMessage) {
+        lines.push(`\nBuild Error:\n${build.buildErrorMessage}`);
+    }
+    if (build.subbuildStatuses.length > 0) {
+        lines.push(`\nSubbuilds:`);
+        lines.push(...formatSubbuilds(build.subbuildStatuses));
+    }
+    else {
+        lines.push(`\nSubbuilds: None`);
+    }
+    return lines.join('\n');
+}
+export class GetBuildStatusTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, limit, }) {
+        await trackToolUsage(TOOL_NAME);
+        try {
+            const accountId = getConfigDefaultAccountIfExists()?.accountId;
+            if (!accountId) {
+                return formatTextContents(absoluteCurrentWorkingDirectory, 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`');
+            }
+            const { projectConfig, projectDir } = await getProjectConfig(absoluteProjectPath);
+            validateProjectConfig(projectConfig, projectDir);
+            const projectName = projectConfig.name;
+            let output;
+            if (buildId) {
+                const response = await getBuildStatus(accountId, projectName, buildId);
+                const build = response.data;
+                output = formatBuildDetails(build);
+            }
+            else {
+                const response = await fetchProjectBuilds(accountId, projectName, {
+                    limit,
+                });
+                const { results } = response.data;
+                if (!results || results.length === 0) {
+                    return formatTextContents(absoluteCurrentWorkingDirectory, `No builds found for project '${projectName}'.`);
+                }
+                output = `Recent builds for '${projectName}':\n\n${formatBuildList(results)}`;
+            }
+            return formatTextContents(absoluteCurrentWorkingDirectory, output);
+        }
+        catch (error) {
+            let errorMessage;
+            if (isHubSpotHttpError(error)) {
+                errorMessage = error.toString();
+            }
+            else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else {
+                errorMessage = String(error);
+            }
+            return formatTextContents(absoluteCurrentWorkingDirectory, errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(TOOL_NAME, {
+            title: 'Get HubSpot Projects Build Status and Errors',
+            description: 'Retrieves build status and error messages for HubSpot projects. When buildId is omitted, shows recent builds with their status(default 3) - use this to find the latest builds when troubleshooting. When buildId is provided, shows detailed error information for that specific build. Displays buildErrorMessage and subbuild failures to help diagnose build issues.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+                idempotentHint: true,
+            },
+        }, this.handler);
+    }
+}

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

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

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);
     }
 }