@hubspot/cli 8.0.10-experimental.5 → 8.0.10-experimental.6

package/commands/mcp/__tests__/start.test.js

@@ -1,144 +0,0 @@
-import { spawn } from 'node:child_process';
-import fs from 'fs';
-import { EventEmitter } from 'events';
-import * as configLib from '@hubspot/local-dev-lib/config';
-import { uiLogger } from '../../../lib/ui/logger.js';
-import * as errorHandlers from '../../../lib/errorHandlers/index.js';
-import * as usageTrackingLib from '../../../lib/usageTracking.js';
-import * as processLib from '../../../lib/process.js';
-import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-// Create a mock execAsync function before importing the module
-const execAsyncMock = vi.fn();
-vi.mock('yargs');
-vi.mock('../../../lib/commonOpts');
-vi.mock('node:child_process');
-vi.mock('node:util', () => ({
-    promisify: vi.fn(() => execAsyncMock),
-}));
-vi.mock('fs');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../../../lib/errorHandlers/index.js');
-vi.mock('../../../lib/process.js');
-// Import after mocks are set up
-const startCommand = await import('../start.js').then(m => m.default);
-const spawnSpy = vi.mocked(spawn);
-const existsSyncSpy = vi.spyOn(fs, 'existsSync');
-const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
-const handleExitSpy = vi.spyOn(processLib, 'handleExit');
-const logErrorSpy = vi.spyOn(errorHandlers, 'logError');
-const processExitSpy = vi.spyOn(process, 'exit');
-const getConfigAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigAccountIfExists');
-class MockChildProcess extends EventEmitter {
-    kill = vi.fn();
-}
-describe('commands/mcp/start', () => {
-    let mockChildProcess;
-    beforeEach(() => {
-        mockChildProcess = new MockChildProcess();
-        // @ts-expect-error Mock implementation
-        spawnSpy.mockReturnValue(mockChildProcess);
-        existsSyncSpy.mockReturnValue(true);
-        // @ts-expect-error Mock implementation
-        processExitSpy.mockImplementation(() => { });
-        // Mock config to prevent reading actual config file in CI
-        getConfigAccountIfExistsSpy.mockReturnValue(undefined);
-        execAsyncMock.mockClear();
-    });
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(startCommand.command).toEqual('start');
-        });
-    });
-    describe('describe', () => {
-        it('should be undefined to keep the command hidden', () => {
-            expect(startCommand.describe).toBeUndefined();
-        });
-    });
-    describe('builder', () => {
-        it('should be defined as a function', () => {
-            expect(startCommand.builder).toBeDefined();
-            expect(typeof startCommand.builder).toBe('function');
-        });
-    });
-    describe('handler', () => {
-        let args;
-        beforeEach(() => {
-            args = {
-                aiAgent: 'test-agent',
-                derivedAccountId: 123456,
-                d: false,
-                debug: false,
-            };
-        });
-        it('should track command usage', async () => {
-            await startCommand.handler(args);
-            expect(trackCommandUsageSpy).toHaveBeenCalledWith('mcp-start', {}, 123456);
-        });
-        it('should check if server file exists', async () => {
-            await startCommand.handler(args);
-            expect(existsSyncSpy).toHaveBeenCalledWith(expect.stringContaining('server.js'));
-        });
-        it('should error if server file does not exist', async () => {
-            existsSyncSpy.mockReturnValue(false);
-            await startCommand.handler(args);
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
-            expect(spawnSpy).not.toHaveBeenCalled();
-        });
-        it('should spawn server process with correct arguments', async () => {
-            await startCommand.handler(args);
-            expect(spawnSpy).toHaveBeenCalledWith('node', [expect.stringContaining('server.js')], expect.objectContaining({
-                stdio: 'inherit',
-                env: expect.objectContaining({
-                    HUBSPOT_MCP_AI_AGENT: 'test-agent',
-                }),
-            }));
-        });
-        it('should use "unknown" as default AI agent', async () => {
-            delete args.aiAgent;
-            await startCommand.handler(args);
-            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
-                env: expect.objectContaining({
-                    HUBSPOT_MCP_AI_AGENT: 'unknown',
-                }),
-            }));
-        });
-        it('should log debug messages when starting', async () => {
-            await startCommand.handler(args);
-            expect(uiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('Starting'));
-            expect(uiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('stop'));
-        });
-        it('should handle child process errors', async () => {
-            await startCommand.handler(args);
-            const error = new Error('Process error');
-            mockChildProcess.emit('error', error);
-            expect(logErrorSpy).toHaveBeenCalledWith(error);
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to start'));
-        });
-        it('should handle child process close', async () => {
-            await startCommand.handler(args);
-            mockChildProcess.emit('close');
-            expect(uiLogger.info).toHaveBeenCalledWith(expect.stringMatching(/stopped/i));
-        });
-        it('should register exit handler', async () => {
-            await startCommand.handler(args);
-            expect(handleExitSpy).toHaveBeenCalledWith(expect.any(Function));
-        });
-        it('should kill child process on exit', async () => {
-            await startCommand.handler(args);
-            const exitHandler = handleExitSpy.mock.calls[0][0];
-            exitHandler({ isSIGHUP: false });
-            expect(uiLogger.info).toHaveBeenCalledWith(expect.stringContaining('Shutting'));
-            expect(mockChildProcess.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
-        });
-        it('should handle exceptions during server start', async () => {
-            const error = new Error('Spawn failed');
-            spawnSpy.mockImplementation(() => {
-                throw error;
-            });
-            await startCommand.handler(args);
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to start'));
-            expect(logErrorSpy).toHaveBeenCalledWith(error);
-        });
-    });
-});

