@hubspot/cli 7.7.0-experimental.2 → 7.7.0

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

@@ -0,0 +1,107 @@
+import { UploadProjectTools } from '../UploadProjectTools.js';
+import { runCommandInDir } from '../../../utils/project.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/toolUsageTracking');
+const mockRunCommandInDir = runCommandInDir;
+describe('mcp-server/tools/project/UploadProjectTools', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error noy mocking whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new UploadProjectTools(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('upload-project', {
+                title: 'Upload HubSpot Project',
+                description: expect.stringContaining('Uploads the HubSpot project in current working directory.'),
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            absoluteProjectPath: '/test/project',
+        };
+        it('should upload project successfully', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project uploaded successfully',
+                stderr: '',
+            });
+            const result = await tool.handler(input);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project upload --force-create');
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Project uploaded successfully' },
+                    { type: 'text', text: '' },
+                ],
+            });
+        });
+        it('should handle upload with warnings', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project uploaded with warnings',
+                stderr: 'Warning: some files were ignored',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'Project uploaded with warnings' },
+                { type: 'text', text: 'Warning: some files were ignored' },
+            ]);
+        });
+        it('should handle upload errors', async () => {
+            const error = new Error('Upload failed');
+            mockRunCommandInDir.mockRejectedValue(error);
+            await expect(tool.handler(input)).rejects.toThrow('Upload failed');
+        });
+        it('should use force-create flag', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project created and uploaded',
+                stderr: '',
+            });
+            await tool.handler(input);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project upload --force-create');
+        });
+        it('should handle empty stdout and stderr', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: '' },
+                { type: 'text', text: '' },
+            ]);
+        });
+        it('should work with different project paths', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Upload complete',
+                stderr: '',
+            });
+            const differentInput = {
+                absoluteProjectPath: '/different/path/to/project',
+            };
+            await tool.handler(differentInput);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', 'hs project upload --force-create');
+        });
+        it('should handle very long output', async () => {
+            const longOutput = 'A'.repeat(10000);
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: longOutput,
+                stderr: 'Long stderr output',
+            });
+            const result = await tool.handler(input);
+            expect(result.content[0].text).toBe(longOutput);
+            expect(result.content[1].text).toBe('Long stderr output');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,110 @@
+import { ValidateProjectTool, } from '../ValidateProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+vi.mock('../../../utils/toolUsageTracking');
+const mockRunCommandInDir = runCommandInDir;
+describe('mcp-server/tools/project/ValidateProjectTool', () => {
+    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 ValidateProjectTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('validate-project', {
+                title: expect.stringContaining('Validate HubSpot Project'),
+                description: expect.stringContaining('Validates the HubSpot project and its configuration files.'),
+                inputSchema: expect.any(Object),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            absoluteProjectPath: '/test/project',
+        };
+        it('should validate project successfully', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project validation successful',
+                stderr: '',
+            });
+            const result = await tool.handler(input);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project validate');
+            expect(result).toEqual({
+                content: [
+                    { type: 'text', text: 'Project validation successful' },
+                    { type: 'text', text: '' },
+                ],
+            });
+        });
+        it('should handle validation with warnings', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Project is valid',
+                stderr: 'Warning: some files may need updates',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'Project is valid' },
+                { type: 'text', text: 'Warning: some files may need updates' },
+            ]);
+        });
+        it('should handle validation errors', async () => {
+            const error = new Error('Validation failed');
+            mockRunCommandInDir.mockRejectedValue(error);
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'Validation failed' }],
+            });
+        });
+        it('should handle non-Error rejection', async () => {
+            mockRunCommandInDir.mockRejectedValue('String error');
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [{ type: 'text', text: 'String error' }],
+            });
+        });
+        it('should handle empty stdout and stderr', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'stdout',
+                stderr: 'stderr',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: 'stdout' },
+                { type: 'text', text: 'stderr' },
+            ]);
+        });
+        it('should work with different project paths', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Validation complete',
+                stderr: '',
+            });
+            const differentInput = {
+                absoluteProjectPath: '/different/path/to/project',
+            };
+            await tool.handler(differentInput);
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', 'hs project validate');
+        });
+        it('should handle validation errors with stderr', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: '',
+                stderr: 'Error: Missing required configuration file',
+            });
+            const result = await tool.handler(input);
+            expect(result.content).toEqual([
+                { type: 'text', text: '' },
+                { type: 'text', text: 'Error: Missing required configuration file' },
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,6 @@
+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">, z.ZodLiteral<"workflow-action-tool">, z.ZodLiteral<"app-object">, z.ZodLiteral<"app-event">, z.ZodLiteral<"scim">, z.ZodLiteral<"page">]>, "many">>;
+export declare const docsSearchQuery: z.ZodString;
+export declare const docUrl: z.ZodString;

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

@@ -0,0 +1,32 @@
+import z from 'zod';
+export const absoluteProjectPath = z
+    .string()
+    .describe('The absolute path to the project directory.');
+export const absoluteCurrentWorkingDirectory = z
+    .string()
+    .describe('The absolute path to the current working directory.');
+export const features = z
+    .array(z.union([
+    z.literal('card'),
+    z.literal('settings'),
+    z
+        .literal('app-function')
+        .describe('Also known as a public serverless function'),
+    z.literal('webhooks'),
+    z
+        .literal('workflow-action')
+        .describe('Also known as a custom workflow action.'),
+    z.literal('workflow-action-tool').describe('Also known as agent tools.'),
+    z.literal('app-object'),
+    z.literal('app-event'),
+    z.literal('scim'),
+    z.literal('page'),
+]))
+    .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/types.d.ts

@@ -0,0 +1,14 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare class Tool<InputSchema, ResponseType = TextContentResponse> {
+    protected mcpServer: McpServer;
+    constructor(mcpServer: McpServer);
+    register(): RegisteredTool;
+    handler(input: InputSchema): ResponseType | Promise<ResponseType>;
+}
+export type TextContent = {
+    type: 'text';
+    text: string;
+};
+export type TextContentResponse = {
+    content: TextContent[];
+};

package/mcp-server/types.js

@@ -0,0 +1,13 @@
+export class Tool {
+    mcpServer;
+    constructor(mcpServer) {
+        this.mcpServer = mcpServer;
+    }
+    register() {
+        throw new Error('Must implement register');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    handler(input) {
+        throw new Error('Must implement handler');
+    }
+}

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

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

package/mcp-server/utils/__tests__/cliConfig.test.js

@@ -0,0 +1,110 @@
+import { getAccountIdFromCliConfig } from '../cliConfig.js';
+import { configFileExists, findConfig, getAccountId, loadConfig, } from '@hubspot/local-dev-lib/config';
+vi.mock('@hubspot/local-dev-lib/config');
+const mockConfigFileExists = configFileExists;
+const mockFindConfig = findConfig;
+const mockGetAccountId = getAccountId;
+const mockLoadConfig = loadConfig;
+describe('mcp-server/utils/cliConfig', () => {
+    const mockWorkingDirectory = '/test/working/directory';
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getAccountIdFromCliConfig', () => {
+        it('should load global config when it exists and return account ID', () => {
+            const expectedAccountId = 12345;
+            mockConfigFileExists.mockReturnValue(true);
+            mockGetAccountId.mockReturnValue(expectedAccountId);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockLoadConfig).toHaveBeenCalledWith('');
+            expect(mockFindConfig).not.toHaveBeenCalled();
+            expect(mockGetAccountId).toHaveBeenCalledWith(undefined);
+            expect(result).toBe(expectedAccountId);
+        });
+        it('should load local config when global config does not exist and return account ID', () => {
+            const expectedAccountId = 67890;
+            const localConfigPath = '/path/to/local/config';
+            mockConfigFileExists.mockReturnValue(false);
+            mockFindConfig.mockReturnValue(localConfigPath);
+            mockGetAccountId.mockReturnValue(expectedAccountId);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockFindConfig).toHaveBeenCalledWith(mockWorkingDirectory);
+            expect(mockLoadConfig).toHaveBeenCalledWith(localConfigPath);
+            expect(mockGetAccountId).toHaveBeenCalledWith(undefined);
+            expect(result).toBe(expectedAccountId);
+        });
+        it('should pass accountNameOrId parameter to getAccountId when provided as string', () => {
+            const expectedAccountId = 11111;
+            const accountName = 'test-account';
+            mockConfigFileExists.mockReturnValue(true);
+            mockGetAccountId.mockReturnValue(expectedAccountId);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory, accountName);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockLoadConfig).toHaveBeenCalledWith('');
+            expect(mockGetAccountId).toHaveBeenCalledWith(accountName);
+            expect(result).toBe(expectedAccountId);
+        });
+        it('should pass accountNameOrId parameter to getAccountId when provided as number', () => {
+            const expectedAccountId = 22222;
+            const accountId = 22222;
+            mockConfigFileExists.mockReturnValue(true);
+            mockGetAccountId.mockReturnValue(expectedAccountId);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory, accountId);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockLoadConfig).toHaveBeenCalledWith('');
+            expect(mockGetAccountId).toHaveBeenCalledWith(accountId);
+            expect(result).toBe(expectedAccountId);
+        });
+        it('should return null when getAccountId returns null', () => {
+            mockConfigFileExists.mockReturnValue(true);
+            mockGetAccountId.mockReturnValue(null);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockLoadConfig).toHaveBeenCalledWith('');
+            expect(mockGetAccountId).toHaveBeenCalledWith(undefined);
+            expect(result).toBeNull();
+        });
+        it('should handle findConfig returning null by passing null to loadConfig', () => {
+            const expectedAccountId = 33333;
+            mockConfigFileExists.mockReturnValue(false);
+            mockFindConfig.mockReturnValue(null);
+            mockGetAccountId.mockReturnValue(expectedAccountId);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockFindConfig).toHaveBeenCalledWith(mockWorkingDirectory);
+            expect(mockLoadConfig).toHaveBeenCalledWith(null);
+            expect(mockGetAccountId).toHaveBeenCalledWith(undefined);
+            expect(result).toBe(expectedAccountId);
+        });
+        it('should work with local config when provided with account name parameter', () => {
+            const expectedAccountId = 44444;
+            const accountName = 'local-test-account';
+            const localConfigPath = '/path/to/local/config';
+            mockConfigFileExists.mockReturnValue(false);
+            mockFindConfig.mockReturnValue(localConfigPath);
+            mockGetAccountId.mockReturnValue(expectedAccountId);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory, accountName);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockFindConfig).toHaveBeenCalledWith(mockWorkingDirectory);
+            expect(mockLoadConfig).toHaveBeenCalledWith(localConfigPath);
+            expect(mockGetAccountId).toHaveBeenCalledWith(accountName);
+            expect(result).toBe(expectedAccountId);
+        });
+        it('should work with local config when provided with account ID parameter', () => {
+            const expectedAccountId = 55555;
+            const accountId = 55555;
+            const localConfigPath = '/path/to/local/config';
+            mockConfigFileExists.mockReturnValue(false);
+            mockFindConfig.mockReturnValue(localConfigPath);
+            mockGetAccountId.mockReturnValue(expectedAccountId);
+            const result = getAccountIdFromCliConfig(mockWorkingDirectory, accountId);
+            expect(mockConfigFileExists).toHaveBeenCalledWith(true);
+            expect(mockFindConfig).toHaveBeenCalledWith(mockWorkingDirectory);
+            expect(mockLoadConfig).toHaveBeenCalledWith(localConfigPath);
+            expect(mockGetAccountId).toHaveBeenCalledWith(accountId);
+            expect(result).toBe(expectedAccountId);
+        });
+    });
+});

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

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

