@hubspot/cli 7.7.27-experimental.1 → 7.7.28-experimental.0

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

@@ -0,0 +1,117 @@
+import { DocFetchTool } from '../DocFetchTool.js';
+import { http } from '@hubspot/local-dev-lib/http/unauthed';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('@hubspot/local-dev-lib/http/unauthed');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('../../utils/toolUsageTracking');
+const mockHttp = http;
+const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
+describe('mcp-server/tools/project/DocFetchTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new DocFetchTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('fetch-hubspot-doc', {
+                title: 'Fetch HubSpot Developer Documentation (single file)',
+                description: 'Always use this immediately after `search-hubspot-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: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const mockInput = {
+            docUrl: 'https://example.com/docs/test-doc',
+        };
+        it('should successfully fetch and return markdown content', async () => {
+            const mockContent = '# Test Document\n\nThis is a test markdown document.';
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.get.mockResolvedValue({
+                data: mockContent,
+            });
+            const result = await tool.handler(mockInput);
+            expect(mockHttp.get).toHaveBeenCalledWith({
+                url: 'https://example.com/docs/test-doc.md',
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: mockContent,
+                    },
+                ],
+            });
+        });
+        it('should handle HubSpot HTTP errors', async () => {
+            const mockError = {
+                toString: () => 'HubSpotHttpError: \n- message: The request was not found.\n- status: 404\n- statusText: Not Found\n- method: get\n- code: ERR_BAD_REQUEST\n- derivedContext: {\n  "request": "https://example.com/docs/test-doc.md"\n}',
+            };
+            mockHttp.get.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(true);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'HubSpotHttpError: \n- message: The request was not found.\n- status: 404\n- statusText: Not Found\n- method: get\n- code: ERR_BAD_REQUEST\n- derivedContext: {\n  "request": "https://example.com/docs/test-doc.md"\n}',
+                    },
+                ],
+            });
+        });
+        it('should handle empty content', async () => {
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.get.mockResolvedValue({
+                data: '   ',
+            });
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Document is empty or contains no content.',
+                    },
+                ],
+            });
+        });
+        it('should handle generic errors', async () => {
+            const mockError = new Error('Network error');
+            mockHttp.get.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error fetching documentation: Network error',
+                    },
+                ],
+            });
+        });
+        it('should handle non-Error rejections', async () => {
+            mockHttp.get.mockRejectedValue('String error');
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error fetching documentation: String error',
+                    },
+                ],
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,190 @@
+import { DocsSearchTool } from '../DocsSearchTool.js';
+import { http } from '@hubspot/local-dev-lib/http';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('@hubspot/local-dev-lib/http');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('../../../utils/toolUsageTracking');
+const mockHttp = http;
+const mockGetAccountId = getAccountId;
+const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
+describe('mcp-server/tools/project/DocsSearchTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new DocsSearchTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('search-hubspot-docs', {
+                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-hubspot-doc`. Always follow this with a fetch to get the full, authoritative content before making plans or writing answers.',
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const mockInput = {
+            docsSearchQuery: 'test query',
+        };
+        it('should return auth error message when no account ID is found', async () => {
+            mockGetAccountId.mockReturnValue(null);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`',
+                    },
+                ],
+            });
+        });
+        it('should return successful results when docs are found', async () => {
+            mockGetAccountId.mockReturnValue(12345);
+            const mockResponse = {
+                results: [
+                    {
+                        title: 'Test Doc 1',
+                        content: 'Test content 1',
+                        description: 'Test description 1',
+                        url: 'https://example.com/doc1',
+                        score: 0.9,
+                    },
+                    {
+                        title: 'Test Doc 2',
+                        content: 'Test content 2',
+                        description: 'Test description 2',
+                        url: 'https://example.com/doc2',
+                        score: 0.8,
+                    },
+                ],
+            };
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.post.mockResolvedValue({
+                data: mockResponse,
+            });
+            const result = await tool.handler(mockInput);
+            expect(mockHttp.post).toHaveBeenCalledWith(12345, {
+                url: 'dev/docs/llms/v1/docs-search',
+                data: {
+                    query: 'test query',
+                },
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: expect.stringContaining('Found 2 documentation results:'),
+                    },
+                ],
+            });
+            const resultText = result.content[0].text;
+            expect(resultText).toContain('**Test Doc 1**');
+            expect(resultText).toContain('Test description 1');
+            expect(resultText).toContain('https://example.com/doc1');
+            expect(resultText).toContain('Score: 0.9');
+            expect(resultText).toContain('Test content 1');
+            expect(resultText).toContain('**Test Doc 2**');
+            expect(resultText).toContain('Test description 2');
+            expect(resultText).toContain('https://example.com/doc2');
+            expect(resultText).toContain('Score: 0.8');
+            expect(resultText).toContain('Test content 2');
+        });
+        it('should return no results message when no documentation is found', async () => {
+            mockGetAccountId.mockReturnValue(12345);
+            const mockResponse = {
+                results: [],
+            };
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.post.mockResolvedValue({
+                data: mockResponse,
+            });
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No documentation found for your query.',
+                    },
+                ],
+            });
+        });
+        it('should return no results message when results is null', async () => {
+            mockGetAccountId.mockReturnValue(12345);
+            const mockResponse = {
+                results: null,
+            };
+            // @ts-expect-error - Mocking axios response structure
+            mockHttp.post.mockResolvedValue({
+                data: mockResponse,
+            });
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No documentation found for your query.',
+                    },
+                ],
+            });
+        });
+        it('should handle HubSpot HTTP errors', async () => {
+            mockGetAccountId.mockReturnValue(12345);
+            const mockError = {
+                toString: () => 'HubSpot API Error: 404 Not Found',
+            };
+            mockHttp.post.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(true);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'HubSpot API Error: 404 Not Found',
+                    },
+                ],
+            });
+        });
+        it('should handle generic errors', async () => {
+            mockGetAccountId.mockReturnValue(12345);
+            const mockError = new Error('Network error');
+            mockHttp.post.mockRejectedValue(mockError);
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error searching documentation: Network error',
+                    },
+                ],
+            });
+        });
+        it('should handle non-Error rejections', async () => {
+            mockGetAccountId.mockReturnValue(12345);
+            mockHttp.post.mockRejectedValue('String error');
+            mockIsHubSpotHttpError.mockReturnValue(false);
+            const result = await tool.handler(mockInput);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error searching documentation: String error',
+                    },
+                ],
+            });
+        });
+    });
+});

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

