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

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/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/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.7.34-experimental.0",
+    "version": "7.8.0-beta.0",
     "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.18.0",
-        "@hubspot/project-parsing-lib": "0.8.3",
+        "@hubspot/local-dev-lib": "3.20.0",
+        "@hubspot/project-parsing-lib": "0.9.0",
         "@hubspot/serverless-dev-runtime": "7.0.6",
         "@hubspot/theme-preview-dev-server": "0.0.10",
-        "@hubspot/ui-extensions-dev-server": "0.9.8",
+        "@hubspot/ui-extensions-dev-server": "0.10.1",
         "archiver": "7.0.1",
         "boxen": "8.0.1",
         "chalk": "5.4.1",

package/types/LocalDev.d.ts

@@ -1,17 +1,17 @@
 import { HSProfileVariables, IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { ProjectConfig } from './Projects.js';
 import LocalDevState from '../lib/projects/localDev/LocalDevState.js';
-import { APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../lib/constants.js';
+import { APP_INSTALLATION_STATES, LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../lib/constants.js';
 export type LocalDevStateConstructorOptions = {
     targetProjectAccountId: number;
     targetTestingAccountId: number;
     profile?: string;
     projectConfig: ProjectConfig;
     projectDir: string;
-    projectId: number;
-    projectName: string;
+    projectData: Project;
     debug?: boolean;
     initialProjectNodes: {
         [key: string]: IntermediateRepresentationNodeLocalDev;
@@ -23,6 +23,12 @@ export type LocalDevWebsocketMessage = {
     type: string;
     data?: unknown;
 };
+export type LocalDevDeployWebsocketMessage = {
+    type: typeof LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.DEPLOY;
+    data: {
+        force: boolean;
+    };
+};
 export type LocalDevStateListener<K extends keyof LocalDevState> = (value: LocalDevState[K]) => void;
 export type AppLocalDevData = {
     id: number;
@@ -32,3 +38,13 @@ export type AppLocalDevData = {
     scopeGroupIds: number[];
 };
 export type LocalDevServerMessage = ValueOf<typeof LOCAL_DEV_SERVER_MESSAGE_TYPES>;
+export type LocalDevProjectUploadResult = {
+    uploadSuccess: boolean;
+    buildSuccess: boolean;
+    deploySuccess?: boolean;
+    deployId?: number;
+};
+export type LocalDevProjectDeployResult = {
+    success: boolean;
+    deployId?: number;
+};

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/ui/index.js

@@ -1,5 +1,5 @@
 import { render } from 'ink';
-// Ink components will be enabled by setting the ENABLE_INK environment variable
+// Ink components will be enabled by setting the HUBSPOT_ENABLE_INK environment variable
 export async function renderInline(component) {
     const { unmount } = render(component, { patchConsole: false });
     unmount();

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;
-}