package/mcp-server/utils/__tests__/command.test.js

@@ -0,0 +1,45 @@
+import { addFlag } from '../command.js';
+vi.mock('child_process');
+vi.mock('util');
+describe('mcp-server/utils/command', () => {
+    describe('addFlag', () => {
+        it('should add string flag to command', () => {
+            const result = addFlag('hs project create', 'name', 'test-project');
+            expect(result).toBe('hs project create --name "test-project"');
+        });
+        it('should add number flag to command', () => {
+            const result = addFlag('hs project deploy', 'build', 123);
+            expect(result).toBe('hs project deploy --build "123"');
+        });
+        it('should add boolean flag to command', () => {
+            const result = addFlag('hs project upload', 'watch', true);
+            expect(result).toBe('hs project upload --watch "true"');
+        });
+        it('should add array flag to command', () => {
+            const result = addFlag('hs project create', 'features', [
+                'card',
+                'settings',
+            ]);
+            expect(result).toBe('hs project create --features "card" "settings"');
+        });
+        it('should handle empty array', () => {
+            const result = addFlag('hs project create', 'features', []);
+            expect(result).toBe('hs project create --features ');
+        });
+        it('should handle array with one item', () => {
+            const result = addFlag('hs project create', 'features', ['card']);
+            expect(result).toBe('hs project create --features "card"');
+        });
+        it('should handle special characters in string values', () => {
+            const result = addFlag('hs project create', 'name', 'my-project with spaces');
+            expect(result).toBe('hs project create --name "my-project with spaces"');
+        });
+        it('should handle special characters in array values', () => {
+            const result = addFlag('hs project create', 'features', [
+                'card with spaces',
+                'settings',
+            ]);
+            expect(result).toBe('hs project create --features "card with spaces" "settings"');
+        });
+    });
+});

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

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

