@hubspot/cli 7.6.0-beta.11 → 7.6.0-beta.13

package/lib/projects/create/__tests__/v3.test.js

@@ -26,9 +26,9 @@ describe('lib/projects/create/v3', () => {
                 card: { count: 3, maxCount: 3, hsMetaFiles: [] },
             },
         };
-        it('returns enabled components when they meet all requirements', () => {
-            const choices = calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', mockProjectMetadataForChoices);
-            expect(choices).toHaveLength(3); // includes separator
+        it('returns enabled components when they meet all requirements', async () => {
+            const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', 123, mockProjectMetadataForChoices);
+            expect(choices).toHaveLength(4); // includes separator
             expect(choices[0]).toEqual({
                 name: 'Module Component',
                 value: mockComponents[0],
@@ -39,8 +39,8 @@ describe('lib/projects/create/v3', () => {
                 disabled: expect.stringContaining('maximum'),
             });
         });
-        it('disables components when auth type is not supported', () => {
-            const choices = calculateComponentTemplateChoices(mockComponents, 'privatekey', 'private', mockProjectMetadataForChoices);
+        it('disables components when auth type is not supported', async () => {
+            const choices = await calculateComponentTemplateChoices(mockComponents, 'privatekey', 'private', 123, mockProjectMetadataForChoices);
             // All components should be disabled, so they come after the separator
             expect(choices[1]).toEqual({
                 name: expect.stringContaining('Module Component'),
@@ -48,8 +48,8 @@ describe('lib/projects/create/v3', () => {
                 disabled: expect.stringContaining('privatekey'),
             });
         });
-        it('disables components when distribution is not supported', () => {
-            const choices = calculateComponentTemplateChoices(mockComponents, 'oauth', 'enterprise', mockProjectMetadataForChoices);
+        it('disables components when distribution is not supported', async () => {
+            const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'enterprise', 123, mockProjectMetadataForChoices);
             // All components should be disabled, so they come after the separator
             expect(choices[1]).toEqual({
                 name: expect.stringContaining('Module Component'),
@@ -57,7 +57,7 @@ describe('lib/projects/create/v3', () => {
                 disabled: expect.stringContaining('enterprise'),
             });
         });
-        it('handles components without auth type or distribution restrictions', () => {
+        it('handles components without auth type or distribution restrictions', async () => {
             const componentsWithoutRestrictions = [
                 {
                     label: 'Unrestricted Component',
@@ -65,7 +65,7 @@ describe('lib/projects/create/v3', () => {
                     type: 'module',
                 },
             ];
-            const choices = calculateComponentTemplateChoices(componentsWithoutRestrictions, 'oauth', 'private', {
+            const choices = await calculateComponentTemplateChoices(componentsWithoutRestrictions, 'oauth', 'private', 123, {
                 hsMetaFiles: [],
                 components: { module: { count: 0, maxCount: 5, hsMetaFiles: [] } },
             });
@@ -74,5 +74,93 @@ describe('lib/projects/create/v3', () => {
                 value: componentsWithoutRestrictions[0],
             });
         });
+        it('handles components with cliSelector field (metadata compatibility)', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const projectMetadataWithWorkflowAction = {
+                hsMetaFiles: [],
+                components: {
+                    'workflow-action': { count: 2, maxCount: 3, hsMetaFiles: [] },
+                },
+            };
+            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 213, projectMetadataWithWorkflowAction);
+            expect(choices).toHaveLength(1); // no disabled components
+            expect(choices[0]).toEqual({
+                name: 'Workflow Action Tool',
+                value: componentWithCliSelector[0],
+            });
+        });
+        it('disables component when project metadata count exceeds maximum', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const projectMetadataAtMaxWorkflowAction = {
+                hsMetaFiles: [],
+                components: {
+                    'workflow-action': { count: 3, maxCount: 3, hsMetaFiles: [] },
+                },
+            };
+            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, projectMetadataAtMaxWorkflowAction);
+            expect(choices).toHaveLength(3); // includes separators
+            expect(choices[1]).toEqual({
+                name: expect.stringContaining('Workflow Action Tool'),
+                value: componentWithCliSelector[0],
+                disabled: expect.stringContaining('maximum'),
+            });
+        });
+        it('handles undefined projectMetadata without throwing errors', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, undefined);
+            expect(choices).toHaveLength(1); // no disabled components
+            expect(choices[0]).toEqual({
+                name: 'Workflow Action Tool',
+                value: componentWithCliSelector[0],
+            });
+        });
+        it('handles projectMetadata with undefined components property (after fix)', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const projectMetadataWithoutComponents = {
+                hsMetaFiles: [],
+                components: undefined,
+            };
+            // This test verifies the null check fix works
+            // Currently this will fail because the fix checks for projectMetadata.components
+            await expect(async () => calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, 
+            // @ts-expect-error breaking stuff on purpose
+            projectMetadataWithoutComponents)).rejects.toThrow();
+        });
     });
 });

package/lib/projects/create/index.js

@@ -1,7 +1,7 @@
 import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
 import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
-import { useV3Api } from '../buildAndDeploy.js';
+import { useV3Api } from '../platformVersion.js';
 import { v3ComponentFlow } from './v3.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
 import { uiLogger } from '../../ui/logger.js';
@@ -12,7 +12,7 @@ export async function handleProjectCreationFlow(args) {
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
     const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
     if (useV3Api(platformVersion)) {
-        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution);
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
         const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
         return {
             authType,

package/lib/projects/create/legacy.js

@@ -3,7 +3,7 @@ import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { debugError } from '../../errorHandlers/index.js';
 import { uiLogger } from '../../ui/logger.js';
-import { useV3Api } from '../buildAndDeploy.js';
+import { useV3Api } from '../platformVersion.js';
 import { lib } from '../../../lang/en.js';
 const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';

package/lib/projects/create/v3.d.ts

@@ -6,7 +6,7 @@ export declare function createV3App(providedAuth: string | undefined, providedDi
     authType: string;
     distribution: string;
 }>;
-export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, projectMetadata?: ProjectMetadata): (ComponentTemplateChoice | Separator)[];
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, accountId: number, projectMetadata?: ProjectMetadata): Promise<(ComponentTemplateChoice | Separator)[]>;
 type V3ComponentInfo = {
     authType?: string;
     distribution?: string;
@@ -14,7 +14,7 @@ type V3ComponentInfo = {
     projectContents?: string;
     componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
 };
-export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined): Promise<V3ComponentInfo>;
+export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V3ComponentInfo>;
 export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
     selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
     platformVersion: string;

package/lib/projects/create/v3.js

@@ -1,13 +1,15 @@
 import { Separator } from '@inquirer/prompts';
-import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../constants.js';
+import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, FEATURES, } from '../../constants.js';
 import { commands, lib } from '../../../lang/en.js';
 import { listPrompt } from '../../prompts/promptUtils.js';
 import chalk from 'chalk';
-import { useV3Api } from '../buildAndDeploy.js';
+import { useV3Api } from '../platformVersion.js';
 import path from 'path';
 import { getConfigForPlatformVersion } from './legacy.js';
 import { logError } from '../../errorHandlers/index.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { hasFeature } from '../../hasFeature.js';
+import { AppEventsKey, PagesKey, } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 export async function createV3App(providedAuth, providedDistribution) {
     let authType;
     if (providedAuth &&
@@ -47,16 +49,26 @@ export async function createV3App(providedAuth, providedDistribution) {
         authType: authType,
     };
 }
-export function calculateComponentTemplateChoices(components, authType, distribution, projectMetadata) {
+const componentTypeToGateMap = {
+    [AppEventsKey]: FEATURES.APP_EVENTS,
+    [PagesKey]: FEATURES.APPS_HOME,
+};
+export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
     const enabledComponents = [];
     const disabledComponents = [];
-    components.forEach(template => {
+    for (const template of components) {
         const { supportedAuthTypes, supportedDistributions } = template;
         const disabledReasons = [];
         if (projectMetadata) {
-            const { count, maxCount } = projectMetadata.components[template.type];
-            if (count >= maxCount) {
-                disabledReasons.push(commands.project.add.error.maxExceeded(maxCount));
+            const componentMetadata = projectMetadata.components[template.type];
+            if (!componentMetadata) {
+                disabledReasons.push(commands.project.add.error.invalidComponentType(template.type));
+            }
+            else {
+                const { count, maxCount } = componentMetadata;
+                if (count >= maxCount) {
+                    disabledReasons.push(commands.project.add.error.maxExceeded(maxCount));
+                }
             }
         }
         if (Array.isArray(supportedAuthTypes) &&
@@ -69,9 +81,15 @@ export function calculateComponentTemplateChoices(components, authType, distribu
             !supportedDistributions.includes(distribution)) {
             disabledReasons.push(commands.project.add.error.distributionNotAllowed(distribution));
         }
+        if (componentTypeToGateMap[template.type]) {
+            const isUngated = await hasFeature(accountId, componentTypeToGateMap[template.type]);
+            if (!isUngated) {
+                disabledReasons.push(commands.project.add.error.portalDoesNotHaveAccessToThisFeature(accountId));
+            }
+        }
         if (disabledReasons.length > 0) {
             disabledComponents.push({
-                name: `[${chalk.yellow('DISABLED')}] ${template.label}`,
+                name: `[${chalk.yellow('DISABLED')}] ${template.label} -`,
                 value: template,
                 disabled: disabledReasons.join(' '),
             });
@@ -82,12 +100,17 @@ export function calculateComponentTemplateChoices(components, authType, distribu
                 value: template,
             });
         }
-    });
+    }
     return disabledComponents.length
-        ? [...enabledComponents, new Separator(), ...disabledComponents]
+        ? [
+            ...enabledComponents,
+            new Separator(),
+            ...disabledComponents,
+            new Separator(),
+        ]
         : [...enabledComponents];
 }
-export async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution) {
+export async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
     let repoConfig = undefined;
     let authType;
     let distribution;
@@ -113,7 +136,7 @@ export async function v3ComponentFlow(platformVersion, projectBase, providedAuth
         authType = selectedAuthType;
         distribution = selectedDistribution;
     }
-    const componentTemplateChoices = calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution);
+    const componentTemplateChoices = await calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution, accountId);
     return {
         componentTemplateChoices,
         authType,

package/lib/projects/deploy.d.ts

@@ -0,0 +1,13 @@
+import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
+export declare function validateBuildIdForDeploy(buildId: number, deployedBuildId: number | undefined, latestBuildId: number, projectName: string | undefined, accountId: number): boolean | string;
+export declare function logDeployErrors(errorData: {
+    message: string;
+    errors: Array<{
+        message: string;
+        subCategory: string;
+        context: {
+            COMPONENT_NAME: string;
+        };
+    }>;
+}): void;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, useV3Api: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -0,0 +1,63 @@
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { PROJECT_ERROR_TYPES } from '../constants.js';
+import { deployProject } from '@hubspot/local-dev-lib/api/projects';
+import { pollDeployStatus } from './pollProjectBuildAndDeploy.js';
+export function validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId) {
+    if (Number(buildId) > latestBuildId) {
+        return commands.project.deploy.errors.buildIdDoesNotExist(accountId, buildId, projectName);
+    }
+    if (Number(buildId) === deployedBuildId) {
+        return commands.project.deploy.errors.buildAlreadyDeployed(accountId, buildId, projectName);
+    }
+    return true;
+}
+export function logDeployErrors(errorData) {
+    uiLogger.error(errorData.message);
+    errorData.errors.forEach(err => {
+        // This is how the pre-deploy check manifests itself in < 2025.2 projects
+        if (err.subCategory === PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS) {
+            uiLogger.log(commands.project.deploy.errors.deployContainsRemovals(err.context.COMPONENT_NAME));
+        }
+        else {
+            uiLogger.log(err.message);
+        }
+    });
+}
+function handleBlockedDeploy(deployResp) {
+    const deployCanBeForced = deployResp.issues.every(issue => issue.blockingMessages.every(message => message.isWarning));
+    uiLogger.log('');
+    if (deployCanBeForced) {
+        uiLogger.warn(commands.project.deploy.errors.deployWarningsHeader);
+        uiLogger.log('');
+    }
+    else {
+        uiLogger.error(commands.project.deploy.errors.deployBlockedHeader);
+        uiLogger.log('');
+    }
+    deployResp.issues.forEach(issue => {
+        if (issue.blockingMessages.length > 0) {
+            issue.blockingMessages.forEach(message => {
+                uiLogger.log(commands.project.deploy.errors.deployIssueComponentWarning(issue.uid, issue.componentTypeName, message.message));
+            });
+        }
+        else {
+            uiLogger.log(commands.project.deploy.errors.deployIssueComponentGeneric(issue.uid, issue.componentTypeName));
+        }
+        uiLogger.log('');
+    });
+}
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force) {
+    const { data: deployResp } = await deployProject(targetAccountId, projectName, buildId, useV3Api, force);
+    if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
+        if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {
+            handleBlockedDeploy(deployResp);
+        }
+        else {
+            uiLogger.error(commands.project.deploy.errors.deploy);
+        }
+        return;
+    }
+    const deployResult = await pollDeployStatus(targetAccountId, projectName, Number(deployResp.id), buildId);
+    return deployResult;
+}

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

@@ -11,17 +11,19 @@ declare class AppDevModeInterface {
     _appNode?: AppIRNode | null;
     marketplaceAppInstalls?: number;
     constructor(options: AppDevModeInterfaceConstructorOptions);
+    private getAppNodeFromProjectNodes;
     private get appNode();
     private get appData();
     private set appData(value);
-    private isAutomaticallyInstallable;
     private getAppInstallUrl;
     private fetchAppData;
     private checkMarketplaceAppInstalls;
-    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

@@ -1,19 +1,21 @@
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts,
+// installStaticAuthAppOnTestAccount,
+ } from '@hubspot/local-dev-lib/api/appsDev';
 import { DevModeUnifiedInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
 import { requestPorts } from '@hubspot/local-dev-lib/portManager';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { isAppIRNode } from '../../projects/structure.js';
 import { uiLine } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
-import { installAppAutoPrompt, installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
+import { 
+// installAppAutoPrompt,
+installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
 import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { lib } from '../../../lang/en.js';
 import { uiLogger } from '../../ui/logger.js';
 import { getOauthAppInstallUrl, getStaticAuthAppInstallUrl, } from '../../app/urls.js';
-import { isDeveloperTestAccount, isSandbox } from '../../accountTypes.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
 class AppDevModeInterface {
     localDevState;
@@ -30,12 +32,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;
     }
@@ -51,19 +54,26 @@ class AppDevModeInterface {
         }
         this.localDevState.setAppDataForUid(this.appNode.uid, appData);
     }
-    isAutomaticallyInstallable() {
-        const targetTestingAccount = getAccountConfig(this.localDevState.targetTestingAccountId);
-        if (!targetTestingAccount) {
-            return false;
-        }
-        const isTestAccount = isDeveloperTestAccount(targetTestingAccount) ||
-            isSandbox(targetTestingAccount);
-        const hasCorrectParent = targetTestingAccount.parentAccountId ===
-            this.localDevState.targetProjectAccountId;
-        return (isTestAccount &&
-            hasCorrectParent &&
-            this.appNode?.config.auth.type === APP_AUTH_TYPES.STATIC);
-    }
+    // @TODO: Restore test account auto install functionality
+    // private isAutomaticallyInstallable(): boolean {
+    //   const targetTestingAccount = getAccountConfig(
+    //     this.localDevState.targetTestingAccountId
+    //   );
+    //   if (!targetTestingAccount) {
+    //     return false;
+    //   }
+    //   const isTestAccount =
+    //     isDeveloperTestAccount(targetTestingAccount) ||
+    //     isSandbox(targetTestingAccount);
+    //   const hasCorrectParent =
+    //     targetTestingAccount.parentAccountId ===
+    //     this.localDevState.targetProjectAccountId;
+    //   return (
+    //     isTestAccount &&
+    //     hasCorrectParent &&
+    //     this.appNode?.config.auth.type === APP_AUTH_TYPES.STATIC
+    //   );
+    // }
     async getAppInstallUrl() {
         if (this.appNode?.config.auth.type === APP_AUTH_TYPES.OAUTH) {
             return getOauthAppInstallUrl({
@@ -90,7 +100,18 @@ class AppDevModeInterface {
         SpinniesManager.add('fetchAppData', {
             text: lib.AppDevModeInterface.fetchAppData.checking(this.appNode?.config.name || ''),
         });
-        const { data: { results: portalApps }, } = await fetchPublicAppsForPortal(this.localDevState.targetProjectAccountId);
+        let portalApps = [];
+        try {
+            const { data: { results }, } = await fetchPublicAppsForPortal(this.localDevState.targetProjectAccountId);
+            portalApps = results;
+        }
+        catch (e) {
+            SpinniesManager.fail('fetchAppData', {
+                text: lib.AppDevModeInterface.fetchAppData.error,
+            });
+            logError(e);
+            process.exit(EXIT_CODES.ERROR);
+        }
         const appData = portalApps.find(({ sourceId }) => sourceId === this.appNode?.uid);
         if (!appData) {
             return;
@@ -122,27 +143,47 @@ class AppDevModeInterface {
         }
         this.localDevState.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
     }
-    async autoInstallStaticAuthApp() {
-        const shouldInstall = await installAppAutoPrompt();
-        if (!shouldInstall) {
-            uiLogger.log(lib.AppDevModeInterface.autoInstallDeclined);
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        await installStaticAuthAppOnTestAccount(this.appData.id, this.localDevState.targetTestingAccountId, this.appData.scopeGroupIds);
-    }
+    // @TODO: Restore test account auto install functionality
+    // private async autoInstallStaticAuthApp(): Promise<void> {
+    //   const shouldInstall = await installAppAutoPrompt();
+    //   if (!shouldInstall) {
+    //     uiLogger.log(lib.AppDevModeInterface.autoInstallDeclined);
+    //     process.exit(EXIT_CODES.SUCCESS);
+    //   }
+    //   await installStaticAuthAppOnTestAccount(
+    //     this.appData!.id,
+    //     this.localDevState.targetTestingAccountId,
+    //     this.appData!.scopeGroupIds
+    //   );
+    // }
     async installAppOrOpenInstallUrl(isReinstall) {
-        if (this.isAutomaticallyInstallable()) {
-            try {
-                await this.autoInstallStaticAuthApp();
-                uiLogger.success(lib.AppDevModeInterface.autoInstallSuccess(this.appData.name, this.localDevState.targetTestingAccountId));
-                return;
-            }
-            catch (e) {
-                uiLogger.error(lib.AppDevModeInterface.autoInstallError(this.appData.name, this.localDevState.targetTestingAccountId));
-            }
-        }
+        // @TODO: Restore test account auto install functionality
+        // if (this.isAutomaticallyInstallable()) {
+        //   try {
+        //     await this.autoInstallStaticAuthApp();
+        //     uiLogger.success(
+        //       lib.AppDevModeInterface.autoInstallSuccess(
+        //         this.appData!.name,
+        //         this.localDevState.targetTestingAccountId
+        //       )
+        //     );
+        //     return;
+        //   } catch (e) {
+        //     uiLogger.error(
+        //       lib.AppDevModeInterface.autoInstallError(
+        //         this.appData!.name,
+        //         this.localDevState.targetTestingAccountId
+        //       )
+        //     );
+        //   }
+        // }
         const installUrl = await this.getAppInstallUrl();
-        await installAppBrowserPrompt(installUrl, isReinstall);
+        await installAppBrowserPrompt(installUrl, isReinstall, {
+            testingAccountId: this.localDevState.targetTestingAccountId,
+            projectAccountId: this.localDevState.targetProjectAccountId,
+            projectName: this.localDevState.projectConfig.name,
+            appUid: this.appNode.uid,
+        });
     }
     async checkTestAccountAppInstallation() {
         if (!this.appNode || !this.appData) {
@@ -164,12 +205,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
@@ -204,7 +266,7 @@ class AppDevModeInterface {
         catch (e) {
             logError(e);
         }
-        this.setUpLocalDevServerMessageListeners();
+        this.setUpStateListeners();
         return UIEDevModeInterface.setup(args);
     }
     async start() {
@@ -228,6 +290,7 @@ class AppDevModeInterface {
         if (!this.appNode) {
             return;
         }
+        this.removeStateListeners();
         return UIEDevModeInterface.cleanup();
     }
 }

package/lib/projects/localDev/DevServerManagerV2.js

@@ -34,6 +34,7 @@ class DevServerManagerV2 {
                 // @TODO: In the future, update UIE Dev Server to use LocalDevState
                 await serverInterface.setup({
                     components: this.localDevState.projectNodes,
+                    profileData: this.localDevState.projectProfileData,
                     logger,
                     urls: {
                         api: getHubSpotApiOrigin(env),

package/lib/projects/localDev/LocalDevProcess.js

@@ -8,7 +8,7 @@ import DevServerManagerV2 from './DevServerManagerV2.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { getProjectConfig } from '../config.js';
 import { handleProjectUpload } from '../upload.js';
-import { pollProjectBuildAndDeploy } from '../buildAndDeploy.js';
+import { pollProjectBuildAndDeploy } from '../pollProjectBuildAndDeploy.js';
 import { getLocalDevUiUrl } from '../urls.js';
 import { CONFIG_LOCAL_STATE_FLAGS } from '../../constants.js';
 import { isAutoOpenBrowserEnabled } from '../../configOptions.js';
@@ -101,11 +101,13 @@ class LocalDevProcess {
         const intermediateRepresentation = await this.getIntermediateRepresentation(this.state.projectNodesAtLastUpload);
         this.state.projectNodes =
             intermediateRepresentation.intermediateNodesIndexedByUid;
+        this.state.projectProfileData = intermediateRepresentation.profileData;
     }
     async updateProjectNodesAfterUpload() {
         const intermediateRepresentation = await this.getIntermediateRepresentation();
         this.state.projectNodes =
             intermediateRepresentation.intermediateNodesIndexedByUid;
+        this.state.projectProfileData = intermediateRepresentation.profileData;
         this.state.projectNodesAtLastUpload =
             intermediateRepresentation.intermediateNodesIndexedByUid;
     }