@hubspot/cli 7.7.29-experimental.0 → 7.7.31-experimental.0

package/commands/app/__tests__/install.test.d.ts

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

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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,122 @@
+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/commands/app.js

@@ -1,11 +1,16 @@
 import migrateCommand from './app/migrate.js';
 import appSecretCommand from './app/secret.js';
+import installAppCommand from './app/install.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 const command = ['app', 'apps'];
 // Keep the command hidden for now
 const describe = undefined;
 function appBuilder(yargs) {
-    yargs.command(migrateCommand).command(appSecretCommand).demandCommand(1, '');
+    yargs
+        .command(migrateCommand)
+        .command(appSecretCommand)
+        .command(installAppCommand)
+        .demandCommand(1, '');
     return yargs;
 }
 const builder = makeYargsBuilder(appBuilder, command, describe);

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

@@ -1,7 +1,22 @@
 import yargs from 'yargs';
 import projectAddCommand from '../add.js';
 import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, } from '../../../lib/constants.js';
+import { v3AddComponent } from '../../../lib/projects/add/v3AddComponent.js';
+import { legacyAddComponent } from '../../../lib/projects/add/legacyAddComponent.js';
+import { getProjectConfig } from '../../../lib/projects/config.js';
+import { useV3Api } from '../../../lib/projects/buildAndDeploy.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
 vi.mock('../../../lib/commonOpts');
+vi.mock('../../../lib/projects/add/v3AddComponent');
+vi.mock('../../../lib/projects/add/legacyAddComponent');
+vi.mock('../../../lib/projects/config');
+vi.mock('../../../lib/projects/buildAndDeploy');
+vi.mock('../../../lib/usageTracking');
+const mockedV3AddComponent = vi.mocked(v3AddComponent);
+const mockedLegacyAddComponent = vi.mocked(legacyAddComponent);
+const mockedGetProjectConfig = vi.mocked(getProjectConfig);
+const mockedUseV3Api = vi.mocked(useV3Api);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('commands/project/add', () => {
     const yargsMock = yargs;
     describe('command', () => {
@@ -40,4 +55,55 @@ describe('commands/project/add', () => {
             });
         });
     });