package/commands/mcp/setup.d.ts

@@ -1,6 +0,0 @@
-import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
-interface MCPSetupArgs extends CommonArgs {
-    client?: string[];
-}
-declare const mcpSetupCommand: YargsCommandModule<unknown, MCPSetupArgs>;
-export default mcpSetupCommand;

package/commands/mcp/setup.js

@@ -1,36 +0,0 @@
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { commands } from '../../lang/en.js';
-import { addMcpServerToConfig, supportedTools } from '../../lib/mcp/setup.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-const command = ['setup'];
-const describe = commands.mcp.setup.describe;
-async function handler(args) {
-    const { derivedAccountId } = args;
-    await trackCommandUsage('mcp-setup', {}, derivedAccountId);
-    try {
-        await addMcpServerToConfig(args.client);
-    }
-    catch (e) {
-        process.exit(EXIT_CODES.ERROR);
-    }
-    process.exit(EXIT_CODES.SUCCESS);
-}
-function setupBuilder(yargs) {
-    yargs.option('client', {
-        describe: commands.mcp.setup.args.client,
-        type: 'array',
-        choices: [...supportedTools.map(tool => tool.value)],
-    });
-    return yargs;
-}
-const builder = makeYargsBuilder(setupBuilder, command, describe, {
-    useGlobalOptions: true,
-});
-const mcpSetupCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-export default mcpSetupCommand;

package/commands/mcp/start.d.ts

@@ -1,6 +0,0 @@
-import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
-interface McpStartArgs extends CommonArgs {
-    aiAgent?: string;
-}
-declare const mcpStartCommand: YargsCommandModule<unknown, McpStartArgs>;
-export default mcpStartCommand;

package/commands/mcp/start.js