package/mcp-server/utils/__tests__/project.test.js

@@ -0,0 +1,79 @@
+import { runCommandInDir } from '../project.js';
+import { execAsync } from '../command.js';
+import fs from 'fs';
+import path from 'path';
+vi.mock('../command');
+vi.mock('fs');
+vi.mock('path');
+const mockExecAsync = execAsync;
+const mockExistsSync = fs.existsSync;
+const mockMkdirSync = fs.mkdirSync;
+const mockResolve = path.resolve;
+describe('mcp-server/utils/project', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('runCommandInDir', () => {
+        const mockDirectory = '/test/directory';
+        const mockCommand = 'npm install';
+        const mockResolvedPath = '/resolved/test/directory';
+        beforeEach(() => {
+            mockResolve.mockReturnValue(mockResolvedPath);
+        });
+        it('should run command in existing directory', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).not.toHaveBeenCalled();
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should create directory if it does not exist', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(false);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should propagate execAsync errors', async () => {
+            const error = new Error('Command failed');
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockRejectedValue(error);
+            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should handle stderr in results', async () => {
+            const expectedResult = {
+                stdout: 'some output',
+                stderr: 'warning message',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(result.stdout).toBe('some output');
+            expect(result.stderr).toBe('warning message');
+        });
+    });
+});

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