@@ -25,7 +25,7 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-hubspot-project-feature-config-schema', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-hubspot-feature-config-schema', {
                 title: 'Fetch the JSON Schema for component',
                 description: expect.stringContaining('Fetches and returns the JSON schema for the provided feature'),
                 inputSchema: expect.objectContaining({

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

@@ -2,3 +2,5 @@ import z from 'zod';
 export declare const absoluteProjectPath: z.ZodString;
 export declare const absoluteCurrentWorkingDirectory: z.ZodString;
 export declare const 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">>;
+export declare const docsSearchQuery: z.ZodString;
+export declare const docUrl: z.ZodString;

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

@@ -16,3 +16,9 @@ export const features = z
 ])
     .describe('The features to include in the project, multiple options can be selected'))
     .optional();
+export const docsSearchQuery = z
+    .string()
+    .describe('The query to search the HubSpot Developer Documentation for.');
+export const docUrl = z
+    .string()
+    .describe('The URL of the HubSpot Developer Documentation to fetch.');

package/mcp-server/utils/toolUsageTracking.d.ts

@@ -1 +1,3 @@
-export declare function trackToolUsage(toolName: string): Promise<void>;
+export declare function trackToolUsage(toolName: string, meta?: {
+    [key: string]: string;
+}): Promise<void>;

package/mcp-server/utils/toolUsageTracking.js

@@ -2,7 +2,7 @@ import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { EventClass, getNodeVersionData, getPlatform, } from '../../lib/usageTracking.js';
 import { getAccountId, isTrackingAllowed } from '@hubspot/local-dev-lib/config';
