@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/mcp-server/tools/index.js

@@ -0,0 +1,38 @@
+import { UploadProjectTools } from './project/UploadProjectTools.js';
+import { CreateProjectTool } from './project/CreateProjectTool.js';
+import { GuidedWalkthroughTool } from './project/GuidedWalkthroughTool.js';
+import { DeployProjectTool } from './project/DeployProjectTool.js';
+import { AddFeatureToProjectTool } from './project/AddFeatureToProjectTool.js';
+import { ValidateProjectTool } from './project/ValidateProjectTool.js';
+import { GetConfigValuesTool } from './project/GetConfigValuesTool.js';
+import { DocsSearchTool } from './project/DocsSearchTool.js';
+import { DocFetchTool } from './project/DocFetchTool.js';
+import { HsListTool } from './cms/HsListTool.js';
+import { HsCreateModuleTool } from './cms/HsCreateModuleTool.js';
+import { HsCreateTemplateTool } from './cms/HsCreateTemplateTool.js';
+import { HsCreateFunctionTool } from './cms/HsCreateFunctionTool.js';
+import { HsListFunctionsTool } from './cms/HsListFunctionsTool.js';
+import { HsFunctionLogsTool } from './cms/HsFunctionLogsTool.js';
+export function registerProjectTools(mcpServer) {
+    return [
+        new UploadProjectTools(mcpServer).register(),
+        new CreateProjectTool(mcpServer).register(),
+        new GuidedWalkthroughTool(mcpServer).register(),
+        new DeployProjectTool(mcpServer).register(),
+        new AddFeatureToProjectTool(mcpServer).register(),
+        new ValidateProjectTool(mcpServer).register(),
+        new GetConfigValuesTool(mcpServer).register(),
+        new DocsSearchTool(mcpServer).register(),
+        new DocFetchTool(mcpServer).register(),
+    ];
+}
+export function registerCmsTools(mcpServer) {
+    return [
+        new HsListTool(mcpServer).register(),
+        new HsCreateModuleTool(mcpServer).register(),
+        new HsCreateTemplateTool(mcpServer).register(),
+        new HsCreateFunctionTool(mcpServer).register(),
+        new HsListFunctionsTool(mcpServer).register(),
+        new HsFunctionLogsTool(mcpServer).register(),
+    ];
+}

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