@@ -0,0 +1 @@
+export declare function getAccountIdFromCliConfig(absolutePathToWorkingDirectory: string, accountNameOrId?: string | number): number | null;

package/mcp-server/utils/cliConfig.js

@@ -0,0 +1,12 @@
+import { configFileExists, findConfig, getAccountId, loadConfig, } from '@hubspot/local-dev-lib/config';
+export function getAccountIdFromCliConfig(absolutePathToWorkingDirectory, accountNameOrId) {
+    const globalConfigExists = configFileExists(true);
+    if (globalConfigExists) {
+        loadConfig('');
+    }
+    else {
+        const configPath = findConfig(absolutePathToWorkingDirectory);
+        loadConfig(configPath);
+    }
+    return getAccountId(accountNameOrId);
+}

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

@@ -0,0 +1,3 @@
+import { exec } from 'node:child_process';
+export declare const execAsync: typeof exec.__promisify__;
+export declare function addFlag(command: string, flagName: string, value: string | number | boolean | string[]): string;

package/mcp-server/utils/command.js

@@ -0,0 +1,9 @@
+import util from 'util';
+import { exec } from 'node:child_process';
+export const execAsync = util.promisify(exec);
+export function addFlag(command, flagName, value) {
+    if (Array.isArray(value)) {
+        return `${command} --${flagName} ${value.map(item => `"${item}"`).join(' ')}`;
+    }
+    return `${command} --${flagName} "${value}"`;
+}

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

@@ -0,0 +1,3 @@
+import { TextContent, TextContentResponse } from '../types.js';
+export declare function formatTextContents(...outputs: (string | undefined)[]): TextContentResponse;
+export declare function formatTextContent(text: string): TextContent;

package/mcp-server/utils/content.js

@@ -0,0 +1,17 @@
+export function formatTextContents(...outputs) {
+    const content = [];
+    outputs.forEach(output => {
+        if (output !== undefined) {
+            content.push(formatTextContent(output));
+        }
+    });
+    return {
+        content,
+    };
+}
+export function formatTextContent(text) {
+    return {
+        type: 'text',
+        text,
+    };
+}

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

@@ -0,0 +1,5 @@
+export interface CommandResults {
+    stderr: string;
+    stdout: string;
+}
+export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/project.js

@@ -0,0 +1,14 @@
+import { execAsync } from './command.js';
+import path from 'path';
+import fs from 'fs';
+export async function runCommandInDir(directory, command) {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory);
+    }
+    return execAsync(command, {
+        cwd: path.resolve(directory),
+        env: {
+            ...process.env,
+        },
+    });
+}

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

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

package/mcp-server/utils/toolUsageTracking.js

@@ -0,0 +1,23 @@
+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, meta) {
+    if (!isTrackingAllowed()) {
+        return;
+    }
+    const usageTrackingEvent = {
+        action: 'cli-mcp-tool-invocation',
+        os: getPlatform(),
+        ...getNodeVersionData(),
+        command: toolName,
+        type: process.env.HUBSPOT_MCP_AI_AGENT,
+        ...meta,
+    };
+    const accountId = getAccountId() || undefined;
+    try {
+        logger.info('Tracking tool usage');
+        await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+    }
+    catch (error) { }
+}