@hubspot/cli 7.8.0-experimental.0 → 7.8.0

package/lib/projects/add/{v3AddComponent.js → v2AddComponent.js}

@@ -1,10 +1,10 @@
 import { commands, lib } from '../../../lang/en.js';
 import { getConfigForPlatformVersion } from '../create/legacy.js';
-import { calculateComponentTemplateChoices, createV3App, } from '../create/v3.js';
+import { calculateComponentTemplateChoices, createV2App, } from '../create/v2.js';
 import { PROJECT_WITH_APP } from '../../constants.js';
 import path from 'path';
 import fs from 'fs';
-import { projectAddPromptV3 } from '../../prompts/projectAddPrompt.js';
+import { projectAddPromptV2 } from '../../prompts/projectAddPrompt.js';
 import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../constants.js';
 import { updateHsMetaFilesWithAutoGeneratedFields, handleComponentCollision, } from '../components.js';
 import { getProjectMetadata, } from '@hubspot/project-parsing-lib/src/lib/project.js';
@@ -13,7 +13,7 @@ import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { debugError } from '../../errorHandlers/index.js';
 import { uiLogger } from '../../ui/logger.js';
 import { trackCommandUsage } from '../../usageTracking.js';
-export async function v3AddComponent(args, projectDir, projectConfig, accountId) {
+export async function v2AddComponent(args, projectDir, projectConfig, accountId) {
     uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
     const config = await getConfigForPlatformVersion(projectConfig.platformVersion);
     const { components, parentComponents } = config;
@@ -27,7 +27,7 @@ export async function v3AddComponent(args, projectDir, projectConfig, accountId)
     const appsMetadata = currentProjectMetadata.components[AppKey];
     const shouldCreateApp = appsMetadata.count === 0;
     if (shouldCreateApp) {
-        const { authType, distribution } = await createV3App(args.auth, args.distribution);
+        const { authType, distribution } = await createV2App(args.auth, args.distribution);
         derivedDistribution = distribution;
         derivedAuthType = authType;
     }
@@ -47,7 +47,7 @@ export async function v3AddComponent(args, projectDir, projectConfig, accountId)
         derivedAuthType = apps[0].config?.auth?.type;
     }
     const componentTemplateChoices = await calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, args.derivedAccountId, currentProjectMetadata);
-    const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
+    const projectAddPromptResponse = await projectAddPromptV2(componentTemplateChoices, args.features);
     const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.cliSelector || componentTemplate.type);
     await trackCommandUsage('project-add', {
         type: componentTypes?.join(','),

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

@@ -1,9 +1,9 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../../ui/logger.js';
 import * as github from '@hubspot/local-dev-lib/api/github';
 import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { getProjectComponentListFromRepo, getProjectTemplateListFromRepo, } from '../legacy.js';
 import { PROJECT_COMPONENT_TYPES, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../../../constants.js';
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/api/github');
 const mockedFetchRepoFile = vi.mocked(github.fetchRepoFile);
 const repoConfig = {
@@ -60,14 +60,14 @@ describe('lib/projects/create/legacy', () => {
         it('Logs an error and exits the process if the request for the template list fails', async () => {
             mockedFetchRepoFile.mockRejectedValue(new Error('Not found'));
             await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/Failed to fetch the config.json file from the target repository/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Failed to fetch the config.json file from the target repository/));
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
         });
         it('Logs an error and exits the process if there are no projects listed in the repo config', async () => {
             // @ts-expect-error - Mocking AxiosResponse
             mockedFetchRepoFile.mockResolvedValue({});
             await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/Unable to find any projects in the target repository's config.json file/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Unable to find any projects in the target repository's config.json file/));
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
         });
         it('Logs an error and exits the process if any of the projects in the repo config are missing required properties', async () => {
@@ -84,7 +84,7 @@ describe('lib/projects/create/legacy', () => {
                 },
             });
             await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/Found misconfigured projects in the target repository's config.json file/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Found misconfigured projects in the target repository's config.json file/));
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
         });
     });

