@hubspot/cli 7.8.12-experimental.0 → 7.8.12-experimental.1

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/utils/toolUsageTracking.js

@@ -1,7 +1,7 @@
 import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { EventClass, getNodeVersionData, getPlatform, } from '../../lib/usageTracking.js';
 import { getAccountId, isTrackingAllowed } from '@hubspot/local-dev-lib/config';
+import { uiLogger } from '../../lib/ui/logger.js';
 export async function trackToolUsage(toolName, meta) {
     if (!isTrackingAllowed()) {
         return;
@@ -16,7 +16,7 @@ export async function trackToolUsage(toolName, meta) {
     };
     const accountId = getAccountId() || undefined;
     try {
-        logger.info('Tracking tool usage');
+        uiLogger.info('Tracking tool usage');
         await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
     }
     catch (error) { }

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.8.12-experimental.0",
+    "version": "7.8.12-experimental.1",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "type": "module",
     "dependencies": {
-        "@hubspot/local-dev-lib": "3.19.1",
-        "@hubspot/project-parsing-lib": "0.8.6",
+        "@hubspot/local-dev-lib": "3.20.0",
+        "@hubspot/project-parsing-lib": "0.10.0-beta.0",
         "@hubspot/serverless-dev-runtime": "7.0.6",
         "@hubspot/theme-preview-dev-server": "0.0.10",
-        "@hubspot/ui-extensions-dev-server": "0.10.0",
+        "@hubspot/ui-extensions-dev-server": "0.10.1",
         "archiver": "7.0.1",
         "boxen": "8.0.1",
         "chalk": "5.4.1",
@@ -29,7 +29,7 @@
         "react": "^18.0.0",
         "strip-ansi": "7.1.0",
         "table": "6.9.0",
-        "tmp": "0.2.3",
+        "tmp": "0.2.4",
         "update-notifier": "7.3.1",
         "ws": "^8.18.2",
         "yargs": "17.7.2",
@@ -52,7 +52,7 @@
         "@types/yargs": "^17.0.33",
         "@typescript-eslint/eslint-plugin": "^8.30.1",
         "@typescript-eslint/parser": "^8.11.0",
-        "axios": "^1.7.4",
+        "axios": "^1.12.2",
         "eslint": "^8.56.0",
         "eslint-plugin-import": "^2.31.0",
         "husky": "^4.3.8",

package/types/Yargs.d.ts

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

package/commands/app/__tests__/install.test.js

@@ -1,47 +0,0 @@
-import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addGlobalOptions, addJSONOutputOptions, } from '../../../lib/commonOpts.js';
-import installCommand from '../install.js';
-vi.mock('../../../lib/commonOpts');
-describe('commands/app/install', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(installCommand.command).toEqual('install <test-account-id>');
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(installCommand.describe).not.toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            installCommand.builder(yargsMock);
-            expect(addGlobalOptions).toHaveBeenCalledTimes(1);
-            expect(addGlobalOptions).toHaveBeenCalledWith(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);
-            expect(addJSONOutputOptions).toHaveBeenCalledTimes(1);
-            expect(addJSONOutputOptions).toHaveBeenCalledWith(yargsMock);
-            expect(yargsMock.positional).toHaveBeenCalledTimes(1);
-            expect(yargsMock.positional).toHaveBeenCalledWith('test-account-id', expect.objectContaining({
-                type: 'number',
-                required: true,
-                describe: expect.any(String),
-            }));
-            expect(yargsMock.option).toHaveBeenCalledTimes(2);
-            expect(yargsMock.option).toHaveBeenCalledWith('app-uid', expect.objectContaining({
-                type: 'string',
-                describe: expect.any(String),
-            }));
-            expect(yargsMock.option).toHaveBeenCalledWith('project-name', expect.objectContaining({
-                type: 'string',
-                describe: expect.any(String),
-            }));
-        });
-    });
-});

package/commands/app/install.d.ts