@@ -1,72 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'path';
-import fs from 'fs';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-import { logError } from '../../lib/errorHandlers/index.js';
-import { commands } from '../../lang/en.js';
-import { handleExit } from '../../lib/process.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { fileURLToPath } from 'url';
-const command = 'start';
-const describe = undefined; // Leave hidden for now
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-async function handler(args) {
-    trackCommandUsage('mcp-start', {}, args.derivedAccountId);
-    await startMcpServer(args.aiAgent);
-}
-async function startMcpServer(aiAgent) {
-    try {
-        const serverPath = path.join(__dirname, '..', '..', 'mcp-server', 'server.js');
-        // Check if server file exists
-        if (!fs.existsSync(serverPath)) {
-            uiLogger.error(commands.mcp.start.errors.serverFileNotFound(serverPath));
-            return;
-        }
-        uiLogger.debug(commands.mcp.start.startingServer);
-        uiLogger.debug(commands.mcp.start.stopInstructions);
-        const args = [serverPath];
-        const child = spawn(`node`, args, {
-            stdio: 'inherit',
-            env: {
-                ...process.env,
-                HUBSPOT_MCP_AI_AGENT: aiAgent || 'unknown',
-            },
-        });
-        // Handle server process events
-        child.on('error', error => {
-            logError(error);
-            uiLogger.error(commands.mcp.start.errors.failedToStart);
-        });
-        child.on('close', () => {
-            uiLogger.info(commands.mcp.start.stoppedSuccessfully);
-        });
-        handleExit(() => {
-            uiLogger.info(commands.mcp.start.shuttingDown);
-            child.kill('SIGTERM');
-            process.exit(EXIT_CODES.SUCCESS);
-        });
-    }
-    catch (error) {
-        uiLogger.error(commands.mcp.start.errors.failedToStart);
-        logError(error);
-    }
-}
-function startBuilder(yargs) {
-    yargs.option('ai-agent', {
-        type: 'string',
-    });
-    return yargs;
-}
-const builder = makeYargsBuilder(startBuilder, command, describe, {
-    useGlobalOptions: true,
-});
-const mcpStartCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-export default mcpStartCommand;

package/commands/mcp.d.ts

@@ -1,3 +0,0 @@
-import { YargsCommandModuleBucket } from '../types/Yargs.js';
-declare const mcpCommand: YargsCommandModuleBucket;
-export default mcpCommand;

package/commands/mcp.js

@@ -1,20 +0,0 @@
-import startCommand from './mcp/start.js';
-import setupCommand from './mcp/setup.js';
-import { makeYargsBuilder } from '../lib/yargsUtils.js';
-import { commands } from '../lang/en.js';
-const command = 'mcp';
-const describe = commands.mcp.describe;
-function mcpBuilder(yargs) {
-    yargs.command(startCommand).command(setupCommand).demandCommand(1, '');
-    return yargs;
-}
-const builder = makeYargsBuilder(mcpBuilder, command, describe, {
-    useGlobalOptions: true,
-});
-const mcpCommand = {
-    command,
-    describe,
-    builder,
-    handler: () => { },
-};
-export default mcpCommand;

package/commands/open.d.ts

@@ -1,7 +0,0 @@
-import { CommonArgs, ConfigArgs, EnvironmentArgs, AccountArgs, YargsCommandModule } from '../types/Yargs.js';
-type OpenArgs = CommonArgs & ConfigArgs & EnvironmentArgs & AccountArgs & {
-    shortcut?: string;
-    list?: boolean;
-};
-declare const openCommand: YargsCommandModule<unknown, OpenArgs>;
-export default openCommand;

package/commands/open.js

@@ -1,70 +0,0 @@
-import { trackCommandUsage } from '../lib/usageTracking.js';
-import { logSiteLinks, getSiteLinksAsArray, openLink } from '../lib/links.js';
-import { promptUser } from '../lib/prompts/promptUtils.js';
-import { commands } from '../lang/en.js';
-import { EXIT_CODES } from '../lib/enums/exitCodes.js';
-import { makeYargsBuilder } from '../lib/yargsUtils.js';
-const separator = ' => ';
-async function createListPrompt(accountId) {
-    return promptUser({
-        name: 'open',
-        type: 'rawlist',
-        pageSize: 20,
-        message: commands.open.selectLink,
-        choices: getSiteLinksAsArray(accountId)
-            .filter(l => !!l.url)
-            .map(l => ({
-            name: `${l.shortcut}${separator}${l.url}`,
-            value: l.shortcut,
-        })),
-    });
-}
-const command = 'open [shortcut]';
-const describe = commands.open.describe;
-async function handler(args) {
-    const { shortcut, list, derivedAccountId } = args;
-    trackCommandUsage('open', undefined, derivedAccountId);
-    if (shortcut === undefined && !list) {
-        const { open } = await createListPrompt(derivedAccountId);
-        openLink(derivedAccountId, open);
-    }
-    else if (list) {
-        logSiteLinks(derivedAccountId);
-    }
-    else if (shortcut) {
-        openLink(derivedAccountId, shortcut);
-    }
-    process.exit(EXIT_CODES.SUCCESS);
-}
-function openBuilder(yargs) {
-    yargs.positional('[shortcut]', {
-        describe: commands.open.positionals.shortcut.describe,
-        type: 'string',
-    });
-    yargs.option('list', {
-        alias: 'l',
-        describe: commands.open.options.list.describe,
-        type: 'boolean',
-    });
-    yargs.example([
-        ['$0 open'],
-        ['$0 open --list'],
-        ['$0 open settings'],
-        ['$0 open settings/navigation'],
-        ['$0 open sn'],
-    ]);
-    return yargs;
-}
-const builder = makeYargsBuilder(openBuilder, command, describe, {
-    useGlobalOptions: true,
-    useConfigOptions: true,
-    useAccountOptions: true,
-    useEnvironmentOptions: true,
-});
-const openCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-export default openCommand;

