@hubspot/cli 7.7.23-experimental.0 → 7.7.24-experimental.0

package/lib/projects/create/v3.js

@@ -1,5 +1,5 @@
 import { Separator } from '@inquirer/prompts';
-import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, } from '../../constants.js';
+import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../constants.js';
 import { commands, lib } from '../../../lang/en.js';
 import { listPrompt } from '../../prompts/promptUtils.js';
 import chalk from 'chalk';
@@ -8,8 +8,6 @@ import path from 'path';
 import { getConfigForPlatformVersion } from './legacy.js';
 import { logError } from '../../errorHandlers/index.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-export const EMPTY_PROJECT = 'empty';
-export const PROJECT_WITH_APP = 'app';
 export async function createV3App(providedAuth, providedDistribution) {
     let authType;
     if (providedAuth &&

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

@@ -32,5 +32,6 @@ declare class LocalDevProcess {
     uploadProject(): Promise<boolean>;
     addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
     sendDevServerMessage(message: LocalDevServerMessage): void;
+    removeStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
 }
 export default LocalDevProcess;

package/lib/projects/localDev/LocalDevProcess.js

@@ -208,5 +208,8 @@ class LocalDevProcess {
     sendDevServerMessage(message) {
         this.state.devServerMessage = message;
     }
+    removeStateListener(key, listener) {
+        this.state.removeListener(key, listener);
+    }
 }
 export default LocalDevProcess;

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

@@ -51,5 +51,6 @@ declare class LocalDevState {
     get devServerMessage(): string;
     set devServerMessage(message: LocalDevServerMessage);
     addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+    removeListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
 }
 export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -111,5 +111,10 @@ class LocalDevState {
             listener(this[key]);
         }
     }
+    removeListener(key, listener) {
+        if (this._listeners[key]) {
+            this._listeners[key].splice(this._listeners[key].indexOf(listener), 1);
+        }
+    }
 }
 export default LocalDevState;

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