-export async function trackToolUsage(toolName) {
+export async function trackToolUsage(toolName, meta) {
     if (!isTrackingAllowed()) {
         return;
     }
@@ -12,6 +12,7 @@ export async function trackToolUsage(toolName) {
         ...getNodeVersionData(),
         command: toolName,
         type: process.env.HUBSPOT_MCP_AI_AGENT,
+        ...meta,
     };
     const accountId = getAccountId() || undefined;
     try {

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.7.27-experimental.1",
+    "version": "7.7.28-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "type": "module",
     "dependencies": {
-        "@hubspot/local-dev-lib": "3.16.0",
-        "@hubspot/project-parsing-lib": "0.0.21-experimental.2",
+        "@hubspot/local-dev-lib": "3.17.0",
+        "@hubspot/project-parsing-lib": "0.8.2",
         "@hubspot/serverless-dev-runtime": "7.0.6",
         "@hubspot/theme-preview-dev-server": "0.0.10",
-        "@hubspot/ui-extensions-dev-server": "0.9.4",
+        "@hubspot/ui-extensions-dev-server": "0.9.8",
         "archiver": "7.0.1",
         "boxen": "8.0.1",
         "chalk": "5.4.1",
@@ -20,11 +20,13 @@
         "express": "4.21.2",
         "findup-sync": "4.0.0",
         "fs-extra": "8.1.0",
+        "ink": "5.2.1",
         "inquirer": "12.7.0",
         "js-yaml": "4.1.0",
         "moment": "2.30.1",
         "open": "7.4.2",
         "p-queue": "8.1.0",
+        "react": "^18.0.0",
         "strip-ansi": "7.1.0",
         "table": "6.9.0",
         "tmp": "0.2.3",
@@ -42,6 +44,7 @@
         "@types/inquirer": "^9.0.8",
         "@types/js-yaml": "^4.0.9",
         "@types/node": "^24.1.0",
+        "@types/react": "^18.3.12",
         "@types/semver": "^7.5.8",
         "@types/tmp": "^0.2.6",
         "@types/update-notifier": "^6.0.8",
@@ -75,7 +78,7 @@
         "hs": "yarn build && node ./dist/bin/hs",
         "hs-debug": "yarn build && NODE_DEBUG=http* node --inspect-brk ./dist/bin/hs",
         "lint": "echo 'Linting is disabled for Blazar'",
-        "lint:local": "eslint . && prettier --list-different './**/*.{ts,js,json}'",
+        "lint:local": "eslint . && prettier --list-different './**/*.{ts,tsx,js,json}'",
         "list-all-commands": "yarn tsx ./scripts/get-all-commands.ts",
         "local-link": "yarn tsx ./scripts/linking.ts",
         "mcp-local": "yarn tsx ./scripts/mcp-local.ts",
@@ -91,7 +94,7 @@
         "view-unreleased-changes": "node ./scripts/unreleasedChanges.js"
     },
     "lint-staged": {
-        "**/*.{js,ts,scss,css}": [
+        "**/*.{js,ts,tsx,scss,css}": [
             "prettier -l",
             "eslint"
         ]

package/types/Cms.d.ts

@@ -1,10 +1,26 @@
 import { CommonArgs, ConfigArgs } from './Yargs.js';
+export declare const TEMPLATE_TYPES: readonly ["page-template", "email-template", "partial", "global-partial", "blog-listing-template", "blog-post-template", "search-template", "section"];
+export type TemplateType = (typeof TEMPLATE_TYPES)[number];
+export declare const HTTP_METHODS: readonly ["DELETE", "GET", "PATCH", "POST", "PUT"];
+export type HttpMethod = (typeof HTTP_METHODS)[number];
+export declare const CONTENT_TYPES: readonly ["ANY", "LANDING_PAGE", "SITE_PAGE", "BLOG_POST", "BLOG_LISTING", "EMAIL", "KNOWLEDGE_BASE", "QUOTE_TEMPLATE", "CUSTOMER_PORTAL", "WEB_INTERACTIVE", "SUBSCRIPTION", "MEMBERSHIP"];
+export type ContentType = (typeof CONTENT_TYPES)[number];
 export type CreateArgs = CommonArgs & ConfigArgs & {
     branch?: string;
     type: string;
     dest: string;
     name: string;
     internal?: boolean;
+    templateType?: TemplateType;
+    moduleLabel?: string;
+    reactType?: boolean;
+    contentTypes?: string;
+    global?: boolean;
+    availableForNewContent?: boolean;
+    functionsFolder?: string;
+    filename?: string;
+    endpointMethod?: HttpMethod;
+    endpointPath?: string;
 };
 export type CmsAssetOperationArgs = {
     assetType: string;

package/types/Cms.js

@@ -1 +1,25 @@
-export {};
+export const TEMPLATE_TYPES = [
+    'page-template',
+    'email-template',
+    'partial',
+    'global-partial',
+    'blog-listing-template',
+    'blog-post-template',
+    'search-template',
+    'section',
+];
+export const HTTP_METHODS = ['DELETE', 'GET', 'PATCH', 'POST', 'PUT'];
+export const CONTENT_TYPES = [
+    'ANY',
+    'LANDING_PAGE',
+    'SITE_PAGE',
+    'BLOG_POST',
+    'BLOG_LISTING',
+    'EMAIL',
+    'KNOWLEDGE_BASE',
+    'QUOTE_TEMPLATE',
+    'CUSTOMER_PORTAL',
+    'WEB_INTERACTIVE',
+    'SUBSCRIPTION',
+    'MEMBERSHIP',
+];

package/types/LocalDev.d.ts

@@ -1,5 +1,4 @@
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
-import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
 import { ProjectConfig } from './Projects.js';
@@ -14,8 +13,6 @@ export type LocalDevStateConstructorOptions = {
     projectId: number;
     projectName: string;
     debug?: boolean;
-    deployedBuild?: Build;
-    isGithubLinked: boolean;
     initialProjectNodes: {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };

package/types/Prompts.d.ts

@@ -23,5 +23,6 @@ export type PromptConfig<T extends GenericPromptResponse> = {
     validate?: (answer?: any) => PromptOperand | Promise<PromptOperand>;
     mask?: string;
     filter?: (input: string) => string;
+    loop?: boolean;
 };
 export {};

package/types/Yargs.d.ts

@@ -15,7 +15,7 @@ export type AccountArgs = {
     account?: string;
 };
 export type EnvironmentArgs = {
-    'use-env'?: string;
+    'use-env'?: boolean;
 };
 export type OverwriteArgs = Options & {
     o?: boolean;

package/ui/index.d.ts

@@ -0,0 +1 @@
+export declare function renderInline(component: React.ReactNode): Promise<void>;

package/ui/index.js

@@ -0,0 +1,6 @@
+import { render } from 'ink';
+// Ink components will be enabled by setting the ENABLE_INK environment variable
+export async function renderInline(component) {
+    const { unmount } = render(component, { patchConsole: false });
+    unmount();
+}