package/commands/project/__tests__/add.test.d.ts

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

package/commands/project/__tests__/add.test.js

@@ -1,107 +0,0 @@
-import yargs from 'yargs';
-import projectAddCommand from '../add.js';
-import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, } from '../../../lib/constants.js';
-import { v2AddComponent } from '../../../lib/projects/add/v2AddComponent.js';
-import { legacyAddComponent } from '../../../lib/projects/add/legacyAddComponent.js';
-import { getProjectConfig } from '../../../lib/projects/config.js';
-import { isV2Project } from '../../../lib/projects/platformVersion.js';
-import { trackCommandUsage } from '../../../lib/usageTracking.js';
-vi.mock('../../../lib/commonOpts');
-vi.mock('../../../lib/errorHandlers/index.js');
-vi.mock('../../../lib/projects/add/v2AddComponent');
-vi.mock('../../../lib/projects/add/legacyAddComponent');
-vi.mock('../../../lib/projects/config');
-vi.mock('../../../lib/projects/platformVersion');
-const mockedV2AddComponent = vi.mocked(v2AddComponent);
-const mockedLegacyAddComponent = vi.mocked(legacyAddComponent);
-const mockedGetProjectConfig = vi.mocked(getProjectConfig);
-const mockedUseV2Api = vi.mocked(isV2Project);
-const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
-describe('commands/project/add', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(projectAddCommand.command).toEqual('add');
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(projectAddCommand.describe).toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            projectAddCommand.builder(yargsMock);
-            expect(yargsMock.example).toHaveBeenCalledTimes(2);
-            expect(yargsMock.options).toHaveBeenCalledWith({
-                auth: expect.objectContaining({
-                    type: 'string',
-                    choices: expect.arrayContaining([staticAuth, oAuth]),
-                }),
-                distribution: expect.objectContaining({
-                    type: 'string',
-                    choices: expect.arrayContaining([
-                        privateDistribution,
-                        marketplaceDistribution,
-                    ]),
-                }),
-                features: expect.objectContaining({
-                    type: 'array',
-                }),
-                name: expect.objectContaining({
-                    type: 'string',
-                }),
-                type: expect.objectContaining({ type: 'string' }),
-            });
-        });
-    });
-    describe('handler', () => {
-        const mockProjectConfig = {
-            name: 'test-project',
-            srcDir: 'src',
-            platformVersion: '2025.2',
-        };
-        const mockProjectDir = '/path/to/project';
-        const mockArgs = {
-            derivedAccountId: 123,
-            name: 'test-component',
-            type: 'module',
-        };
-        beforeEach(() => {
-            mockedGetProjectConfig.mockResolvedValue({
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            mockedTrackCommandUsage.mockResolvedValue();
-            mockedV2AddComponent.mockResolvedValue();
-            mockedLegacyAddComponent.mockResolvedValue();
-            vi.spyOn(process, 'exit').mockImplementation(() => {
-                throw new Error('process.exit called');
-            });
-        });
-        it('should call v2AddComponent with accountId for v2 projects', async () => {
-            mockedUseV2Api.mockReturnValue(true);
-            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
-            expect(mockedV2AddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig, 123);
-            expect(mockedLegacyAddComponent).not.toHaveBeenCalled();
-        });
-        it('should call legacyAddComponent for non-v2 projects', async () => {
-            mockedUseV2Api.mockReturnValue(false);
-            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
-            expect(mockedLegacyAddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig, 123);
-            expect(mockedV2AddComponent).not.toHaveBeenCalled();
-        });
-        it('should exit with error when project config is not found', async () => {
-            mockedGetProjectConfig.mockResolvedValue({
-                projectConfig: null,
-                projectDir: null,
-            });
-            const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
-                throw new Error('process.exit called');
-            });
-            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
-            expect(mockExit).toHaveBeenCalledWith(1);
-            mockExit.mockRestore();
-        });
-    });
-});