@@ -1,18 +1,18 @@
 import LocalDevProcess from './LocalDevProcess.js';
 declare class LocalDevWebsocketServer {
     private server?;
-    private _websocket?;
     private debug?;
     private localDevProcess;
     private ALLOWED_ORIGINS;
     constructor(localDevProcess: LocalDevProcess, debug?: boolean);
-    private websocket;
     private log;
     private logError;
     private sendMessage;
     private handleUpload;
     private setupMessageHandlers;
     private sendProjectData;
+    private setupProjectNodesListener;
+    private setupAppDataListener;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -8,7 +8,6 @@ const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
 const LOG_PREFIX = '[LocalDevWebsocketServer]';
 class LocalDevWebsocketServer {
     server;
-    _websocket;
     debug;
     localDevProcess;
     ALLOWED_ORIGINS = [
@@ -21,12 +20,6 @@ class LocalDevWebsocketServer {
         this.localDevProcess = localDevProcess;
         this.debug = debug;
     }
-    websocket() {
-        if (!this._websocket) {
-            throw new Error(lib.LocalDevWebsocketServer.errors.notInitialized(LOG_PREFIX));
-        }
-        return this._websocket;
-    }
     log(message) {
         if (this.debug) {
             logger.log(LOG_PREFIX, message);
@@ -37,24 +30,24 @@ class LocalDevWebsocketServer {
             logger.error(LOG_PREFIX, message);
         }
     }
-    sendMessage(message) {
-        this.websocket().send(JSON.stringify(message));
+    sendMessage(websocket, message) {
+        websocket.send(JSON.stringify(message));
     }
-    async handleUpload() {
+    async handleUpload(websocket) {
         const uploadSuccess = await this.localDevProcess.uploadProject();
         if (uploadSuccess) {
-            this.sendMessage({
+            this.sendMessage(websocket, {
                 type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
             });
         }
         else {
-            this.sendMessage({
+            this.sendMessage(websocket, {
                 type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
             });
         }
     }
-    setupMessageHandlers() {
-        this.websocket().on('message', data => {
+    setupMessageHandlers(websocket) {
+        websocket.on('message', data => {
             try {
                 const message = JSON.parse(data.toString());
                 if (!message.type) {
@@ -63,7 +56,7 @@ class LocalDevWebsocketServer {
                 }
                 switch (message.type) {
                     case LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
-                        this.handleUpload();
+                        this.handleUpload(websocket);
                         break;
                     case LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.VIEWED_WELCOME_SCREEN:
                         addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
@@ -77,8 +70,8 @@ class LocalDevWebsocketServer {
             }
         });
     }
-    sendProjectData() {
-        this.sendMessage({
+    sendProjectData(websocket) {
+        this.sendMessage(websocket, {
             type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
             data: {
                 projectName: this.localDevProcess.projectName,
@@ -88,19 +81,33 @@ class LocalDevWebsocketServer {
             },
         });
     }
-    setupStateListeners() {
-        this.localDevProcess.addStateListener('projectNodes', nodes => {
-            this.sendMessage({
+    setupProjectNodesListener(websocket) {
+        const listener = (nodes) => {
+            this.sendMessage(websocket, {
                 type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
                 data: nodes,
             });
-        }, true);
-        this.localDevProcess.addStateListener('appData', appData => {
-            this.sendMessage({
+        };
+        this.localDevProcess.addStateListener('projectNodes', listener, true);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('projectNodes', listener);
+        });
+    }
+    setupAppDataListener(websocket) {
+        const listener = (appData) => {
+            this.sendMessage(websocket, {
                 type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
                 data: appData,
             });
-        }, true);
+        };
+        this.localDevProcess.addStateListener('appData', listener, true);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('appData', listener);
+        });
+    }
+    setupStateListeners(websocket) {
+        this.setupProjectNodesListener(websocket);
+        this.setupAppDataListener(websocket);
     }
     async start() {
         const portManagerIsRunning = await isPortManagerServerRunning();
@@ -117,17 +124,16 @@ class LocalDevWebsocketServer {
                 ws.close(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
                 return;
             }
-            this._websocket = ws;
-            this.sendProjectData();
-            this.setupMessageHandlers();
-            this.setupStateListeners();
+            this.sendProjectData(ws);
+            this.setupMessageHandlers(ws);
+            this.setupStateListeners(ws);
             this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
+        this.server.on('close', () => { });
     }
     shutdown() {
         this.server?.close();
         this.server = undefined;
-        this._websocket = undefined;
     }
 }
 export default LocalDevWebsocketServer;

package/lib/projects/upload.js

@@ -14,6 +14,7 @@ import { ensureProjectExists } from './ensureProjectExists.js';
 import { uiLogger } from '../ui/logger.js';
 import { useV3Api } from './buildAndDeploy.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
+import ProjectValidationError from '../errors/ProjectValidationError.js';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     SpinniesManager.init({});
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
@@ -107,17 +108,13 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
 export function validateSourceDirectory(srcDir, projectConfig) {
     const filenames = fs.readdirSync(srcDir);
     if (!filenames || filenames.length === 0) {
-        const validationError = new Error(lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
-        validationError.name = 'ProjectValidationError';
-        throw validationError;
+        throw new ProjectValidationError(lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
     }
 }
 export async function validateNoHSMetaMismatch(srcDir, projectConfig) {
     const hasHsMetaFiles = await projectContainsHsMetaFiles(srcDir);
     if (!useV3Api(projectConfig.platformVersion) && hasHsMetaFiles) {
-        const validationError = new Error(lib.projectUpload.wrongPlatformVersionMetaFiles);
-        validationError.name = 'ProjectValidationError';
-        throw validationError;
+        throw new ProjectValidationError(lib.projectUpload.wrongPlatformVersionMetaFiles);
     }
 }
 export async function handleTranslate(projectDir, projectConfig, accountId, skipValidation, profile) {
@@ -132,12 +129,8 @@ export async function handleTranslate(projectDir, projectConfig, accountId, skip
     }
     catch (e) {
         if (isTranslationError(e)) {
-            const validationError = new Error(e.toString());
-            validationError.name = 'ProjectValidationError';
-            throw validationError;
-        }
-        else {
-            logError(e);
+            throw new ProjectValidationError(e.toString(), { cause: e });
         }
+        throw e;
     }
 }

package/lib/sandboxes.d.ts

@@ -11,6 +11,10 @@ export declare const SANDBOX_API_TYPE_MAP: {
     readonly STANDARD_SANDBOX: 1;
     readonly DEVELOPMENT_SANDBOX: 2;
 };
+export declare const SANDBOX_TYPE_MAP_V2: {
+    readonly STANDARD_SANDBOX: "STANDARD";
+    readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
+};
 export declare function getSandboxTypeAsString(accountType?: AccountType): string;
 export declare function getHasSandboxesByType(parentAccountConfig: CLIAccount, type: AccountType): boolean;
 export declare function getAvailableSyncTypes(parentAccountConfig: CLIAccount, config: CLIAccount): Promise<Array<SandboxSyncTask>>;

package/lib/sandboxes.js

@@ -22,6 +22,10 @@ export const SANDBOX_API_TYPE_MAP = {
     [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
     [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
 };
+export const SANDBOX_TYPE_MAP_V2 = {
+    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
+    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
+};
 export function getSandboxTypeAsString(accountType) {
     if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
         return 'development'; // Only place we're using this specific name

package/lib/ui/index.d.ts

@@ -1,9 +1,14 @@
+type TerminalSupport = {
+    hyperlinks: boolean;
+    color: boolean;
+};
 export declare const UI_COLORS: {
     SORBET: string;
     MARIGOLD: string;
     MARIGOLD_DARK: string;
 };
 export declare function uiLine(): void;
+export declare function getTerminalUISupport(): TerminalSupport;
 export declare function uiLink(linkText: string, url: string): string;
 export declare function uiAccountDescription(accountId?: number | null, bold?: boolean): string;
 export declare function uiInfoSection(title: string, logContent: () => void): void;
@@ -17,3 +22,4 @@ export declare function uiCommandDisabledBanner(command: string, url?: string, m
 export declare function uiDeprecatedDescription(message: string, command: string, url?: string): undefined;
 export declare function uiDeprecatedMessage(command: string, url?: string, message?: string): void;
 export declare function indent(level: number): string;
+export {};

package/lib/ui/index.js

@@ -13,7 +13,7 @@ export const UI_COLORS = {
 export function uiLine() {
     logger.log('-'.repeat(50));
 }
-function getTerminalUISupport() {
+export function getTerminalUISupport() {
     return {
         hyperlinks: supportsHyperlinkModule.stdout,
         color: supportsColor.stdout.hasBasic,
@@ -79,9 +79,8 @@ export function uiFeatureHighlight(features, title) {
     });
 }
 export function uiBetaTag(message, log = true) {
-    const terminalUISupport = getTerminalUISupport();
     const tag = i18n(`lib.ui.betaTag`);
-    const result = `${terminalUISupport.color ? chalk.hex(UI_COLORS.SORBET)(tag) : tag} ${message}`;
+    const result = `${tag} ${message}`;
     if (log) {
         logger.log(result);
         return;
@@ -89,9 +88,8 @@ export function uiBetaTag(message, log = true) {
     return result;
 }
 export function uiDeprecatedTag(message, log = true) {
-    const terminalUISupport = getTerminalUISupport();
     const tag = i18n(`lib.ui.deprecatedTag`);
-    const result = `${terminalUISupport.color ? chalk.yellow(tag) : tag} ${message}`;
+    const result = `${tag} ${message}`;
     if (log) {
         logger.log(result);
         return;

package/mcp-server/tools/index.js

@@ -1,16 +1,18 @@
 import { UploadProjectTools } from './project/UploadProjectTools.js';
 import { CreateProjectTool } from './project/CreateProjectTool.js';
 import { GuidedWalkthroughTool } from './project/GuidedWalkthroughTool.js';
-import { DeployProject } from './project/DeployProject.js';
-import { AddFeatureToProject } from './project/AddFeatureToProject.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';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
         new CreateProjectTool(mcpServer).register(),
         new GuidedWalkthroughTool(mcpServer).register(),
-        new DeployProject(mcpServer).register(),
-        new AddFeatureToProject(mcpServer).register(),
+        new DeployProjectTool(mcpServer).register(),
+        new AddFeatureToProjectTool(mcpServer).register(),
         new ValidateProjectTool(mcpServer).register(),
+        new GetConfigValuesTool(mcpServer).register(),
     ];
 }

package/mcp-server/tools/project/{AddFeatureToProject.d.ts → AddFeatureToProjectTool.d.ts}

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

package/mcp-server/tools/project/{AddFeatureToProject.js → AddFeatureToProjectTool.js}

@@ -2,8 +2,8 @@ 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 } from './constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { absoluteProjectPath, features } from './constants.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {
@@ -23,23 +23,14 @@ const inputSchema = {
         z.literal(APP_AUTH_TYPES.OAUTH),
     ]))
         .describe('Static uses a static non changing authentication token, and is only available for private distribution. If not specified by the user, do not choose for them.  This cannot be changed after a project is uploaded.'),
-    features: z
-        .array(z
-        .union([
-        z.literal('card'),
-        z.literal('settings'),
-        z.literal('app-function'),
-        z.literal('webhooks'),
-    ])
-        .describe('The features to include in the project, multiple options can be selected'))
-        .optional(),
+    features,
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({
     ...inputSchema,
 });
 const toolName = 'add-feature-to-hubspot-project';
-export class AddFeatureToProject extends Tool {
+export class AddFeatureToProjectTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
@@ -77,7 +68,8 @@ export class AddFeatureToProject extends Tool {
     register() {
         return this.mcpServer.registerTool(toolName, {
             title: 'Add feature to HubSpot Project',
-            description: 'Adds a feature to an existing 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

@@ -8,7 +8,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     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">]>, "many">>;
+    features: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">, z.ZodLiteral<"workflow-action">]>, "many">>;
 }, "strip", z.ZodTypeAny, {
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
@@ -16,7 +16,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     name?: string | undefined;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
+    features?: ("card" | "settings" | "app-function" | "webhooks" | "workflow-action")[] | undefined;
 }, {
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
@@ -24,7 +24,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     name?: string | undefined;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
+    features?: ("card" | "settings" | "app-function" | "webhooks" | "workflow-action")[] | undefined;
 }>;
 export type CreateProjectInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class CreateProjectTool extends Tool<CreateProjectInputSchema> {

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

@@ -1,10 +1,9 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
-import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../lib/constants.js';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../lib/constants.js';
 import { addFlag } from '../../utils/command.js';
-import { EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../lib/projects/create/v3.js';
-import { absoluteCurrentWorkingDirectory } from './constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { absoluteCurrentWorkingDirectory, features } from './constants.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {
@@ -32,16 +31,7 @@ const inputSchema = {
     ]))
         .describe('Static uses a static non changing authentication token, and is only available for private distribution. If not specified by the user, do not choose for them.  This cannot be changed after a project is uploaded.')
         .optional(),
-    features: z
-        .array(z
-        .union([
-        z.literal('card'),
-        z.literal('settings'),
-        z.literal('app-function'),
-        z.literal('webhooks'),
-    ])
-        .describe('The features to include in the project, multiple options can be selected'))
-        .optional(),
+    features,
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });

package/mcp-server/tools/project/{DeployProject.d.ts → DeployProjectTool.d.ts}

@@ -12,7 +12,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     buildNumber?: number | undefined;
 }>;
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
-export declare class DeployProject extends Tool<InputSchemaType> {
+export declare class DeployProjectTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
     handler({ absoluteProjectPath, buildNumber, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;

package/mcp-server/tools/project/{DeployProject.js → DeployProjectTool.js}

@@ -2,7 +2,7 @@ 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 { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {
@@ -16,7 +16,7 @@ const inputSchemaZodObject = z.object({
     ...inputSchema,
 });
 const toolName = 'deploy-hubspot-project';
-export class DeployProject extends Tool {
+export class DeployProjectTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }

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

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

@@ -0,0 +1,51 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { formatTextContents } from '../../utils/content.js';
+import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { useV3Api } from '../../../lib/projects/buildAndDeploy.js';
+const inputSchema = {
+    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-hubspot-project-feature-config-schema';
+export class GetConfigValuesTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ platformVersion, featureType, }) {
+        try {
+            if (!useV3Api(platformVersion)) {
+                return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
+            }
+            const schema = await getIntermediateRepresentationSchema({
+                platformVersion,
+                projectSourceDir: '',
+                accountId: getAccountId(),
+            });
+            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/UploadProjectTools.js

@@ -1,5 +1,5 @@
 import { Tool } from '../../types.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { absoluteProjectPath } from './constants.js';
 import z from 'zod';
 import { formatTextContents } from '../../utils/content.js';

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

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteProjectPath } from './constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {

package/mcp-server/tools/project/__tests__/{AddFeatureToProject.test.js → AddFeatureToProjectTool.test.js}

@@ -1,9 +1,9 @@
-import { AddFeatureToProject, } from '../AddFeatureToProject.js';
-import { runCommandInDir } from '../../../utils/project.js';
+import { AddFeatureToProjectTool, } from '../AddFeatureToProjectTool.js';
+import { runCommandInDir } from '../../../utils/command.js';
 import { addFlag } from '../../../utils/command.js';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../../lib/constants.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/project');
+vi.mock('../../../utils/command');
 vi.mock('../../../utils/command');
 vi.mock('../../../../lib/constants');
 vi.mock('../../../utils/toolUsageTracking');
@@ -21,18 +21,18 @@ describe('mcp-server/tools/project/AddFeatureToProject', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new AddFeatureToProject(mockMcpServer);
+        tool = new AddFeatureToProjectTool(mockMcpServer);
         // Mock addFlag to simulate command building
         mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('add-feature-to-hubspot-project', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('add-feature-to-hubspot-project', expect.objectContaining({
                 title: 'Add feature to HubSpot Project',
-                description: 'Adds a feature to an existing HubSpot project',
+                description: expect.stringContaining('Adds a feature to an existing HubSpot project'),
                 inputSchema: expect.any(Object),
-            }, tool.handler);
+            }), tool.handler);
             expect(result).toBe(mockRegisteredTool);
         });
     });