@hubspot/cli 7.7.19-experimental.3 → 7.7.20-experimental.0

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const UploadProjectTools_1 = require("../UploadProjectTools");
+const project_1 = require("../../../utils/project");
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+const mockRunCommandInDir = project_1.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_1.UploadProjectTools(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('upload-hubspot-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,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ValidateProjectTool_1 = require("../ValidateProjectTool");
+const project_1 = require("../../../utils/project");
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('../../../utils/project');
+const mockRunCommandInDir = project_1.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_1.ValidateProjectTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('validate-hubspot-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/utils/__tests__/command.test.d.ts

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("../command");
+vi.mock('child_process');
+vi.mock('util');
+describe('mcp-server/utils/command', () => {
+    describe('addFlag', () => {
+        it('should add string flag to command', () => {
+            const result = (0, command_1.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 = (0, command_1.addFlag)('hs project deploy', 'build', 123);
+            expect(result).toBe('hs project deploy --build "123"');
+        });
+        it('should add boolean flag to command', () => {
+            const result = (0, command_1.addFlag)('hs project upload', 'watch', true);
+            expect(result).toBe('hs project upload --watch "true"');
+        });
+        it('should add array flag to command', () => {
+            const result = (0, command_1.addFlag)('hs project create', 'features', [
+                'card',
+                'settings',
+            ]);
+            expect(result).toBe('hs project create --features "card" "settings"');
+        });
+        it('should handle empty array', () => {
+            const result = (0, command_1.addFlag)('hs project create', 'features', []);
+            expect(result).toBe('hs project create --features ');
+        });
+        it('should handle array with one item', () => {
+            const result = (0, command_1.addFlag)('hs project create', 'features', ['card']);
+            expect(result).toBe('hs project create --features "card"');
+        });
+        it('should handle special characters in string values', () => {
+            const result = (0, command_1.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 = (0, command_1.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,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const project_1 = require("../project");
+const command_1 = require("../command");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+vi.mock('../command');
+vi.mock('fs');
+vi.mock('path');
+const mockExecAsync = command_1.execAsync;
+const mockExistsSync = fs_1.default.existsSync;
+const mockMkdirSync = fs_1.default.mkdirSync;
+const mockResolve = path_1.default.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 (0, project_1.runCommandInDir)(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).not.toHaveBeenCalled();
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, {
+                cwd: mockResolvedPath,
+            });
+            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 (0, project_1.runCommandInDir)(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, {
+                cwd: mockResolvedPath,
+            });
+            expect(result).toEqual(expectedResult);
+        });
+        it('should propagate execAsync errors', async () => {
+            const error = new Error('Command failed');
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockRejectedValue(error);
+            await expect((0, project_1.runCommandInDir)(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, {
+                cwd: mockResolvedPath,
+            });
+        });
+        it('should handle stderr in results', async () => {
+            const expectedResult = {
+                stdout: 'some output',
+                stderr: 'warning message',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await (0, project_1.runCommandInDir)(mockDirectory, mockCommand);
+            expect(result.stdout).toBe('some output');
+            expect(result.stderr).toBe('warning message');
+        });
+    });
+});

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.7.19-experimental.3",
+    "version": "7.7.20-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "dependencies": {
-        "@hubspot/local-dev-lib": "3.13.1",
-        "@hubspot/project-parsing-lib": "0.5.1",
+        "@hubspot/local-dev-lib": "3.12.0",
+        "@hubspot/project-parsing-lib": "0.0.21-experimental.0",
         "@hubspot/serverless-dev-runtime": "7.0.6",
         "@hubspot/theme-preview-dev-server": "0.0.10",
         "@hubspot/ui-extensions-dev-server": "0.9.2",
@@ -38,8 +38,8 @@
         "@types/express": "^5.0.0",
         "@types/findup-sync": "^4.0.5",
         "@types/fs-extra": "^11.0.4",
-        "@types/jest": "^29.5.14",
         "@types/js-yaml": "^4.0.9",
+        "@types/node": "^24.1.0",
         "@types/semver": "^7.5.8",
         "@types/tmp": "^0.2.6",
         "@types/ws": "^8.18.1",
@@ -50,15 +50,14 @@
         "eslint": "^8.56.0",
         "eslint-plugin-import": "^2.31.0",
         "husky": "^4.3.8",
-        "jest": "^29.5.0",
         "lint-staged": "^10.5.4",
         "madge": "^8.0.0",
         "mock-stdin": "^1.0.0",
         "prettier": "^3.4.2",
         "semver": "^7.6.3",
-        "ts-jest": "^29.2.5",
         "ts-node": "^10.9.2",
-        "typescript": "^5.6.2"
+        "typescript": "^5.6.2",
+        "vitest": "^2.1.9"
     },
     "optionalDependencies": {
         "@hubspot/cms-dev-server": "^1.0.9",
@@ -78,7 +77,8 @@
         "mcp-local": "yarn ts-node ./scripts/mcp-local.ts",
         "prettier:write": "prettier --write './**/*.{ts,js,json}'",
         "release": "yarn ts-node ./scripts/release.ts release",
-        "test": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
+        "test": "vitest run",
+        "test-dev": "vitest",
         "test-cli": "yarn build && yarn --cwd 'acceptance-tests' test-ci",
         "test-cli-debug": "yarn build && yarn --cwd 'acceptance-tests' test-debug",
         "test-cli-latest": "yarn build && yarn build-docker && docker container run -it --rm --name=hs-cli-container hs-cli-image yarn --cwd 'acceptance-tests' test-latest",

package/commands/app/install.d.ts

@@ -1,8 +0,0 @@
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule, JSONOutputArgs } from '../../types/Yargs';
-type InstallAppArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs & {
-    appUid?: string;
-    projectName?: string;
-    testAccountId: number;
-};
-declare const installAppCommand: YargsCommandModule<unknown, InstallAppArgs>;
-export default installAppCommand;

package/commands/app/install.js

@@ -1,127 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
-const usageTracking_1 = require("../../lib/usageTracking");
-const en_1 = require("../../lang/en");
-const exitCodes_1 = require("../../lib/enums/exitCodes");
-const yargsUtils_1 = require("../../lib/yargsUtils");
-const constants_1 = require("../../lib/constants");
-const logger_1 = require("../../lib/ui/logger");
-const SpinniesManager_1 = __importDefault(require("../../lib/ui/SpinniesManager"));
-const errorHandlers_1 = require("../../lib/errorHandlers");
-const polling_1 = require("../../lib/polling");
-const config_1 = require("../../lib/projects/config");
-const upload_1 = require("../../lib/projects/upload");
-const structure_1 = require("../../lib/projects/structure");
-const command = 'install <test-account-id>';
-const describe = undefined; // commands.app.subcommands.install.describe;
-async function handler(args) {
-    const { derivedAccountId, appUid, projectName, testAccountId, formatOutputAsJson, } = args;
-    (0, usageTracking_1.trackCommandUsage)('app-install', {}, derivedAccountId);
-    const jsonOutput = {};
-    let targetProjectName = projectName;
-    let targetAppUid = appUid;
-    const { projectConfig, projectDir } = await (0, config_1.getProjectConfig)();
-    if (!targetProjectName) {
-        (0, config_1.validateProjectConfig)(projectConfig, projectDir);
-        targetProjectName = projectConfig?.name;
-    }
-    if (!targetProjectName) {
-        logger_1.uiLogger.error(en_1.commands.app.subcommands.install.errors.mustSpecifyProjectName);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
-    }
-    let isAppOauth = true;
-    if (!targetAppUid) {
-        const intermediateRepresentation = await (0, upload_1.handleTranslate)(projectDir, projectConfig, derivedAccountId, true, undefined);
-        if (intermediateRepresentation) {
-            Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).forEach(node => {
-                if ((0, structure_1.isAppIRNode)(node)) {
-                    targetAppUid = node.uid;
-                    isAppOauth = node.config.auth.type === constants_1.APP_AUTH_TYPES.OAUTH;
-                }
-            });
-        }
-    }
-    if (!targetAppUid) {
-        logger_1.uiLogger.error(en_1.commands.app.subcommands.install.errors.noAppUidFound);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
-    }
-    if (!isAppOauth) {
-        logger_1.uiLogger.error(en_1.commands.app.subcommands.install.errors.appMustBeOauth);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
-    }
-    try {
-        const { data } = await (0, developerTestAccounts_1.installOauthAppIntoDeveloperTestAccount)(derivedAccountId, testAccountId, targetProjectName, targetAppUid);
-        if (data?.authCodes.length > 0) {
-            jsonOutput.authCode = data.authCodes[0].authCode;
-        }
-    }
-    catch (err) {
-        (0, errorHandlers_1.logError)(err);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
-    }
-    SpinniesManager_1.default.init({
-        succeedColor: 'white',
-    });
-    SpinniesManager_1.default.add('installApp', {
-        text: en_1.commands.app.subcommands.install.polling.start,
-    });
-    let appInstallSucceeded = false;
-    try {
-        await (0, polling_1.poll)(() => (0, developerTestAccounts_1.fetchDeveloperTestAccountOauthAppInstallStatus)(derivedAccountId, targetProjectName, targetAppUid), {
-            successStates: ['SUCCESS'],
-            errorStates: [],
-        });
-        appInstallSucceeded = true;
-    }
-    catch (err) {
-        SpinniesManager_1.default.fail('installApp');
-        (0, errorHandlers_1.logError)(err);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
-    }
-    if (!appInstallSucceeded) {
-        SpinniesManager_1.default.fail('installApp');
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
-    }
-    SpinniesManager_1.default.succeed('installApp', {
-        text: en_1.commands.app.subcommands.install.polling.success,
-    });
-    if (formatOutputAsJson) {
-        logger_1.uiLogger.json(jsonOutput);
-    }
-    process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
-}
-function installAppBuilder(yargs) {
-    yargs.positional('test-account-id', {
-        describe: en_1.commands.app.subcommands.install.positionals.testAccountId,
-        required: true,
-        type: 'number',
-    });
-    yargs.option('app-uid', {
-        describe: en_1.commands.app.subcommands.install.options.appUid,
-        type: 'string',
-    });
-    yargs.option('project-name', {
-        describe: en_1.commands.app.subcommands.install.options.projectName,
-        type: 'string',
-    });
-    yargs.example('install 1234567890 --app-uid=my-app-uid --project-name=my-project', en_1.commands.app.subcommands.install.example);
-    return yargs;
-}
-const builder = (0, yargsUtils_1.makeYargsBuilder)(installAppBuilder, command, en_1.commands.app.subcommands.install.describe, {
-    useGlobalOptions: true,
-    useAccountOptions: true,
-    useConfigOptions: true,
-    useEnvironmentOptions: true,
-    useJSONOutputOptions: true,
-});
-const installAppCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-exports.default = installAppCommand;