@hubspot/cli 8.2.0-experimental.1 → 8.2.0-experimental.2

package/lib/projects/installApp.js

@@ -0,0 +1,278 @@
+import path from 'path';
+import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { fetchAppMetadataBySourceId, fetchPublicAppMetadata, installStaticAuthAppOnCurrentAccount, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { getAllConfigAccounts, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { translateForLocalDev } from '@hubspot/project-parsing-lib/translate';
+import { commands } from '../../lang/en.js';
+import { isAppDeveloperAccount } from '../accountTypes.js';
+import { ApiErrorContext, debugError, logError, } from '../errorHandlers/index.js';
+import { confirmPrompt, listPrompt } from '../prompts/promptUtils.js';
+import { projectProfilePrompt } from '../prompts/projectProfilePrompt.js';
+import { loadProfile } from './projectProfiles.js';
+import { handleProjectUpload } from './upload.js';
+import { pollProjectBuildAndDeploy } from './pollProjectBuildAndDeploy.js';
+import { getAppNodeFromProjectNodes, canUseStaticAuthTestAccountInstall, isPrivateApp, isStaticAuthApp, } from '../app/install.js';
+import { uiLogger } from '../ui/logger.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { getStaticAuthAppInstallUrl } from '../app/urls.js';
+export async function resolveProjectAccountId(derivedAccountId, projectConfig, projectDir, profileOption, useEnvOption) {
+    try {
+        const profileName = await projectProfilePrompt(projectDir, projectConfig, profileOption, useEnvOption);
+        if (profileName) {
+            const profile = loadProfile(projectConfig, projectDir, profileName);
+            uiLogger.log(commands.project.installApp.profileMessage(profileName, profile.accountId));
+            uiLogger.log('');
+            return { accountId: profile.accountId, profileName };
+        }
+        return { accountId: derivedAccountId };
+    }
+    catch (error) {
+        logError(error);
+        return null;
+    }
+}
+export async function loadInstallableAppNode(projectConfig, projectDir, accountId) {
+    let appNode;
+    try {
+        const { intermediateNodesIndexedByUid } = await translateForLocalDev({
+            projectSourceDir: path.join(projectDir, projectConfig.srcDir),
+            platformVersion: projectConfig.platformVersion,
+            accountId,
+        }, { skipValidation: true });
+        appNode = getAppNodeFromProjectNodes(intermediateNodesIndexedByUid);
+    }
+    catch (error) {
+        debugError(error);
+        uiLogger.error(commands.project.installApp.errors.failedToParseProject);
+        return null;
+    }
+    if (!appNode) {
+        uiLogger.error(commands.project.installApp.errors.noAppInProject);
+        return null;
+    }
+    if (!isStaticAuthApp(appNode)) {
+        uiLogger.error(commands.project.installApp.errors.unsupportedAuthType(appNode.config.auth.type));
+        return null;
+    }
+    if (!isPrivateApp(appNode)) {
+        uiLogger.error(commands.project.installApp.errors.unsupportedDistribution(appNode.config.distribution || 'unknown'));
+        return null;
+    }
+    return appNode;
+}
+// App developer accounts can't host app installs.
+export async function resolveValidInstallAccount(targetAccountId, force, formatOutputAsJson) {
+    const accountConfig = getConfigAccountIfExists(targetAccountId);
+    if (!accountConfig || !isAppDeveloperAccount(accountConfig)) {
+        return targetAccountId;
+    }
+    const validAccounts = getAllConfigAccounts().filter(account => !isAppDeveloperAccount(account));
+    if (force || formatOutputAsJson || validAccounts.length === 0) {
+        uiLogger.error(commands.project.installApp.errors.invalidAppDeveloperAccount(targetAccountId));
+        return null;
+    }
+    uiLogger.log(commands.project.installApp.appDeveloperAccountNotice(targetAccountId));
+    return listPrompt(commands.project.installApp.selectInstallAccountPrompt, {
+        choices: validAccounts.map(account => ({
+            name: uiAccountDescription(account.accountId, false),
+            value: account.accountId,
+        })),
+    });
+}
+async function offerUploadAndDeploy(options) {
+    const { accountId, projectConfig, projectDir, profile, force } = options;
+    if (!force) {
+        if (options.formatOutputAsJson) {
+            return false;
+        }
+        const shouldUpload = await confirmPrompt(commands.project.installApp.uploadAndDeployPrompt(accountId));
+        if (!shouldUpload) {
+            return false;
+        }
+    }
+    try {
+        const { result, uploadError } = await handleProjectUpload({
+            accountId,
+            projectConfig,
+            projectDir,
+            callbackFunc: pollProjectBuildAndDeploy,
+            isUploadCommand: true,
+            sendIR: true,
+            forceCreate: true,
+            profile,
+        });
+        if (uploadError) {
+            logError(uploadError, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return false;
+        }
+        return Boolean(result && result.succeeded);
+    }
+    catch (error) {
+        logError(error, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+        return false;
+    }
+}
+export async function resolveProjectId(options) {
+    const { accountId, projectConfig } = options;
+    try {
+        const response = await fetchProject(accountId, projectConfig.name);
+        return response.data.id;
+    }
+    catch (error) {
+        if (!isHubSpotHttpError(error) || error.status !== 404) {
+            logError(error, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+        const uploaded = await offerUploadAndDeploy(options);
+        if (!uploaded) {
+            uiLogger.error(commands.project.installApp.errors.projectNotFound(accountId, projectConfig.name));
+            return null;
+        }
+        try {
+            const response = await fetchProject(accountId, projectConfig.name);
+            return response.data.id;
+        }
+        catch (retryError) {
+            logError(retryError, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+    }
+}
+export async function resolveAppMetadata(options) {
+    const { appId, projectId, appUid, appName, accountId, projectConfig } = options;
+    const fetchMetadata = (forceSourceIdLookup = false) => appId && !forceSourceIdLookup
+        ? fetchPublicAppMetadata(appId, accountId)
+        : fetchAppMetadataBySourceId(projectId, appUid, accountId);
+    try {
+        const { data } = await fetchMetadata();
+        return {
+            appId: appId ?? data.id,
+            scopeGroupIds: data.scopeGroupIds,
+            ownerPortalId: data.portalId,
+        };
+    }
+    catch (error) {
+        if (!isHubSpotHttpError(error) || error.status !== 404) {
+            logError(error, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+        const uploaded = await offerUploadAndDeploy(options);
+        if (!uploaded) {
+            uiLogger.error(commands.project.installApp.errors.appNotDeployed(appName, accountId));
+            return null;
+        }
+        try {
+            const { data } = await fetchMetadata(true);
+            return {
+                appId: data.id,
+                scopeGroupIds: data.scopeGroupIds,
+                ownerPortalId: data.portalId,
+            };
+        }
+        catch (retryError) {
+            logError(retryError, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+    }
+}
+export async function fetchProjectAppInstallationData(targetAccountId, projectId, appNode, projectConfig) {
+    try {
+        const response = await fetchAppInstallationData(targetAccountId, projectId, appNode.uid, appNode.config.auth.requiredScopes, appNode.config.auth.optionalScopes);
+        return {
+            appId: response.data.appId,
+            isInstalledWithScopeGroups: response.data.isInstalledWithScopeGroups,
+            previouslyAuthorizedScopeGroups: response.data.previouslyAuthorizedScopeGroups,
+        };
+    }
+    catch (error) {
+        if (isHubSpotHttpError(error) && error.status === 404) {
+            return {
+                isInstalledWithScopeGroups: false,
+                previouslyAuthorizedScopeGroups: [],
+            };
+        }
+        logError(error, new ApiErrorContext({
+            accountId: targetAccountId,
+            projectName: projectConfig.name,
+        }));
+        return null;
+    }
+}
+export async function confirmInstallAppAction({ appName, targetAccountId, force, needsReinstall, }) {
+    if (force) {
+        return true;
+    }
+    if (needsReinstall) {
+        uiLogger.log(commands.project.installApp.outdatedScopes(appName, targetAccountId));
+        return confirmPrompt(commands.project.installApp.reinstallPrompt);
+    }
+    return confirmPrompt(commands.project.installApp.installPrompt(appName, targetAccountId));
+}
+export async function installStaticAuthAppForAccount({ appId, appNode, appName, targetAccountId, targetAccountConfig, projectId, projectName, scopeGroupIds, ownerPortalId, installationState, formatOutputAsJson, }) {
+    const installingIntoOwnerAccount = ownerPortalId === targetAccountId;
+    const useTestAccountInstall = !installingIntoOwnerAccount &&
+        canUseStaticAuthTestAccountInstall({
+            accountConfig: targetAccountConfig,
+            appNode,
+        });
+    if (!installingIntoOwnerAccount && !useTestAccountInstall) {
+        const installUrl = getStaticAuthAppInstallUrl({
+            targetAccountId,
+            env: (targetAccountConfig?.env || 'prod'),
+            appId,
+        });
+        if (formatOutputAsJson) {
+            uiLogger.json({
+                appId,
+                appUid: appNode.uid,
+                accountId: targetAccountId,
+                projectId,
+                installationState,
+                installed: false,
+                reinstalled: false,
+                installUrl,
+                error: commands.project.installApp.jsonErrors.automaticInstallUnavailable,
+            });
+        }
+        else {
+            uiLogger.error(commands.project.installApp.errors.automaticInstallUnavailable(appName, targetAccountId));
+            uiLogger.log(commands.project.installApp.installFromBrowser(installUrl));
+        }
+        return false;
+    }
+    try {
+        if (useTestAccountInstall) {
+            await installStaticAuthAppOnTestAccount(appId, targetAccountId, scopeGroupIds);
+        }
+        else {
+            await installStaticAuthAppOnCurrentAccount(appId, targetAccountId, scopeGroupIds);
+        }
+        return true;
+    }
+    catch (error) {
+        if (formatOutputAsJson) {
+            uiLogger.json({
+                appId,
+                appUid: appNode.uid,
+                accountId: targetAccountId,
+                projectId,
+                installationState,
+                installed: false,
+                reinstalled: false,
+                error: isHubSpotHttpError(error)
+                    ? error.message
+                    : commands.project.installApp.jsonErrors.installFailed(appName, targetAccountId),
+            });
+        }
+        else {
+            uiLogger.error(commands.project.installApp.errors.installFailed(appName, targetAccountId));
+            logError(error, new ApiErrorContext({
+                accountId: targetAccountId,
+                projectName,
+            }));
+        }
+        return false;
+    }
+}

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

@@ -12,12 +12,9 @@ declare class AppDevModeInterface {
     marketplaceAppInstalls?: number;
     private appInstallResolve?;
     constructor(options: AppDevModeInterfaceConstructorOptions);
-    private getAppNodeFromProjectNodes;
     private get appNode();
     private get appData();
     private set appData(value);
-    private isStaticAuthApp;
-    private isOAuthApp;
     private isAutomaticallyInstallable;
     private getAppInstallUrl;
     private fetchAppData;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -3,7 +3,6 @@ import { fetchAppMetadataBySourceId, fetchPublicAppProductionInstallCounts, inst
 import { getConfigAccountById } 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 { isPromptExitError } from '../../errors/PromptExitError.js';
@@ -12,9 +11,9 @@ 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';
 import { isServerRunningAtUrl } from '../../http.js';
+import { canUseStaticAuthTestAccountInstall, getAppInstallationState, getAppNodeFromProjectNodes, isMarketplaceApp, isOAuthApp, } from '../../app/install.js';
 class AppDevModeInterface {
     localDevState;
     localDevLogger;
@@ -31,13 +30,10 @@ class AppDevModeInterface {
             throw new Error(lib.LocalDevManager.failedToInitialize);
         }
     }
-    getAppNodeFromProjectNodes(projectNodes) {
-        return Object.values(projectNodes).find(isAppIRNode) || null;
-    }
     // Assumes only one app per project
     get appNode() {
         if (this._appNode === undefined) {
-            this._appNode = this.getAppNodeFromProjectNodes(this.localDevState.projectNodes);
+            this._appNode = getAppNodeFromProjectNodes(this.localDevState.projectNodes);
         }
         return this._appNode;
     }
@@ -61,25 +57,16 @@ class AppDevModeInterface {
         }
         this.localDevState.setAppDataForUid(this.appNode.uid, appData);
     }
-    isStaticAuthApp() {
-        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.STATIC);
-    }
-    isOAuthApp() {
-        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH);
-    }
     isAutomaticallyInstallable() {
         const targetTestingAccount = getConfigAccountById(this.localDevState.targetTestingAccountId);
-        if (!targetTestingAccount) {
-            return false;
-        }
-        const isTestAccount = isDeveloperTestAccount(targetTestingAccount) ||
-            isSandbox(targetTestingAccount);
-        const hasCorrectParent = targetTestingAccount.parentAccountId ===
-            this.localDevState.targetProjectAccountId;
-        return isTestAccount && hasCorrectParent && this.isStaticAuthApp();
+        return canUseStaticAuthTestAccountInstall({
+            accountConfig: targetTestingAccount,
+            appNode: this.appNode,
+            parentAccountId: this.localDevState.targetProjectAccountId,
+        });
     }
     async getAppInstallUrl() {
-        if (this.appNode && this.isOAuthApp()) {
+        if (this.appNode && isOAuthApp(this.appNode)) {
             return getOauthAppInstallUrl({
                 targetAccountId: this.localDevState.targetTestingAccountId,
                 env: this.localDevState.env,
@@ -195,26 +182,17 @@ class AppDevModeInterface {
             return {};
         }
         const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await fetchAppInstallationData(this.localDevState.targetTestingAccountId, this.localDevState.projectId, this.appNode.uid, this.appNode.config.auth.requiredScopes, this.appNode.config.auth.optionalScopes);
-        const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
-        if (isInstalledWithScopeGroups) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED,
-            };
-        }
-        else if (isReinstall) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
-            };
-        }
-        else {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
-            };
-        }
-        return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
+        const installationState = getAppInstallationState(isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups);
+        const isReinstall = installationState ===
+            APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES;
+        this.appData = {
+            ...this.appData,
+            installationState,
+        };
+        return {
+            needsInstall: installationState !== APP_INSTALLATION_STATES.INSTALLED,
+            isReinstall,
+        };
     }
     async validateOauthAppRedirectUrl() {
         const redirectUrl = this.appNode?.config.auth.redirectUrls[0];
@@ -263,7 +241,7 @@ class AppDevModeInterface {
         }
     };
     onChangeProjectNodes = (nodes) => {
-        const newAppNode = this.getAppNodeFromProjectNodes(nodes);
+        const newAppNode = getAppNodeFromProjectNodes(nodes);
         const oldDistribution = this.appNode?.config.distribution;
         const newDistribution = newAppNode?.config.distribution;
         const oldAuthType = this.appNode?.config.auth.type;
@@ -287,7 +265,7 @@ class AppDevModeInterface {
         }
         try {
             await this.fetchAppData();
-            if (this.appNode.config.distribution === APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+            if (isMarketplaceApp(this.appNode)) {
                 await this.checkMarketplaceAppInstalls();
             }
             const { needsInstall, isReinstall } = await this.checkTestAccountAppInstallation();
@@ -298,7 +276,7 @@ class AppDevModeInterface {
                         failColor: 'white',
                     });
                 }
-                if (this.isOAuthApp()) {
+                if (isOAuthApp(this.appNode)) {
                     await this.validateOauthAppRedirectUrl();
                 }
                 this.localDevState.addListener('devServerMessage', this.onDevServerMessage);

package/lib/projects/localDev/helpers/project.d.ts

@@ -1,7 +1,7 @@
 import { type IntermediateRepresentationNode, type IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Project } from '@hubspot/local-dev-lib/types/Project';
-import { ProjectConfig } from '../../../../types/Projects.js';
+import { LocallyChangedComponents, ProjectConfig } from '../../../../types/Projects.js';
 import { ExitFunction } from '../../../../types/Yargs.js';
 export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean, exit: ExitFunction): Promise<Project>;
 export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, exit: ExitFunction, sendIR?: boolean, profile?: string): Promise<Build>;
@@ -11,7 +11,8 @@ export declare function compareLocalProjectToDeployed(projectConfig: ProjectConf
 export declare function getDeployedProjectNodes(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, profile?: string): Promise<{
     [key: string]: IntermediateRepresentationNode;
 }>;
-export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
+export declare function hasLocalComponentChanges(changed: LocallyChangedComponents): boolean;
+export declare function getLocallyChangedComponents(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
-}, profile?: string): Promise<boolean>;
+}, profile?: string): Promise<LocallyChangedComponents>;
 export declare function checkAndInstallDependencies(): Promise<void>;

package/lib/projects/localDev/helpers/project.js

@@ -1,25 +1,24 @@
 import fs from 'fs-extra';
 import os from 'os';
 import path from 'path';
-import { createProject } from '@hubspot/local-dev-lib/api/projects';
-import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
+import { createProject, downloadProject, } from '@hubspot/local-dev-lib/api/projects';
 import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
 import { sanitizeFileName } from '@hubspot/local-dev-lib/path';
 import { isDeepEqual } from '@hubspot/local-dev-lib/isDeepEqual';
 import { translate, } from '@hubspot/project-parsing-lib/translate';
+import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
+import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
 import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
-import { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, PROJECT_CONFIG_FILE, } from '../../../constants.js';
+import { PROJECT_BUILD_TEXT, PROJECT_CONFIG_FILE, PROJECT_DEPLOY_TEXT, PROJECT_ERROR_TYPES, } from '../../../constants.js';
 import { lib } from '../../../../lang/en.js';
 import { uiLogger } from '../../../ui/logger.js';
-import { uiLine } from '../../../ui/index.js';
+import { uiAccountDescription, uiLine } from '../../../ui/index.js';
 import { confirmPrompt } from '../../../prompts/promptUtils.js';
-import { uiAccountDescription } from '../../../ui/index.js';
 import SpinniesManager from '../../../ui/SpinniesManager.js';
 import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { handleProjectUpload } from '../../upload.js';
 import { pollProjectBuildAndDeploy } from '../../pollProjectBuildAndDeploy.js';
-import { debugError, logError } from '../../../errorHandlers/index.js';
-import { ApiErrorContext } from '../../../errorHandlers/index.js';
+import { ApiErrorContext, debugError, logError, } from '../../../errorHandlers/index.js';
 import { getProjectPackageJsonLocations, hasMissingPackages, installPackages, } from '../../../dependencyManagement.js';
 // Prompt the user to create a new project if one doesn't exist on their target account
 export async function createNewProjectForLocalDev(projectConfig, targetAccountId, shouldCreateWithoutConfirmation, hasPublicApps, exit) {
@@ -133,8 +132,8 @@ export async function compareLocalProjectToDeployed(projectConfig, accountId, de
     SpinniesManager.add('compareLocalProjectToDeployed', {
         text: lib.localDevHelpers.project.compareLocalProjectToDeployed.checking,
     });
-    const isUpToDate = await isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile);
-    if (isUpToDate) {
+    const changedComponents = await getLocallyChangedComponents(projectConfig, accountId, deployedBuildId, localProjectNodes, profile);
+    if (!hasLocalComponentChanges(changedComponents)) {
         SpinniesManager.succeed('compareLocalProjectToDeployed', {
             text: lib.localDevHelpers.project.compareLocalProjectToDeployed.upToDate,
         });
@@ -145,6 +144,8 @@ export async function compareLocalProjectToDeployed(projectConfig, accountId, de
                 .notUpToDate,
         });
         uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed.changedFiles(changedComponents));
+        uiLogger.log('');
         uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed.notUpToDateExplanation(profile));
         return exit(EXIT_CODES.SUCCESS);
     }
@@ -185,14 +186,47 @@ export async function getDeployedProjectNodes(projectConfig, accountId, deployed
         }
     }
 }
-export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+function filterAutoGeneratedNodes(nodes) {
+    return Object.fromEntries(Object.entries(nodes).filter(([, node]) => !AUTO_GENERATED_COMPONENT_TYPES.includes(mapToUserFacingType(node.componentType))));
+}
+export function hasLocalComponentChanges(changed) {
+    return (changed.added.length > 0 ||
+        changed.updated.length > 0 ||
+        changed.removed.length > 0);
+}
+export async function getLocallyChangedComponents(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+    const result = {
+        added: [],
+        updated: [],
+        removed: [],
+    };
     try {
         const deployedProjectNodes = await getDeployedProjectNodes(projectConfig, accountId, deployedBuildId, profile);
-        return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
+        const filteredLocal = filterAutoGeneratedNodes(localProjectNodes);
+        const filteredDeployed = filterAutoGeneratedNodes(deployedProjectNodes);
+        const allUids = new Set([
+            ...Object.keys(filteredLocal),
+            ...Object.keys(filteredDeployed),
+        ]);
+        for (const uid of allUids) {
+            const local = filteredLocal[uid];
+            const deployed = filteredDeployed[uid];
+            if (!local) {
+                result.removed.push(path.join(projectConfig.srcDir, deployed.metaFilePath));
+            }
+            else if (!deployed) {
+                result.added.push(path.join(projectConfig.srcDir, local.metaFilePath));
+            }
+            else if (!isDeepEqual(local, deployed, ['localDev', 'componentDeps'])) {
+                result.updated.push(path.join(projectConfig.srcDir, local.metaFilePath));
+            }
+        }
+        return result;
     }
     catch (err) {
         debugError(err);
-        return false;
+        uiLogger.warn(lib.localDevHelpers.project.compareLocalProjectToDeployed.unableToCompare);
+        return result;
     }
 }
 export async function checkAndInstallDependencies() {

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,5 +1,5 @@
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
+import { HUBSPOT_ACCOUNT_TYPE_STRINGS, HUBSPOT_ACCOUNT_TYPES, } from '@hubspot/local-dev-lib/constants/config';
 import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { promptUser } from './promptUtils.js';
 import { lib } from '../../lang/en.js';
@@ -92,7 +92,8 @@ export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAc
         devTestAccountsResponse = data;
     }
     catch (err) {
-        uiLogger.debug('Unable to fetch developer test account usage limits: ', err);
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.fetchDeveloperTestAccountsError);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.fetchDeveloperTestAccountsError, EXIT_CODES.ERROR);
     }
     let disabledMessage = false;
     if (devTestAccountsResponse &&

package/lib/theme/cmsDevServerProcess.js

@@ -10,7 +10,7 @@ import { EXIT_CODES } from '../enums/exitCodes.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // cms-dev-server version to install to isolated cache
-const TARGET_CMS_DEV_SERVER_VERSION = '1.2.26';
+const TARGET_CMS_DEV_SERVER_VERSION = '1.2.44';
 /**
  * Ensures cms-dev-server is installed in an isolated cache directory.
  * This prevents React version conflicts with the CLI.

package/lib/usageTracking.d.ts

@@ -19,3 +19,4 @@ export declare function trackHelpUsage(command: string): Promise<void>;
 export declare function trackConvertFieldsUsage(command: string): Promise<void>;
 export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): Promise<void>;
 export declare function trackCommandMetadataUsage(command: string, meta?: UsageTrackingMeta, accountId?: number): Promise<void>;
+export declare function trackMcpPromotionShown(command?: string): Promise<void>;

package/lib/usageTracking.js

@@ -171,6 +171,15 @@ export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
         meta,
     });
 }
+export async function trackMcpPromotionShown(command) {
+    return trackCliInteraction({
+        action: 'cli-mcp-promotion',
+        command: command ?? 'mcp-promotion',
+        meta: {
+            step: 'shown',
+        },
+    });
+}
 async function trackCliInteraction({ action, accountId, command, authType, meta = {}, }) {
     try {
         const config = getConfig();

package/mcp-server/tools/project/CreateTestAccountTool.js

@@ -61,7 +61,7 @@ const inputSchema = {
     commerceLevel: z
         .enum(ACCOUNT_LEVEL_CHOICES_WITHOUT_STARTER)
         .optional()
-        .describe(`Commerce Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES_WITHOUT_STARTER.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+        .describe(`Revenue Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES_WITHOUT_STARTER.join(', ')}. Defaults to ENTERPRISE if not specified.`),
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const createTestAccountInputSchema = z.object({ ...inputSchema });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.2.0-experimental.1",
+    "version": "8.2.0-experimental.2",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
@@ -10,10 +10,10 @@
         "!**/__tests__/**"
     ],
     "dependencies": {
-        "@hubspot/local-dev-lib": "5.8.1",
-        "@hubspot/project-parsing-lib": "0.2.2-experimental.1",
+        "@hubspot/local-dev-lib": "5.9.0",
+        "@hubspot/project-parsing-lib": "0.18.0",
         "@hubspot/serverless-dev-runtime": "7.0.7",
-        "@hubspot/ui-extensions-dev-server": "2.0.9",
+        "@hubspot/ui-extensions-dev-server": "2.0.10",
         "@inquirer/prompts": "7.1.0",
         "@modelcontextprotocol/sdk": "1.29.0",
         "archiver": "7.0.1",