@hubspot/cli 7.7.34-experimental.0 → 7.8.0-beta.0

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

@@ -0,0 +1,49 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+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';
+const inputSchema = {};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'get-applications-info';
+export class GetApplicationInfoTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({}) {
+        await trackToolUsage(toolName);
+        try {
+            // Get account ID from CLI config
+            const accountId = getAccountId();
+            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 response = await http.get(accountId, {
+                url: `app/feature/utilization/public/v3/insights/apps`,
+            });
+            // Format the response for display
+            const { data } = response;
+            const formattedResult = JSON.stringify(data, null, 2);
+            return formatTextContents(formattedResult);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle HubSpot-specific HTTP errors
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

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

@@ -2,19 +2,22 @@ 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({ platformVersion, featureType, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,10 +1,12 @@
 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 { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
-import { useV3Api } from '../../../lib/projects/platformVersion.js';
+import { isV2Project } 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.'),
@@ -21,16 +23,20 @@ export class GetConfigValuesTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ platformVersion, featureType, }) {
+    async handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }) {
         try {
-            if (!useV3Api(platformVersion)) {
+            if (!isV2Project(platformVersion)) {
                 return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
             }
-            loadConfig(getConfigPath());
+            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: getAccountId(),
+                accountId,
             });
             const internalComponentType = mapToInternalType(featureType);
             if (schema[internalComponentType]) {

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

@@ -4,9 +4,9 @@ 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 create" | "hs project upload" | "hs init" | undefined;
 }, {
-    command?: "hs auth" | "hs project upload" | "hs project create" | "hs init" | undefined;
+    command?: "hs auth" | "hs project create" | "hs project upload" | "hs init" | undefined;
 }>;
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class GuidedWalkthroughTool extends Tool<InputSchemaType> {

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

@@ -1,14 +1,14 @@
 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';
+import { getAccountIdFromCliConfig } from '../../../utils/cliConfig.js';
 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');
+vi.mock('../../../utils/cliConfig.js');
 const mockHttp = http;
-const mockGetAccountId = getAccountId;
+const mockGetAccountIdFromCliConfig = getAccountIdFromCliConfig;
 const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
 describe('mcp-server/tools/project/DocsSearchTool', () => {
     let mockMcpServer;
@@ -38,9 +38,10 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
     describe('handler', () => {
         const mockInput = {
             docsSearchQuery: 'test query',
+            absoluteCurrentWorkingDirectory: '/foo',
         };
         it('should return auth error message when no account ID is found', async () => {
-            mockGetAccountId.mockReturnValue(null);
+            mockGetAccountIdFromCliConfig.mockReturnValue(null);
             const result = await tool.handler(mockInput);
             expect(result).toEqual({
                 content: [
@@ -52,7 +53,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should return successful results when docs are found', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockResponse = {
                 results: [
                     {
@@ -76,6 +77,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
                 data: mockResponse,
             });
             const result = await tool.handler(mockInput);
+            expect(mockGetAccountIdFromCliConfig).toHaveBeenCalledWith('/foo');
             expect(mockHttp.post).toHaveBeenCalledWith(12345, {
                 url: 'dev/docs/llms/v1/docs-search',
                 data: {
@@ -103,7 +105,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             expect(resultText).toContain('Test content 2');
         });
         it('should return no results message when no documentation is found', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockResponse = {
                 results: [],
             };
@@ -122,7 +124,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should return no results message when results is null', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockResponse = {
                 results: null,
             };
@@ -141,7 +143,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle HubSpot HTTP errors', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockError = {
                 toString: () => 'HubSpot API Error: 404 Not Found',
             };
@@ -158,7 +160,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle generic errors', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockError = new Error('Network error');
             mockHttp.post.mockRejectedValue(mockError);
             mockIsHubSpotHttpError.mockReturnValue(false);
@@ -173,7 +175,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle non-Error rejections', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             mockHttp.post.mockRejectedValue('String error');
             mockIsHubSpotHttpError.mockReturnValue(false);
             const result = await tool.handler(mockInput);

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

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

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

@@ -0,0 +1,169 @@
+import { GetApiUsagePatternsByAppIdTool } from '../GetApiUsagePatternsByAppIdTool.js';
+import { z } from 'zod';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { http } from '@hubspot/local-dev-lib/http';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/toolUsageTracking');
+vi.mock('@hubspot/local-dev-lib/http');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockGetAccountId = getAccountId;
+const mockHttp = http;
+const mockIsHubSpotHttpError = isHubSpotHttpError;
+describe('mcp-server/tools/project/GetApiUsagePatternsByAppIdTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole thing
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new GetApiUsagePatternsByAppIdTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-api-usage-patterns-by-app-id', {
+                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: expect.objectContaining({
+                    appId: expect.objectContaining({
+                        describe: expect.any(Function),
+                    }),
+                    startDate: expect.objectContaining({
+                        optional: expect.any(Function),
+                    }),
+                    endDate: expect.objectContaining({
+                        optional: expect.any(Function),
+                    }),
+                }),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('input validation', () => {
+        const inputSchema = z.object({
+            appId: z
+                .string()
+                .describe('The application ID to get API usage patterns for.'),
+            startDate: z
+                .string()
+                .regex(/^\d{4}-\d{2}-\d{2}$/, 'Start date must be in YYYY-MM-DD format')
+                .optional()
+                .describe('Start date for the usage patterns query in ISO 8601 format (e.g., 2025-01-01).'),
+            endDate: z
+                .string()
+                .regex(/^\d{4}-\d{2}-\d{2}$/, 'End date must be in YYYY-MM-DD format')
+                .optional()
+                .describe('End date for the usage patterns query in ISO 8601 format (e.g., 2025-12-31).'),
+        });
+        it('should validate date format correctly', () => {
+            const validInput = {
+                appId: '12345',
+                startDate: '2025-01-01',
+                endDate: '2025-12-31',
+            };
+            const invalidInput = {
+                appId: '12345',
+                startDate: '2025-1-1',
+                endDate: '2025-12-31T00:00:00Z',
+            };
+            expect(() => inputSchema.parse(validInput)).not.toThrow();
+            expect(() => inputSchema.parse(invalidInput)).toThrow();
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            appId: '12345',
+            startDate: '2025-01-01',
+            endDate: '2025-12-31',
+        };
+        beforeEach(() => {
+            mockGetAccountId.mockReturnValue(123456789);
+            mockIsHubSpotHttpError.mockReturnValue(false);
+        });
+        it('should return API usage patterns successfully', async () => {
+            const mockResponse = {
+                data: {
+                    patternSummaries: {
+                        additionalProp1: {
+                            portalPercentage: 25.5,
+                            numOfPortals: 150,
+                        },
+                        additionalProp2: {
+                            portalPercentage: 18.2,
+                            numOfPortals: 89,
+                        },
+                        additionalProp3: {
+                            portalPercentage: 32.1,
+                            numOfPortals: 201,
+                        },
+                    },
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(mockGetAccountId).toHaveBeenCalledWith();
+            expect(mockHttp.get).toHaveBeenCalledWith(123456789, {
+                url: 'app/feature/utilization/public/v3/insights/app/12345/usage-patterns',
+                params: {
+                    startDate: '2025-01-01',
+                    endDate: '2025-12-31',
+                },
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+        it('should return error when account ID cannot be determined', async () => {
+            mockGetAccountId.mockReturnValue(null);
+            const result = await tool.handler(input);
+            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>`',
+                    },
+                ],
+            });
+            expect(mockHttp.get).not.toHaveBeenCalled();
+        });
+        it('should handle empty usage patterns response', async () => {
+            const mockResponse = {
+                data: {
+                    patternSummaries: {},
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,115 @@
+import { GetApplicationInfoTool } from '../GetApplicationInfoTool.js';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { http } from '@hubspot/local-dev-lib/http';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../utils/toolUsageTracking');
+vi.mock('@hubspot/local-dev-lib/http');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockGetAccountId = getAccountId;
+const mockHttp = http;
+const mockIsHubSpotHttpError = isHubSpotHttpError;
+describe('mcp-server/tools/project/GetApplicationInfoTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole thing
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new GetApplicationInfoTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-applications-info', {
+                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: {},
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {};
+        beforeEach(() => {
+            mockGetAccountId.mockReturnValue(123456789);
+            mockIsHubSpotHttpError.mockReturnValue(false);
+        });
+        it('should return application information successfully', async () => {
+            const mockResponse = {
+                data: {
+                    applications: [
+                        {
+                            appId: 12345,
+                            appName: 'Test App 1',
+                        },
+                        {
+                            appId: 67890,
+                            appName: 'Test App 2',
+                        },
+                    ],
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(mockGetAccountId).toHaveBeenCalledWith();
+            expect(mockHttp.get).toHaveBeenCalledWith(123456789, {
+                url: 'app/feature/utilization/public/v3/insights/apps',
+            });
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+        it('should return error when account ID cannot be determined', async () => {
+            mockGetAccountId.mockReturnValue(null);
+            const result = await tool.handler(input);
+            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>`',
+                    },
+                ],
+            });
+            expect(mockHttp.get).not.toHaveBeenCalled();
+        });
+        it('should handle empty applications response', async () => {
+            const mockResponse = {
+                data: {
+                    applications: [],
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: { headers: {} },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(mockResponse.data, null, 2),
+                    },
+                ],
+            });
+        });
+    });
+});

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

@@ -1,13 +1,13 @@
 import { GetConfigValuesTool } from '../GetConfigValuesTool.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getAccountIdFromCliConfig } from '../../../utils/cliConfig.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('@hubspot/project-parsing-lib');
-vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/cliConfig.js');
 vi.mock('../../../utils/toolUsageTracking');
 const mockGetIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
 const mockMapToInternalType = mapToInternalType;
-const mockGetAccountId = getAccountId;
+const mockGetAccountIdFromCliConfig = getAccountIdFromCliConfig;
 describe('mcp-server/tools/project/GetConfigValuesTool', () => {
     let mockMcpServer;
     let tool;
@@ -44,9 +44,10 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
         const input = {
             platformVersion: '2025.2',
             featureType: 'card',
+            absoluteCurrentWorkingDirectory: '/foo',
         };
         beforeEach(() => {
-            mockGetAccountId.mockReturnValue(123456789);
+            mockGetAccountIdFromCliConfig.mockReturnValue(123456789);
         });
         it('should return config schema when component type exists', async () => {
             const mockSchema = {
@@ -61,6 +62,7 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
             mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
             mockMapToInternalType.mockReturnValue('internal-card-type');
             const result = await tool.handler(input);
+            expect(mockGetAccountIdFromCliConfig).toHaveBeenCalledWith('/foo');
             expect(mockGetIntermediateRepresentationSchema).toHaveBeenCalledWith({
                 platformVersion: '2025.2',
                 projectSourceDir: '',
@@ -133,14 +135,13 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
             });
         });
         it('should handle null account id', async () => {
-            mockGetAccountId.mockReturnValue(null);
-            mockGetIntermediateRepresentationSchema.mockRejectedValue(new Error('No account ID'));
+            mockGetAccountIdFromCliConfig.mockReturnValue(null);
             const result = await tool.handler(input);
             expect(result).toEqual({
                 content: [
                     {
                         type: 'text',
-                        text: 'Unable to locate JSON schema for type card',
+                        text: 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`',
                     },
                 ],
             });

package/mcp-server/utils/__tests__/cliConfig.test.d.ts

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