+    describe('handler', () => {
+        const mockProjectConfig = {
+            name: 'test-project',
+            srcDir: 'src',
+            platformVersion: 'v3',
+        };
+        const mockProjectDir = '/path/to/project';
+        const mockArgs = {
+            derivedAccountId: 123,
+            name: 'test-component',
+            type: 'module',
+        };
+        beforeEach(() => {
+            mockedGetProjectConfig.mockResolvedValue({
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            mockedTrackCommandUsage.mockResolvedValue();
+            mockedV3AddComponent.mockResolvedValue();
+            mockedLegacyAddComponent.mockResolvedValue();
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error('process.exit called');
+            });
+        });
+        it('should call v3AddComponent with accountId for v3 projects', async () => {
+            mockedUseV3Api.mockReturnValue(true);
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', undefined, 123);
+            expect(mockedV3AddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig, 123);
+            expect(mockedLegacyAddComponent).not.toHaveBeenCalled();
+        });
+        it('should call legacyAddComponent for non-v3 projects', async () => {
+            mockedUseV3Api.mockReturnValue(false);
+            await expect(projectAddCommand.handler(mockArgs)).rejects.toThrow('process.exit called');
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', undefined, 123);
+            expect(mockedLegacyAddComponent).toHaveBeenCalledWith(mockArgs, mockProjectDir, mockProjectConfig);
+            expect(mockedV3AddComponent).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/add.d.ts

@@ -1,5 +1,5 @@
 import { YargsCommandModule, CommonArgs } from '../../types/Yargs.js';
-type ProjectAddArgs = CommonArgs & {
+export type ProjectAddArgs = CommonArgs & {
     type?: string;
     name?: string;
     features?: string[];

package/commands/project/add.js

@@ -23,7 +23,7 @@ async function handler(args) {
         }
         const isV3ProjectCreate = useV3Api(projectConfig.platformVersion);
         if (isV3ProjectCreate) {
-            await v3AddComponent(args, projectDir, projectConfig);
+            await v3AddComponent(args, projectDir, projectConfig, derivedAccountId);
         }
         else {
             await legacyAddComponent(args, projectDir, projectConfig);

package/commands/project/create.js

@@ -41,7 +41,7 @@ async function handler(args) {
         type: selectProjectTemplatePromptResponse.projectTemplate?.name ||
             (selectProjectTemplatePromptResponse.componentTemplates || [])
                 // @ts-expect-error
-                .map((item) => item.label)
+                .map((item) => item.type)
                 .join(','),
     }, derivedAccountId);
     const projectDest = path.resolve(getCwd(), projectNameAndDestPromptResponse.dest);

package/commands/project/upload.d.ts

@@ -1,5 +1,5 @@
-import { CommonArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectUploadArgs = CommonArgs & JSONOutputArgs & {
+import { CommonArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectUploadArgs = CommonArgs & JSONOutputArgs & EnvironmentArgs & {
     forceCreate: boolean;
     message: string;
     m: string;

package/commands/project/upload.js

@@ -25,7 +25,7 @@ async function handler(args) {
     validateProjectConfig(projectConfig, projectDir);
     let targetAccountId;
     if (useV3Api(projectConfig.platformVersion)) {
-        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile, args.useEnv);
     }
     targetAccountId = targetAccountId || derivedAccountId;
     const accountConfig = getAccountConfig(targetAccountId);

package/commands/testAccount/create.js

@@ -75,6 +75,9 @@ async function handler(args) {
         resultJson.personalAccessKey = createResult.personalAccessKey;
     }
     catch (err) {
+        SpinniesManager.fail('createTestAccount', {
+            text: commands.testAccount.create.polling.createFailure,
+        });
         logError(err);
         SpinniesManager.fail('createTestAccount', {
             text: commands.testAccount.create.polling.createFailure,

package/lang/en.d.ts

@@ -884,12 +884,10 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
                 readonly configuringCursor: "Configuring Cursor...";
                 readonly failedToConfigureCursor: "Failed to configure Cursor";
                 readonly configuredCursor: "Configured Cursor";
-                readonly cursorNotFound: "Cursor not found - skipping configuration";
                 readonly alreadyInstalled: "HubSpot CLI mcp server already installed, reinstalling";
                 readonly configuringWindsurf: "Configuring Windsurf...";
                 readonly failedToConfigureWindsurf: "Failed to configure Windsurf";
                 readonly configuredWindsurf: "Configured Windsurf";
-                readonly windsurfNotFound: "Windsurf not found - skipping configuration";
                 readonly configuringVsCode: "Configuring VSCode...";
                 readonly failedToConfigureVsCode: "Failed to configure VSCode";
                 readonly configuredVsCode: "Configured VSCode";
@@ -1552,6 +1550,28 @@ ${string}`;
     readonly app: {
         readonly describe: "Commands for managing apps.";
         readonly subcommands: {
+            readonly install: {
+                readonly describe: "Install an OAuth app into a test account.";
+                readonly options: {
+                    readonly appUid: "The uid of the app to install";
+                    readonly projectName: "The name of the project that contains the app";
+                };
+                readonly positionals: {
+                    readonly testAccountId: "The id of the test account to install the app into";
+                };
+                readonly errors: {
+                    readonly mustSpecifyProjectName: `You must specify a project name. Use the ${string} flag to specify the project name or run this command from within a project directory.`;
+                    readonly noAppUidFound: `No app uid found. Please specify the app uid with the ${string} flag or run this command from within a project that contains an app.`;
+                    readonly appMustBeOauth: "This command only supports installing oauth apps. Please specify an app with oauth auth type.";
+                };
+                readonly polling: {
+                    readonly start: "Installing app...";
+                    readonly success: "App installed successfully";
+                    readonly failure: "App installation failed";
+                    readonly error: "Error installing app";
+                };
+                readonly example: "Install the app with uid my-app-uid from the project named \"my-project\" into the target account with id 1234567890";
+            };
             readonly secret: {
                 readonly describe: "Commands for managing secrets.";
                 readonly subcommands: {
@@ -2571,6 +2591,8 @@ export declare const lib: {
             readonly activeInstallations: (appName: string, installCount: number) => string;
             readonly error: "An error occurred while checking installations for your app";
         };
+        readonly distributionChanged: `Your app's distribution type has been changed from private to marketplace. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${string} change your app's distribution type. This will uninstall your app from all accounts.`;
+        readonly authTypeChanged: `Your app's auth type has been changed from static to oauth. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${string} change your app's auth type. This will uninstall your app from all accounts.`;
     };
     readonly LocalDevWebsocketServer: {
         readonly errors: {

package/lang/en.js

@@ -5,7 +5,7 @@ import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constant
 import { ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME, GLOBAL_CONFIG_PATH, DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME, } from '@hubspot/local-dev-lib/constants/config';
 import { uiAccountDescription, uiBetaTag, uiCommandReference, uiLink, UI_COLORS, } from '../lib/ui/index.js';
 import { getProjectDetailUrl, getProjectSettingsUrl, getLocalDevUiUrl, } from '../lib/projects/urls.js';
-import { PROJECT_CONFIG_FILE, PROJECT_WITH_APP } from '../lib/constants.js';
+import { APP_DISTRIBUTION_TYPES, APP_AUTH_TYPES, PROJECT_CONFIG_FILE, PROJECT_WITH_APP, } from '../lib/constants.js';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 export const commands = {
     generalErrors: {
@@ -889,13 +889,11 @@ export const commands = {
                 configuringCursor: 'Configuring Cursor...',
                 failedToConfigureCursor: 'Failed to configure Cursor',
                 configuredCursor: 'Configured Cursor',
-                cursorNotFound: 'Cursor not found - skipping configuration',
                 alreadyInstalled: 'HubSpot CLI mcp server already installed, reinstalling',
                 // Windsurf
                 configuringWindsurf: 'Configuring Windsurf...',
                 failedToConfigureWindsurf: 'Failed to configure Windsurf',
                 configuredWindsurf: 'Configured Windsurf',
-                windsurfNotFound: 'Windsurf not found - skipping configuration',
                 // VS Code
                 configuringVsCode: 'Configuring VSCode...',
                 failedToConfigureVsCode: 'Failed to configure VSCode',
@@ -1549,6 +1547,28 @@ export const commands = {
     app: {
         describe: 'Commands for managing apps.',
         subcommands: {
+            install: {
+                describe: 'Install an OAuth app into a test account.',
+                options: {
+                    appUid: 'The uid of the app to install',
+                    projectName: 'The name of the project that contains the app',
+                },
+                positionals: {
+                    testAccountId: 'The id of the test account to install the app into',
+                },
+                errors: {
+                    mustSpecifyProjectName: `You must specify a project name. Use the ${uiCommandReference('--project-name')} flag to specify the project name or run this command from within a project directory.`,
+                    noAppUidFound: `No app uid found. Please specify the app uid with the ${uiCommandReference('--app-uid')} flag or run this command from within a project that contains an app.`,
+                    appMustBeOauth: 'This command only supports installing oauth apps. Please specify an app with oauth auth type.',
+                },
+                polling: {
+                    start: 'Installing app...',
+                    success: 'App installed successfully',
+                    failure: 'App installation failed',
+                    error: 'Error installing app',
+                },
+                example: 'Install the app with uid my-app-uid from the project named "my-project" into the target account with id 1234567890',
+            },
             secret: {
                 describe: 'Commands for managing secrets.',
                 subcommands: {
@@ -2568,6 +2588,8 @@ export const lib = {
             activeInstallations: (appName, installCount) => `[WARNING] Your app ${chalk.bold(appName)} is installed in ${chalk.bold(`${installCount} ${installCount === 1 ? 'account' : 'accounts'}`)}`,
             error: 'An error occurred while checking installations for your app',
         },
+        distributionChanged: `Your app's distribution type has been changed from ${APP_DISTRIBUTION_TYPES.PRIVATE} to ${APP_DISTRIBUTION_TYPES.MARKETPLACE}. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${chalk.bold('permanantly')} change your app's distribution type. This will uninstall your app from all accounts.`,
+        authTypeChanged: `Your app's auth type has been changed from ${APP_AUTH_TYPES.STATIC} to ${APP_AUTH_TYPES.OAUTH}. Once uploaded, this change cannot be reversed. Before uploading your project, confirm that you want to ${chalk.bold('permanantly')} change your app's auth type. This will uninstall your app from all accounts.`,
     },
     LocalDevWebsocketServer: {
         errors: {

package/lib/mcp/setup.d.ts

@@ -16,8 +16,8 @@ interface McpCommand {
     args: string[];
 }
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
-export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
-export declare function setupCursor(mcpCommand?: McpCommand): Promise<boolean>;
-export declare function setupWindsurf(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupCursor(mcpCommand?: McpCommand): boolean;
+export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
 export {};

package/lib/mcp/setup.js

@@ -4,6 +4,10 @@ import { promptUser } from '../prompts/promptUtils.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError } from '../errorHandlers/index.js';
 import { execAsync } from '../../mcp-server/utils/command.js';
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { existsSync } from 'fs';
 const mcpServerName = 'hubspot-cli-mcp';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
@@ -68,6 +72,96 @@ async function runSetupFunction(func) {
         throw new Error();
     }
 }
+function setupMcpConfigFile(config) {
+    try {
+        SpinniesManager.add('spinner', {
+            text: config.configuringMessage,
+        });
+        if (!existsSync(config.configPath)) {
+            fs.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
+        }
+        let mcpConfig = {};
+        let configContent;
+        try {
+            configContent = fs.readFileSync(config.configPath, 'utf8');
+        }
+        catch (error) {
+            SpinniesManager.fail('spinner', {
+                text: config.failedMessage,
+            });
+            logError(error);
+            return false;
+        }
+        try {
+            // In the event the file exists, but is empty, initialize it to and empty object
+            if (configContent.trim() === '') {
+                mcpConfig = {};
+            }
+            else {
+                mcpConfig = JSON.parse(configContent);
+            }
+        }
+        catch (error) {
+            SpinniesManager.fail('spinner', {
+                text: config.failedMessage,
+            });
+            uiLogger.error(commands.mcp.setup.errors.errorParsingJsonFIle(config.configPath, error instanceof Error ? error.message : `${error}`));
+            return false;
+        }
+        // Initialize mcpServers if it doesn't exist
+        if (!mcpConfig.mcpServers) {
+            mcpConfig.mcpServers = {};
+        }
+        // Add or update HubSpot CLI MCP server
+        mcpConfig.mcpServers[mcpServerName] = {
+            ...config.mcpCommand,
+        };
+        // Write the updated config
+        fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
+        SpinniesManager.succeed('spinner', {
+            text: config.configuredMessage,
+        });
+        return true;
+    }
+    catch (error) {
+        SpinniesManager.fail('spinner', {
+            text: config.failedMessage,
+        });
+        logError(error);
+        return false;
+    }
+}
+export async function setupVsCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('vsCode', {
+            text: commands.mcp.setup.spinners.configuringVsCode,
+        });
+        const mcpConfig = JSON.stringify({
+            name: mcpServerName,
+            ...buildCommandWithAgentString(mcpCommand, vscode),
+        });
+        await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
+        SpinniesManager.succeed('vsCode', {
+            text: commands.mcp.setup.spinners.configuredVsCode,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.includes('code: command not found')) {
+            SpinniesManager.fail('vsCode', {
+                text: commands.mcp.setup.spinners.vsCodeNotFound,
+            });
+        }
+        else {
+            SpinniesManager.fail('vsCode', {
+                text: commands.mcp.setup.spinners.failedToConfigureVsCode,
+            });
+            logError(error);
+        }
+        return false;
+    }
+}
 export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     try {
         SpinniesManager.add('claudeCode', {
@@ -88,7 +182,7 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
                 });
                 await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
             }
-            await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
+            await execAsync(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
             SpinniesManager.succeed('claudeCode', {
                 text: commands.mcp.setup.spinners.configuredClaudeCode,
             });
@@ -117,44 +211,25 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
         return false;
     }
 }
-async function setupVsCodeBasedIntegration(commandName, configuringText, configuredText, notFoundText, failedText, mcpCommand = defaultMcpCommand) {
-    try {
-        SpinniesManager.add(commandName, {
-            text: configuringText,
-        });
-        const mcpConfig = JSON.stringify({
-            name: mcpServerName,
-            ...buildCommandWithAgentString(mcpCommand, vscode),
-        });
-        await execAsync(`${commandName} --add-mcp ${JSON.stringify(mcpConfig)}`);
-        SpinniesManager.succeed(commandName, {
-            text: configuredText,
-        });
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes(commandName)) {
-            SpinniesManager.fail(commandName, {
-                text: notFoundText,
-            });
-        }
-        else {
-            SpinniesManager.fail(commandName, {
-                text: failedText,
-            });
-            logError(error);
-        }
-        return false;
-    }
-}
-export async function setupVsCode(mcpCommand = defaultMcpCommand) {
-    return setupVsCodeBasedIntegration('code', commands.mcp.setup.spinners.configuringVsCode, commands.mcp.setup.spinners.configuredVsCode, commands.mcp.setup.spinners.vsCodeNotFound, commands.mcp.setup.spinners.failedToConfigureVsCode, mcpCommand);
-}
-export async function setupCursor(mcpCommand = defaultMcpCommand) {
-    return setupVsCodeBasedIntegration('cursor', commands.mcp.setup.spinners.configuringCursor, commands.mcp.setup.spinners.configuredCursor, commands.mcp.setup.spinners.cursorNotFound, commands.mcp.setup.spinners.failedToConfigureCursor, mcpCommand);
+export function setupCursor(mcpCommand = defaultMcpCommand) {
+    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    return setupMcpConfigFile({
+        configPath: cursorConfigPath,
+        configuringMessage: commands.mcp.setup.spinners.configuringCursor,
+        configuredMessage: commands.mcp.setup.spinners.configuredCursor,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureCursor,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
+    });
 }
-export async function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    return setupVsCodeBasedIntegration('windsurf', commands.mcp.setup.spinners.configuringWindsurf, commands.mcp.setup.spinners.configuredWindsurf, commands.mcp.setup.spinners.windsurfNotFound, commands.mcp.setup.spinners.failedToConfigureWindsurf, mcpCommand);
+export function setupWindsurf(mcpCommand = defaultMcpCommand) {
+    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    return setupMcpConfigFile({
+        configPath: windsurfConfigPath,
+        configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,
+        configuredMessage: commands.mcp.setup.spinners.configuredWindsurf,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureWindsurf,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
+    });
 }
 function buildCommandWithAgentString(mcpCommand, agent) {
     const mcpCommandCopy = structuredClone(mcpCommand);

package/lib/projectProfiles.d.ts

@@ -4,4 +4,4 @@ export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
 export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
 export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined, useEnv?: boolean): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -38,7 +38,12 @@ export function loadProfile(projectConfig, projectDir, profileName) {
             uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
             return;
         }
-        return profile;
+        return {
+            ...profile,
+            accountId: process.env.HUBSPOT_ACCOUNT_ID
+                ? Number(process.env.HUBSPOT_ACCOUNT_ID)
+                : profile.accountId,
+        };
     }
     catch (e) {
         uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
@@ -54,7 +59,7 @@ export async function exitIfUsingProfiles(projectConfig, projectDir) {
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
+export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile, useEnv = false) {
     if (argsProfile) {
         logProfileHeader(argsProfile);
         const profile = loadProfile(projectConfig, projectDir, argsProfile);
@@ -63,6 +68,9 @@ export async function loadAndValidateProfile(projectConfig, projectDir, argsProf
             process.exit(EXIT_CODES.ERROR);
         }
         logProfileFooter(profile, true);
+        if (useEnv) {
+            return Number(process.env.HUBSPOT_ACCOUNT_ID);
+        }
         return profile.accountId;
     }
     else {

package/lib/projects/__tests__/AppDevModeInterface.test.js

@@ -100,6 +100,7 @@ describe('AppDevModeInterface', () => {
             setAppDataForUid: vi.fn(),
             addListener: vi.fn(),
             addUploadWarning: vi.fn(),
+            removeListener: vi.fn(),
         };
         mockLocalDevLogger = {};
         // Mock constructors
@@ -387,6 +388,15 @@ describe('AppDevModeInterface', () => {
             await appDevModeInterface.cleanup();
             expect(UIEDevModeInterface.cleanup).toHaveBeenCalled();
         });
+        it('should remove state listeners', async () => {
+            await appDevModeInterface.cleanup();
+            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('devServerMessage', 
+            // @ts-expect-error access private method for testing
+            appDevModeInterface.onDevServerMessage);
+            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('projectNodes', 
+            // @ts-expect-error
+            appDevModeInterface.onChangeProjectNodes);
+        });
     });
     describe('isAutomaticallyInstallable()', () => {
         it('should return true for static auth app on test account with correct parent', () => {

package/lib/projects/add/__tests__/v3AddComponent.test.js

@@ -7,6 +7,7 @@ import { projectAddPromptV3 } from '../../../prompts/projectAddPrompt.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { trackCommandUsage } from '../../../usageTracking.js';
 import { commands } from '../../../../lang/en.js';
 vi.mock('fs');
 vi.mock('../../../prompts/promptUtils');
@@ -16,6 +17,7 @@ vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/project-parsing-lib/src/lib/project');
+vi.mock('../../../usageTracking');
 const mockedFs = vi.mocked(fs);
 const mockedGetConfigForPlatformVersion = vi.mocked(getConfigForPlatformVersion);
 const mockedConfirmPrompt = vi.mocked(confirmPrompt);
@@ -24,6 +26,7 @@ const mockedProjectAddPromptV3 = vi.mocked(projectAddPromptV3);
 const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
 const mockedLogger = vi.mocked(logger);
 const mockedGetProjectMetadata = vi.mocked(getProjectMetadata);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('lib/projects/add/v3AddComponent', () => {
     const mockProjectConfig = {
         name: 'test-project',
@@ -32,6 +35,7 @@ describe('lib/projects/add/v3AddComponent', () => {
     };
     const mockArgs = { name: 'test-component', type: 'module' };
     const projectDir = '/path/to/project';
+    const mockAccountId = 123;
     const mockComponentTemplate = {
         label: 'Test Component',
         path: 'test-component',
@@ -62,6 +66,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             authType: 'oauth',
             distribution: 'private',
         });
+        mockedTrackCommandUsage.mockResolvedValue();
     });
     describe('v3AddComponent()', () => {
         it('successfully adds a component when app already exists', async () => {
@@ -79,10 +84,13 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedGetConfigForPlatformVersion).toHaveBeenCalledWith('v3');
             expect(mockedGetProjectMetadata).toHaveBeenCalledWith('/path/to/project/src');
             expect(mockedProjectAddPromptV3).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
                 sourceDir: ['v3/test-component'],
                 hideLogs: true,
@@ -106,8 +114,11 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedConfirmPrompt.mockResolvedValue(true);
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedCreateV3App).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
                 sourceDir: ['v3/test-component', 'v3/app-template'],
             }));
@@ -132,8 +143,11 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedConfirmPrompt.mockResolvedValue(true);
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedCreateV3App).not.toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: '',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
         });
         it('throws an error when app count exceeds maximum', async () => {
@@ -146,7 +160,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataMaxApps);
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('This project currently has the maximum number of apps: 1');
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('This project currently has the maximum number of apps: 1');
         });
         it('throws an error when components list is empty', async () => {
             const mockEmptyConfig = {
@@ -154,7 +168,7 @@ describe('lib/projects/add/v3AddComponent', () => {
                 parentComponents: [],
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockEmptyConfig);
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
         });
         it('throws an error when app meta file cannot be parsed', async () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
@@ -162,7 +176,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockImplementation(() => {
                 throw new Error('File read error');
             });
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('Unable to parse app file');
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('Unable to parse app file');
         });
         it('throws an error when cloning fails', async () => {
             const mockAppMeta = {
@@ -179,7 +193,57 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+        });
+        it('should track usage with multiple component types', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockSecondComponentTemplate = {
+                label: 'Test Card',
+                path: 'test-card',
+                type: 'card',
+                supportedAuthTypes: ['oauth'],
+                supportedDistributions: ['private'],
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate, mockSecondComponentTemplate],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module,card',
+            }, mockAccountId);
+        });
+        it('should track usage with empty type when no components are selected', async () => {
+            const mockProjectMetadataNoApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: {
+                        count: 1,
+                        maxCount: 1,
+                        hsMetaFiles: ['/path/to/app.meta.json'],
+                    },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: '',
+            }, mockAccountId);
         });
     });
 });

package/lib/projects/add/v3AddComponent.d.ts

@@ -5,4 +5,4 @@ export declare function v3AddComponent(args: {
     features?: string[];
     auth?: string;
     distribution?: string;
-}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;
+}, projectDir: string, projectConfig: ProjectConfig, accountId: number): Promise<void>;

package/lib/projects/add/v3AddComponent.js

@@ -12,7 +12,8 @@ import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { debugError } from '../../errorHandlers/index.js';
 import { uiLogger } from '../../ui/logger.js';
-export async function v3AddComponent(args, projectDir, projectConfig) {
+import { trackCommandUsage } from '../../usageTracking.js';
+export async function v3AddComponent(args, projectDir, projectConfig, accountId) {
     uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
     const config = await getConfigForPlatformVersion(projectConfig.platformVersion);
     const { components, parentComponents } = config;
@@ -47,6 +48,10 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
     }
     const componentTemplateChoices = calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, currentProjectMetadata);
     const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
+    const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.type);
+    await trackCommandUsage('project-add', {
+        type: componentTypes?.join(','),
+    }, accountId);
     try {
         const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
             return path.join(projectConfig.platformVersion, componentTemplate.path);

package/lib/projects/localDev/AppDevModeInterface.d.ts

@@ -11,6 +11,7 @@ declare class AppDevModeInterface {
     _appNode?: AppIRNode | null;
     marketplaceAppInstalls?: number;
     constructor(options: AppDevModeInterfaceConstructorOptions);
+    private getAppNodeFromProjectNodes;
     private get appNode();
     private get appData();
     private set appData(value);
@@ -21,7 +22,10 @@ declare class AppDevModeInterface {
     private autoInstallStaticAuthApp;
     private installAppOrOpenInstallUrl;
     private checkTestAccountAppInstallation;
-    private setUpLocalDevServerMessageListeners;
+    private onDevServerMessage;
+    private onChangeProjectNodes;
+    private setUpStateListeners;
+    private removeStateListeners;
     setup(args: any): Promise<void>;
     start(): Promise<void>;
     fileChange(filePath: string, event: string): Promise<void>;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -30,12 +30,13 @@ class AppDevModeInterface {
             process.exit(EXIT_CODES.ERROR);
         }
     }
+    getAppNodeFromProjectNodes(projectNodes) {
+        return Object.values(projectNodes).find(isAppIRNode) || null;
+    }
     // Assumes only one app per project
     get appNode() {
         if (this._appNode === undefined) {
-            this._appNode =
-                Object.values(this.localDevState.projectNodes).find(isAppIRNode) ||
-                    null;
+            this._appNode = this.getAppNodeFromProjectNodes(this.localDevState.projectNodes);
         }
         return this._appNode;
     }
@@ -175,12 +176,33 @@ class AppDevModeInterface {
         }
         return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
     }
-    setUpLocalDevServerMessageListeners() {
-        this.localDevState.addListener('devServerMessage', message => {
-            if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
-                this.checkTestAccountAppInstallation();
-            }
-        });
+    onDevServerMessage = (message) => {
+        if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
+            this.checkTestAccountAppInstallation();
+        }
+    };
+    onChangeProjectNodes = (nodes) => {
+        const newAppNode = this.getAppNodeFromProjectNodes(nodes);
+        const oldDistribution = this.appNode?.config.distribution;
+        const newDistribution = newAppNode?.config.distribution;
+        const oldAuthType = this.appNode?.config.auth.type;
+        const newAuthType = newAppNode?.config.auth.type;
+        if (newDistribution === APP_DISTRIBUTION_TYPES.MARKETPLACE &&
+            oldDistribution !== APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+            this.localDevState.addUploadWarning(lib.AppDevModeInterface.distributionChanged);
+        }
+        else if (newAuthType === APP_AUTH_TYPES.OAUTH &&
+            oldAuthType !== APP_AUTH_TYPES.OAUTH) {
+            this.localDevState.addUploadWarning(lib.AppDevModeInterface.authTypeChanged);
+        }
+    };
+    setUpStateListeners() {
+        this.localDevState.addListener('devServerMessage', this.onDevServerMessage);
+        this.localDevState.addListener('projectNodes', this.onChangeProjectNodes);
+    }
+    removeStateListeners() {
+        this.localDevState.removeListener('devServerMessage', this.onDevServerMessage);
+        this.localDevState.removeListener('projectNodes', this.onChangeProjectNodes);
     }
     // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
     // In the future, update UIE Dev Server to use LocalDevState
@@ -215,7 +237,7 @@ class AppDevModeInterface {
         catch (e) {
             logError(e);
         }
-        this.setUpLocalDevServerMessageListeners();
+        this.setUpStateListeners();
         return UIEDevModeInterface.setup(args);
     }
     async start() {
@@ -239,6 +261,7 @@ class AppDevModeInterface {
         if (!this.appNode) {
             return;
         }
+        this.removeStateListeners();
         return UIEDevModeInterface.cleanup();
     }
 }

package/lib/projects/structure.d.ts

@@ -1,5 +1,5 @@
 import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects.js';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { IntermediateRepresentationNode, IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { AppIRNode } from '../../types/ProjectComponents.js';
 export declare const CONFIG_FILES: {
     [k in ComponentTypes]: string;
@@ -15,4 +15,4 @@ export declare function getProjectComponentTypes(components: Array<Component>):
 export declare function getComponentUid(component?: Component | null): string | null;
 export declare function componentIsApp(component?: Component | null): component is Component<PublicAppComponentConfig | PrivateAppComponentConfig>;
 export declare function componentIsPublicApp(component?: Component | null): component is Component<PublicAppComponentConfig>;
-export declare function isAppIRNode(component: IntermediateRepresentationNodeLocalDev): component is AppIRNode;
+export declare function isAppIRNode(component: IntermediateRepresentationNodeLocalDev | IntermediateRepresentationNode): component is AppIRNode;

package/lib/projects/upload.d.ts

@@ -1,4 +1,5 @@
 import { FileResult } from 'tmp';
+import { IntermediateRepresentation } from '@hubspot/project-parsing-lib';
 import { ProjectConfig } from '../../types/Projects.js';
 type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number) => Promise<T>;
 type ProjectUploadResult<T> = {
@@ -20,5 +21,5 @@ type HandleProjectUploadArg<T> = {
 export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
 export declare function validateSourceDirectory(srcDir: string, projectConfig: ProjectConfig): void;
 export declare function validateNoHSMetaMismatch(srcDir: string, projectConfig: ProjectConfig): Promise<void>;
-export declare function handleTranslate(projectDir: string, projectConfig: ProjectConfig, accountId: number, skipValidation: boolean, profile: string | undefined): Promise<unknown>;
+export declare function handleTranslate(projectDir: string, projectConfig: ProjectConfig, accountId: number, skipValidation: boolean, profile: string | undefined): Promise<IntermediateRepresentation | undefined>;
 export {};

package/lib/projects/upload.js

@@ -133,4 +133,5 @@ export async function handleTranslate(projectDir, projectConfig, accountId, skip
         }
         throw e;
     }
+    return undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.7.29-experimental.0",
+    "version": "7.7.31-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",

package/types/Yargs.d.ts

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