package/lib/projects/create/__tests__/v2.test.d.ts

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

package/lib/projects/create/__tests__/{v3.test.js → v2.test.js}

@@ -1,8 +1,17 @@
-import { calculateComponentTemplateChoices } from '../v3.js';
-vi.mock('@hubspot/local-dev-lib/logger');
+import { calculateComponentTemplateChoices } from '../v2.js';
+import { hasFeature } from '../../../hasFeature.js';
+vi.mock('../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/api/github');
-describe('lib/projects/create/v3', () => {
+vi.mock('../../../hasFeature.js');
+const mockHasFeature = vi.mocked(hasFeature);
+describe('lib/projects/create/v2', () => {
+    beforeEach(() => {
+        mockHasFeature.mockResolvedValue(true);
+    });
     describe('calculateComponentTemplateChoices()', () => {
+        beforeEach(() => {
+            mockHasFeature.mockClear();
+        });
         const mockComponents = [
             {
                 label: 'Module Component',
@@ -30,7 +39,7 @@ describe('lib/projects/create/v3', () => {
             const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', 123, mockProjectMetadataForChoices);
             expect(choices).toHaveLength(4); // includes separator
             expect(choices[0]).toEqual({
-                name: 'Module Component',
+                name: 'Module Component [module]',
                 value: mockComponents[0],
             });
             expect(choices[2]).toEqual({
@@ -70,7 +79,7 @@ describe('lib/projects/create/v3', () => {
                 components: { module: { count: 0, maxCount: 5, hsMetaFiles: [] } },
             });
             expect(choices[0]).toEqual({
-                name: 'Unrestricted Component',
+                name: 'Unrestricted Component [module]',
                 value: componentsWithoutRestrictions[0],
             });
         });
@@ -94,7 +103,7 @@ describe('lib/projects/create/v3', () => {
             const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 213, projectMetadataWithWorkflowAction);
             expect(choices).toHaveLength(1); // no disabled components
             expect(choices[0]).toEqual({
-                name: 'Workflow Action Tool',
+                name: 'Workflow Action Tool [workflow-action-tool]',
                 value: componentWithCliSelector[0],
             });
         });
@@ -137,7 +146,7 @@ describe('lib/projects/create/v3', () => {
             const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, undefined);
             expect(choices).toHaveLength(1); // no disabled components
             expect(choices[0]).toEqual({
-                name: 'Workflow Action Tool',
+                name: 'Workflow Action Tool [workflow-action-tool]',
                 value: componentWithCliSelector[0],
             });
         });
@@ -162,5 +171,71 @@ describe('lib/projects/create/v3', () => {
             // @ts-expect-error breaking stuff on purpose
             projectMetadataWithoutComponents)).rejects.toThrow();
         });
+        it('disables gated components when hasFeature returns false', async () => {
+            mockHasFeature.mockResolvedValue(false);
+            const gatedComponent = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const choices = await calculateComponentTemplateChoices(gatedComponent, 'oauth', 'private', 123, mockProjectMetadataForChoices);
+            expect(choices).toHaveLength(3); // includes separators
+            expect(choices[1]).toEqual({
+                name: expect.stringContaining('Workflow Action Tool'),
+                value: gatedComponent[0],
+                disabled: expect.stringContaining('does not have access to this feature'),
+            });
+            expect(mockHasFeature).toHaveBeenCalledWith(123, expect.any(String));
+        });
+        it('enables gated components when hasFeature returns true', async () => {
+            mockHasFeature.mockResolvedValue(true);
+            const gatedComponent = [
+                {
+                    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: 0, maxCount: 3, hsMetaFiles: [] },
+                },
+            };
+            const choices = await calculateComponentTemplateChoices(gatedComponent, 'oauth', 'private', 123, projectMetadataWithWorkflowAction);
+            expect(choices).toHaveLength(1); // no disabled components
+            expect(choices[0]).toEqual({
+                name: 'Workflow Action Tool [workflow-action-tool]',
+                value: gatedComponent[0],
+            });
+            expect(mockHasFeature).toHaveBeenCalledWith(123, expect.any(String));
+        });
+        it('handles non-gated components without calling hasFeature', async () => {
+            const nonGatedComponent = [
+                {
+                    label: 'Regular Component',
+                    path: 'regular',
+                    type: 'module',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const choices = await calculateComponentTemplateChoices(nonGatedComponent, 'oauth', 'private', 123, mockProjectMetadataForChoices);
+            expect(choices).toHaveLength(1);
+            expect(choices[0]).toEqual({
+                name: 'Regular Component [module]',
+                value: nonGatedComponent[0],
+            });
+            // hasFeature should not be called for non-gated components
+            expect(mockHasFeature).not.toHaveBeenCalled();
+        });
     });
 });

package/lib/projects/create/index.js

@@ -1,8 +1,8 @@
 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 '../platformVersion.js';
-import { v3ComponentFlow } from './v3.js';
+import { isV2Project } from '../platformVersion.js';
+import { v2ComponentFlow } from './v2.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
 import { uiLogger } from '../../ui/logger.js';
 import { commands } from '../../../lang/en.js';
@@ -11,8 +11,8 @@ export async function handleProjectCreationFlow(args) {
     const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = 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, args.derivedAccountId);
+    if (isV2Project(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v2ComponentFlow(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,13 +3,13 @@ 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 '../platformVersion.js';
+import { isV2Project } from '../platformVersion.js';
 import { lib } from '../../../lang/en.js';
 const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
 export async function getConfigForPlatformVersion(platformVersion) {
     let path = '';
-    if (useV3Api(platformVersion)) {
+    if (isV2Project(platformVersion)) {
         path = `${platformVersion}/`;
     }
     const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, DEFAULT_PROJECT_TEMPLATE_BRANCH);

package/lib/projects/create/{v3.d.ts → v2.d.ts}

@@ -2,19 +2,19 @@ import { Separator } from '@inquirer/prompts';
 import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
 import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
-export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
+export declare function createV2App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
     authType: string;
     distribution: string;
 }>;
 export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, accountId: number, projectMetadata?: ProjectMetadata): Promise<(ComponentTemplateChoice | Separator)[]>;
-type V3ComponentInfo = {
+type V2ComponentInfo = {
     authType?: string;
     distribution?: string;
     repoConfig?: ProjectTemplateRepoConfig;
     projectContents?: string;
     componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
 };
-export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V3ComponentInfo>;
+export declare function v2ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V2ComponentInfo>;
 export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
     selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
     platformVersion: string;

package/lib/projects/create/{v3.js → v2.js}

@@ -3,14 +3,14 @@ import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_
 import { commands, lib } from '../../../lang/en.js';
 import { listPrompt } from '../../prompts/promptUtils.js';
 import chalk from 'chalk';
-import { useV3Api } from '../platformVersion.js';
+import { isV2Project } 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 } from '@hubspot/project-parsing-lib/src/lib/constants.js';
-export async function createV3App(providedAuth, providedDistribution) {
+import { AppEventsKey, PagesKey, } from '@hubspot/project-parsing-lib/src/lib/constants.js';
+export async function createV2App(providedAuth, providedDistribution) {
     let authType;
     if (providedAuth &&
         providedDistribution === marketplaceDistribution &&
@@ -51,6 +51,8 @@ export async function createV3App(providedAuth, providedDistribution) {
 }
 const componentTypeToGateMap = {
     [AppEventsKey]: FEATURES.APP_EVENTS,
+    [PagesKey]: FEATURES.APPS_HOME,
+    'workflow-action-tool': FEATURES.AGENT_TOOLS,
 };
 export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
     const enabledComponents = [];
@@ -72,30 +74,31 @@ export async function calculateComponentTemplateChoices(components, authType, di
         }
         if (Array.isArray(supportedAuthTypes) &&
             authType &&
-            !supportedAuthTypes.includes(authType)) {
+            !supportedAuthTypes.includes(authType.toLowerCase())) {
             disabledReasons.push(commands.project.add.error.authTypeNotAllowed(authType));
         }
         if (Array.isArray(supportedDistributions) &&
             distribution &&
-            !supportedDistributions.includes(distribution)) {
+            !supportedDistributions.includes(distribution.toLowerCase())) {
             disabledReasons.push(commands.project.add.error.distributionNotAllowed(distribution));
         }
-        if (componentTypeToGateMap[template.type]) {
-            const isUngated = await hasFeature(accountId, componentTypeToGateMap[template.type]);
+        const templateGate = componentTypeToGateMap[template.cliSelector || template.type];
+        if (templateGate) {
+            const isUngated = await hasFeature(accountId, templateGate);
             if (!isUngated) {
-                disabledReasons.push(commands.project.add.error.portalDoesNotHaveAccessToThisFeature(accountId));
+                disabledReasons.unshift(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(' '),
             });
         }
         else {
             enabledComponents.push({
-                name: template.label,
+                name: `${template.label} [${template.cliSelector || template.type}]`,
                 value: template,
             });
         }
@@ -109,7 +112,7 @@ export async function calculateComponentTemplateChoices(components, authType, di
         ]
         : [...enabledComponents];
 }
-export async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
+export async function v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
     let repoConfig = undefined;
     let authType;
     let distribution;
@@ -131,7 +134,7 @@ export async function v3ComponentFlow(platformVersion, projectBase, providedAuth
             ],
         }));
     if (projectContentsChoice === PROJECT_WITH_APP) {
-        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV2App(providedAuth, providedDistribution);
         authType = selectedAuthType;
         distribution = selectedDistribution;
     }
@@ -145,7 +148,7 @@ export async function v3ComponentFlow(platformVersion, projectBase, providedAuth
     };
 }
 export function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
-    if (!useV3Api(platformVersion)) {
+    if (!isV2Project(platformVersion)) {
         return [];
     }
     const components = selectProjectTemplatePromptResponse.componentTemplates?.map((componentTemplate) => {

package/lib/projects/deploy.d.ts

@@ -10,4 +10,4 @@ export declare function logDeployErrors(errorData: {
         };
     }>;
 }): void;
-export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, useV3Api: boolean, force: boolean): Promise<Deploy | undefined>;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isV2Project: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -47,8 +47,8 @@ function handleBlockedDeploy(deployResp) {
         uiLogger.log('');
     });
 }
-export async function handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force) {
-    const { data: deployResp } = await deployProject(targetAccountId, projectName, buildId, useV3Api, force);
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, isV2Project, force) {
+    const { data: deployResp } = await deployProject(targetAccountId, projectName, buildId, isV2Project, force);
     if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
         if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {
             handleBlockedDeploy(deployResp);

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

@@ -10,19 +10,28 @@ declare class AppDevModeInterface {
     localDevLogger: LocalDevLogger;
     _appNode?: AppIRNode | null;
     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;
     private checkMarketplaceAppInstalls;
+    private waitUntilAppIsInstalled;
+    private autoInstallStaticAuthApp;
     private installAppOrOpenInstallUrl;
     private checkTestAccountAppInstallation;
+    private resolveAppInstallPromise;
+    private handleAppInstallSuccessDevServerMessage;
+    private handleAppInstallInitiatedDevServerMessage;
+    private handleAppInstallFailureDevServerMessage;
     private onDevServerMessage;
     private onChangeProjectNodes;
-    private setUpStateListeners;
     private removeStateListeners;
     setup(args: any): Promise<void>;
     start(): Promise<void>;