@@ -0,0 +1,29 @@
+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;
+    addApp: z.ZodBoolean;
+    distribution: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"marketplace">, z.ZodLiteral<"private">]>>;
+    auth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"static">, z.ZodLiteral<"oauth">]>>;
+    features: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">, z.ZodLiteral<"workflow-action">, z.ZodLiteral<"workflow-action-tool">, z.ZodLiteral<"app-object">, z.ZodLiteral<"app-event">, z.ZodLiteral<"scim">, z.ZodLiteral<"page">]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    absoluteProjectPath: string;
+    addApp: boolean;
+    auth?: "oauth" | "static" | undefined;
+    distribution?: "marketplace" | "private" | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+}, {
+    absoluteProjectPath: string;
+    addApp: boolean;
+    auth?: "oauth" | "static" | undefined;
+    distribution?: "marketplace" | "private" | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+}>;
+export type AddFeatureInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class AddFeatureToProjectTool extends Tool<AddFeatureInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteProjectPath, distribution, auth, features, addApp, }: AddFeatureInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,76 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../lib/constants.js';
+import { addFlag } from '../../utils/command.js';
+import { absoluteProjectPath, features } from './constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteProjectPath,
+    addApp: z
+        .boolean()
+        .describe('Should an app be added?  If there is no app in the project, an app must be added to add a feature'),
+    distribution: z
+        .optional(z.union([
+        z.literal(APP_DISTRIBUTION_TYPES.MARKETPLACE),
+        z.literal(APP_DISTRIBUTION_TYPES.PRIVATE),
+    ]))
+        .describe('If not specified by the user, DO NOT choose for them.  This cannot be changed after a project is uploaded. Private is used if you do not wish to distribute your application on the HubSpot marketplace. '),
+    auth: z
+        .optional(z.union([
+        z.literal(APP_AUTH_TYPES.STATIC),
+        z.literal(APP_AUTH_TYPES.OAUTH),
+    ]))
+        .describe('If not specified by the user, DO NOT choose for them.  This cannot be changed after a project is uploaded. Static uses a static non changing authentication token, and is only available for private distribution. '),
+    features,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'add-feature-to-project';
+export class AddFeatureToProjectTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteProjectPath, distribution, auth, features, addApp, }) {
+        try {
+            await trackToolUsage(toolName);
+            let command = `hs project add`;
+            const content = [];
+            if (distribution) {
+                command = addFlag(command, 'distribution', distribution);
+            }
+            else if (addApp) {
+                content.push(formatTextContent(`Ask the user how they would you like to distribute the application. Options are ${APP_DISTRIBUTION_TYPES.MARKETPLACE} and ${APP_DISTRIBUTION_TYPES.PRIVATE}`));
+            }
+            if (auth) {
+                command = addFlag(command, 'auth', auth);
+            }
+            else if (addApp) {
+                content.push(formatTextContent(`Ask the user which auth type they would like to use. Options are ${APP_AUTH_TYPES.STATIC} and ${APP_AUTH_TYPES.OAUTH}`));
+            }
+            if (content.length > 0) {
+                return {
+                    content,
+                };
+            }
+            // If features isn't provided, pass an empty array to bypass the prompt
+            command = addFlag(command, 'features', features || []);
+            const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Add feature to HubSpot Project',
+            description: `Adds a feature to an existing HubSpot project. 
+          Only works for projects with platformVersion '2025.2' and beyond`,
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,35 @@
+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;
+    name: z.ZodOptional<z.ZodString>;
+    destination: z.ZodString;
+    projectBase: z.ZodUnion<[z.ZodLiteral<"empty">, z.ZodLiteral<"app">]>;
+    distribution: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"marketplace">, z.ZodLiteral<"private">]>>;
+    auth: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"static">, z.ZodLiteral<"oauth">]>>>;
+    features: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">, z.ZodLiteral<"workflow-action">, z.ZodLiteral<"workflow-action-tool">, z.ZodLiteral<"app-object">, z.ZodLiteral<"app-event">, z.ZodLiteral<"scim">, z.ZodLiteral<"page">]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    projectBase: "app" | "empty";
+    absoluteCurrentWorkingDirectory: string;
+    destination: string;
+    name?: string | undefined;
+    auth?: "oauth" | "static" | undefined;
+    distribution?: "marketplace" | "private" | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+}, {
+    projectBase: "app" | "empty";
+    absoluteCurrentWorkingDirectory: string;
+    destination: string;
+    name?: string | undefined;
+    auth?: "oauth" | "static" | undefined;
+    distribution?: "marketplace" | "private" | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+}>;
+export type CreateProjectInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class CreateProjectTool extends Tool<CreateProjectInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }: CreateProjectInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,93 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../lib/constants.js';
+import { addFlag } from '../../utils/command.js';
+import { absoluteCurrentWorkingDirectory, features } from './constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    name: z
+        .string()
+        .describe('If not specified by the user, DO NOT choose for them.  Changing this is potentially destructive.The name of the project to be created.  This name is how your project will appear in HubSpot. ')
+        .optional(),
+    destination: z
+        .string()
+        .describe('DO NOT use the current directory unless the user has explicitly stated to do so. Relative path to the directory the project will be created in.'),
+    projectBase: z
+        .union([z.literal(EMPTY_PROJECT), z.literal(PROJECT_WITH_APP)])
+        .describe('Empty will create an empty project, and app will create a project with an app inside of it.'),
+    distribution: z
+        .optional(z.union([
+        z.literal(APP_DISTRIBUTION_TYPES.MARKETPLACE),
+        z.literal(APP_DISTRIBUTION_TYPES.PRIVATE),
+    ]))
+        .describe('If not specified by the user, DO NOT choose for them.  This cannot be changed after a project is uploaded. Private is used if you do not wish to distribute your application on the HubSpot marketplace. '),
+    auth: z
+        .optional(z.union([
+        z.literal(APP_AUTH_TYPES.STATIC),
+        z.literal(APP_AUTH_TYPES.OAUTH),
+    ]))
+        .describe('If not specified by the user, DO NOT choose for them.  This cannot be changed after a project is uploaded. Static uses a static non changing authentication token, and is only available for private distribution. ')
+        .optional(),
+    features,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-project';
+export class CreateProjectTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        let command = addFlag('hs project create', 'platform-version', '2025.2');
+        const content = [];
+        if (name) {
+            command = addFlag(command, 'name', name);
+        }
+        else {
+            content.push(formatTextContent(`Ask the user what they would like to name the project.`));
+        }
+        if (destination) {
+            command = addFlag(command, 'dest', destination);
+        }
+        if (projectBase) {
+            command = addFlag(command, 'project-base', projectBase);
+        }
+        if (distribution) {
+            command = addFlag(command, 'distribution', distribution);
+        }
+        else if (projectBase === PROJECT_WITH_APP) {
+            content.push(formatTextContent(`Ask the user how they would you like to distribute the application? Options are ${APP_DISTRIBUTION_TYPES.MARKETPLACE} and ${APP_DISTRIBUTION_TYPES.PRIVATE}`));
+        }
+        if (auth) {
+            command = addFlag(command, 'auth', auth);
+        }
+        else if (projectBase === PROJECT_WITH_APP) {
+            content.push(formatTextContent(`Ask the user which auth type they would like to use? Options are ${APP_AUTH_TYPES.STATIC} and ${APP_AUTH_TYPES.OAUTH}`));
+        }
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Always pass features, even if it is an empty array to bypass the prompts
+        command = addFlag(command, 'features', features || []);
+        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 Project',
+            description: 'Creates a HubSpot project with the provided name and outputs it in the provided destination',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,20 @@
+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;
+    buildNumber: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    absoluteProjectPath: string;
+    buildNumber?: number | undefined;
+}, {
+    absoluteProjectPath: string;
+    buildNumber?: number | undefined;
+}>;
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DeployProjectTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteProjectPath, buildNumber, }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,49 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { addFlag } from '../../utils/command.js';
+import { absoluteProjectPath } from './constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteProjectPath,
+    buildNumber: z
+        .optional(z.number())
+        .describe('The build number to be deployed.  This can be found in the project details page using `hs project open`.  If no build number is specified, the most recent build is deployed'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'deploy-project';
+export class DeployProjectTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteProjectPath, buildNumber, }) {
+        await trackToolUsage(toolName);
+        let command = `hs project deploy`;
+        const content = [];
+        if (!buildNumber) {
+            const { stdout } = await runCommandInDir(absoluteProjectPath, `hs project list-builds --limit 100`);
+            content.push(formatTextContent(`Ask the user which build number they would like to deploy?  Build information: ${stdout}`));
+        }
+        else {
+            command = addFlag(command, 'build', buildNumber);
+        }
+        if (content.length) {
+            return {
+                content,
+            };
+        }
+        const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
+        return formatTextContents(stdout, stderr);
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Deploy a build of HubSpot Project',
+            description: 'Takes a build number and a project name and deploys that build of the project. DO NOT run this tool unless the user specifies they would like to deploy the project.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    docUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docUrl: string;
+}, {
+    docUrl: string;
+}>;
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocFetchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docUrl }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,49 @@
+import z from 'zod';
+import { Tool } from '../../types.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { docUrl } from './constants.js';
+import { http } from '@hubspot/local-dev-lib/http/unauthed';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+const inputSchema = {
+    docUrl,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'fetch-doc';
+export class DocFetchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docUrl }) {
+        await trackToolUsage(toolName);
+        try {
+            // Append .md extension to the URL
+            const markdownUrl = `${docUrl}.md`;
+            const response = await http.get({
+                url: markdownUrl,
+            });
+            const content = response.data;
+            if (!content || content.trim().length === 0) {
+                return formatTextContents('Document is empty or contains no content.');
+            }
+            return formatTextContents(content);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error fetching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,29 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    docsSearchQuery: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    docsSearchQuery: string;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    docsSearchQuery: string;
+}>;
+export interface DocsSearchResponse {
+    results: {
+        title: string;
+        content: string;
+        description: string;
+        url: string;
+        score: number;
+    }[];
+}
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocsSearchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteCurrentWorkingDirectory, docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,62 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import z from 'zod';
+import { Tool } from '../../types.js';
+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';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    docsSearchQuery,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'search-docs';
+export class DocsSearchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteCurrentWorkingDirectory, docsSearchQuery, }) {
+        await trackToolUsage(toolName, { mode: docsSearchQuery });
+        const accountId = getAccountIdFromCliConfig(absoluteCurrentWorkingDirectory);
+        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(authErrorMessage);
+        }
+        try {
+            const response = await http.post(accountId, {
+                url: 'dev/docs/llms/v1/docs-search',
+                data: {
+                    query: docsSearchQuery,
+                },
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                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(successMessage);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle different status codes
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error searching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

package/mcp-server/tools/project/GetConfigValuesTool.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;
+    platformVersion: z.ZodString;
+    featureType: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    platformVersion: string;
+    absoluteCurrentWorkingDirectory: string;
+    featureType: string;
+}, {
+    platformVersion: string;
+    absoluteCurrentWorkingDirectory: string;
+    featureType: string;
+}>;
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class GetConfigValuesTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { formatTextContents } from '../../utils/content.js';
+import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
+import { useV3Api } from '../../../lib/projects/platformVersion.js';
+import { getAccountIdFromCliConfig } from '../../utils/cliConfig.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    platformVersion: z
+        .string()
+        .describe('The platform version for the project. Located in the hsproject.json file.'),
+    featureType: z
+        .string()
+        .describe('The type of the component to fetch the JSON schema for. This will be the `type` field in the -hsmeta.json file'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'get-feature-config-schema';
+export class GetConfigValuesTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }) {
+        try {
+            if (!useV3Api(platformVersion)) {
+                return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
+            }
+            const accountId = getAccountIdFromCliConfig(absoluteCurrentWorkingDirectory);
+            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(authErrorMessage);
+            }
+            const schema = await getIntermediateRepresentationSchema({
+                platformVersion,
+                projectSourceDir: '',
+                accountId,
+            });
+            const internalComponentType = mapToInternalType(featureType);
+            if (schema[internalComponentType]) {
+                return formatTextContents(JSON.stringify({ config: schema[internalComponentType] }));
+            }
+        }
+        catch (error) { }
+        return formatTextContents(`Unable to locate JSON schema for type ${featureType}`);
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Fetch the JSON Schema for component',
+            description: `Fetches and returns the JSON schema for the provided feature 'type' found in -hsmeta.json file.
+        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,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    command: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"hs init">, z.ZodLiteral<"hs auth">, z.ZodLiteral<"hs project create">, z.ZodLiteral<"hs project upload">]>>;
+}, "strip", z.ZodTypeAny, {
+    command?: "hs auth" | "hs project upload" | "hs project create" | "hs init" | undefined;
+}, {
+    command?: "hs auth" | "hs project upload" | "hs project create" | "hs init" | undefined;
+}>;
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class GuidedWalkthroughTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ command }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};