@@ -1,8 +0,0 @@
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule, JSONOutputArgs } from '../../types/Yargs.js';
-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,122 +0,0 @@
-import { fetchDeveloperTestAccountOauthAppInstallStatus, installOauthAppIntoDeveloperTestAccount, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { commands } from '../../lang/en.js';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { APP_AUTH_TYPES } from '../../lib/constants.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-import SpinniesManager from '../../lib/ui/SpinniesManager.js';
-import { poll } from '../../lib/polling.js';
-import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
-import { handleTranslate } from '../../lib/projects/upload.js';
-import { isAppIRNode } from '../../lib/projects/structure.js';
-import { logError } from '../../lib/errorHandlers/index.js';
-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;
-    trackCommandUsage('app-install', {}, derivedAccountId);
-    const jsonOutput = {};
-    let targetProjectName = projectName;
-    let targetAppUid = appUid;
-    const { projectConfig, projectDir } = await getProjectConfig();
-    if (!targetProjectName) {
-        validateProjectConfig(projectConfig, projectDir);
-        targetProjectName = projectConfig?.name;
-    }
-    if (!targetProjectName) {
-        uiLogger.error(commands.app.subcommands.install.errors.mustSpecifyProjectName);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    let isAppOauth = true;
-    if (!targetAppUid) {
-        const intermediateRepresentation = await handleTranslate(projectDir, projectConfig, derivedAccountId, true, undefined);
-        if (intermediateRepresentation) {
-            Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).forEach(node => {
-                if (isAppIRNode(node)) {
-                    targetAppUid = node.uid;
-                    isAppOauth = node.config.auth.type === APP_AUTH_TYPES.OAUTH;
-                }
-            });
-        }
-    }
-    if (!targetAppUid) {
-        uiLogger.error(commands.app.subcommands.install.errors.noAppUidFound);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!isAppOauth) {
-        uiLogger.error(commands.app.subcommands.install.errors.appMustBeOauth);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        const { data } = await installOauthAppIntoDeveloperTestAccount(derivedAccountId, testAccountId, targetProjectName, targetAppUid);
-        if (data?.authCodes.length > 0) {
-            jsonOutput.authCode = data.authCodes[0].authCode;
-        }
-    }
-    catch (err) {
-        logError(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    SpinniesManager.init({
-        succeedColor: 'white',
-    });
-    SpinniesManager.add('installApp', {
-        text: commands.app.subcommands.install.polling.start,
-    });
-    let appInstallSucceeded = false;
-    try {
-        await poll(() => fetchDeveloperTestAccountOauthAppInstallStatus(derivedAccountId, targetProjectName, targetAppUid), {
-            successStates: ['SUCCESS'],
-            errorStates: [],
-        });
-        appInstallSucceeded = true;
-    }
-    catch (err) {
-        SpinniesManager.fail('installApp');
-        logError(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!appInstallSucceeded) {
-        SpinniesManager.fail('installApp');
-        process.exit(EXIT_CODES.ERROR);
-    }
-    SpinniesManager.succeed('installApp', {
-        text: commands.app.subcommands.install.polling.success,
-    });
-    if (formatOutputAsJson) {
-        uiLogger.json(jsonOutput);
-    }
-    process.exit(EXIT_CODES.SUCCESS);
-}
-function installAppBuilder(yargs) {
-    yargs.positional('test-account-id', {
-        describe: commands.app.subcommands.install.positionals.testAccountId,
-        required: true,
-        type: 'number',
-    });
-    yargs.option('app-uid', {
-        describe: commands.app.subcommands.install.options.appUid,
-        type: 'string',
-    });
-    yargs.option('project-name', {
-        describe: commands.app.subcommands.install.options.projectName,
-        type: 'string',
-    });
-    yargs.example('install 1234567890 --app-uid=my-app-uid --project-name=my-project', commands.app.subcommands.install.example);
-    return yargs;
-}
-const builder = makeYargsBuilder(installAppBuilder, command, commands.app.subcommands.install.describe, {
-    useGlobalOptions: true,
-    useAccountOptions: true,
-    useConfigOptions: true,
-    useEnvironmentOptions: true,
-    useJSONOutputOptions: true,
-});
-const installAppCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-export default installAppCommand;

package/lib/middleware/__test__/utils.test.js

@@ -1,51 +0,0 @@
-import { isTargetedCommand } from '../utils.js';
-const targetCommandMap = {
-    init: { target: true },
-    account: {
-        target: true,
-        subCommands: {
-            use: { target: true },
-        },
-    },
-    project: {
-        subCommands: {
-            deploy: { target: true },
-        },
-    },
-};
-describe('lib/middleware/utils', () => {
-    describe('isTargetedCommand()', () => {
-        it('should return true for a direct target command', () => {
-            const result = isTargetedCommand(['init'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return true for a command with a subcommand', () => {
-            const result = isTargetedCommand(['account'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return true for a nested target command', () => {
-            const result = isTargetedCommand(['project', 'deploy'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return false for a non-existent command', () => {
-            const result = isTargetedCommand(['nonexistent'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a non-targeted command', () => {
-            const result = isTargetedCommand(['auth'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a command with a targeted subcommand', () => {
-            const result = isTargetedCommand(['project'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a non-existent subcommand', () => {
-            const result = isTargetedCommand(['auth', 'nonexistent'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for an empty command array', () => {
-            const result = isTargetedCommand([], targetCommandMap);
-            expect(result).toBe(false);
-        });
-    });
-});

package/lib/middleware/utils.d.ts

@@ -1,8 +0,0 @@
-type TargetCommandMap = {
-    [key: string]: {
-        target?: boolean;
-        subCommands?: TargetCommandMap;
-    };
-};
-export declare function isTargetedCommand(commandParts: (string | number)[], targetCommandMap: TargetCommandMap): boolean;
-export {};

package/lib/middleware/utils.js

@@ -1,14 +0,0 @@
-export function isTargetedCommand(commandParts, targetCommandMap) {
-    const currentCommand = commandParts[0];
-    if (!targetCommandMap[currentCommand]) {
-        return false;
-    }
-    if (targetCommandMap[currentCommand].target) {
-        return true;
-    }
-    const subCommands = targetCommandMap[currentCommand].subCommands || {};
-    if (commandParts.length > 1) {
-        return isTargetedCommand(commandParts.slice(1), subCommands);
-    }
-    return false;
-}