package/commands/project/__tests__/create.test.d.ts

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

package/commands/project/__tests__/create.test.js

@@ -1,97 +0,0 @@
-import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
-import projectCreateCommand from '../create.js';
-vi.mock('../../../lib/commonOpts');
-describe('commands/project/create', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(projectCreateCommand.command).toEqual(['create', 'init']);
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(projectCreateCommand.describe).toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            projectCreateCommand.builder(yargsMock);
-            expect(addAccountOptions).toHaveBeenCalledTimes(1);
-            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
-        });
-        it('should define project creation options', () => {
-            const optionsSpy = vi.spyOn(yargsMock, 'options');
-            const exampleSpy = vi.spyOn(yargsMock, 'example');
-            const conflictsSpy = vi.spyOn(yargsMock, 'conflicts');
-            projectCreateCommand.builder(yargsMock);
-            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
-                name: expect.any(Object),
-                dest: expect.any(Object),
-                template: expect.any(Object),
-                'template-source': expect.any(Object),
-                'platform-version': expect.any(Object),
-                'project-base': expect.any(Object),
-                distribution: expect.any(Object),
-                auth: expect.any(Object),
-                features: expect.any(Object),
-            }));
-            expect(conflictsSpy).toHaveBeenCalledWith('template', 'features');
-            expect(exampleSpy).toHaveBeenCalled();
-        });
-        it('should define platform version option with correct choices', () => {
-            const optionsSpy = vi.spyOn(yargsMock, 'options');
-            projectCreateCommand.builder(yargsMock);
-            const optionsCall = optionsSpy.mock.calls[0][0];
-            expect(optionsCall['platform-version']).toEqual(expect.objectContaining({
-                describe: 'The target platform version for the new project.',
-                type: 'string',
-                choices: ['2025.1', '2025.2', '2026.03-beta', '2026.03'],
-                default: '2026.03',
-            }));
-        });
-        it('should define project base option with correct choices', () => {
-            const optionsSpy = vi.spyOn(yargsMock, 'options');
-            projectCreateCommand.builder(yargsMock);
-            const optionsCall = optionsSpy.mock.calls[0][0];
-            expect(optionsCall['project-base']).toEqual(expect.objectContaining({
-                describe: 'The top level component to include in the project.',
-                type: 'string',
-                choices: ['empty', 'app'],
-            }));
-        });
-        it('should define distribution option with correct choices', () => {
-            const optionsSpy = vi.spyOn(yargsMock, 'options');
-            projectCreateCommand.builder(yargsMock);
-            const optionsCall = optionsSpy.mock.calls[0][0];
-            expect(optionsCall.distribution).toEqual(expect.objectContaining({
-                describe: 'How the app will be distributed.',
-                type: 'string',
-                choices: ['private', 'marketplace'],
-            }));
-        });
-        it('should define auth option with correct choices', () => {
-            const optionsSpy = vi.spyOn(yargsMock, 'options');
-            projectCreateCommand.builder(yargsMock);
-            const optionsCall = optionsSpy.mock.calls[0][0];
-            expect(optionsCall.auth).toEqual(expect.objectContaining({
-                describe: 'Authentication model for the app.',
-                type: 'string',
-                choices: ['oauth', 'static'],
-            }));
-        });
-        it('should define features option as array', () => {
-            const optionsSpy = vi.spyOn(yargsMock, 'options');
-            projectCreateCommand.builder(yargsMock);
-            const optionsCall = optionsSpy.mock.calls[0][0];
-            expect(optionsCall.features).toEqual(expect.objectContaining({
-                describe: 'Features to include in the project. Only valid if project-base is app',
-                type: 'array',
-            }));
-        });
-    });
-});

package/commands/project/__tests__/deploy.test.d.ts

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