@hubspot/cli 7.7.1-experimental.0 → 7.7.2-experimental.0

package/lib/middleware/configMiddleware.js

@@ -87,6 +87,7 @@ const accountsSubCommands = {
         list: { target: true },
         ls: { target: true },
         remove: { target: true },
+        use: { target: true },
     },
 };
 const sandboxesSubCommands = {

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

@@ -0,0 +1,5 @@
+import { ProjectConfig } from '../../../types/Projects';
+export declare function legacyAddComponent(args: {
+    name?: string;
+    type?: string;
+}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;

package/lib/projects/add/legacyAddComponent.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyAddComponent = legacyAddComponent;
+const Projects_1 = require("../../../types/Projects");
+const structure_1 = require("../structure");
+const errorHandlers_1 = require("../../errorHandlers");
+const en_1 = require("../../../lang/en");
+const legacy_1 = require("../create/legacy");
+const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../constants");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const logger_1 = require("../../ui/logger");
+async function legacyAddComponent(args, projectDir, projectConfig) {
+    // We currently only support adding private apps to projects
+    let projectContainsPublicApp = false;
+    try {
+        const components = await (0, structure_1.findProjectComponents)(projectDir);
+        projectContainsPublicApp = components.some(c => c.type === Projects_1.ComponentTypes.PublicApp);
+    }
+    catch (err) {
+        (0, errorHandlers_1.debugError)(err);
+    }
+    if (projectContainsPublicApp) {
+        throw new Error(en_1.commands.project.add.error.projectContainsPublicApp);
+    }
+    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
+    const components = await (0, legacy_1.getProjectComponentListFromRepo)(projectConfig.platformVersion);
+    if (!components || !components.length) {
+        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+    }
+    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPrompt)(components, args);
+    try {
+        const componentPath = path_1.default.join(projectDir, projectConfig.srcDir, projectAddPromptResponse.name);
+        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {
+            sourceDir: projectAddPromptResponse.componentTemplate.path,
+            branch: 'main',
+            hideLogs: true,
+        });
+        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.name));
+    }
+    catch (error) {
+        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { ProjectConfig } from '../../../types/Projects';
+export declare function v3AddComponent(args: {
+    name?: string;
+    type?: string;
+    features?: string[];
+    auth?: string;
+    distribution?: string;
+}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;

package/lib/projects/add/v3AddComponent.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v3AddComponent = v3AddComponent;
+const en_1 = require("../../../lang/en");
+const legacy_1 = require("../create/legacy");
+const v3_1 = require("../create/v3");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
+const constants_1 = require("../../constants");
+const components_1 = require("../components");
+const project_1 = require("@hubspot/project-parsing-lib/src/lib/project");
+const constants_2 = require("@hubspot/project-parsing-lib/src/lib/constants");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const errorHandlers_1 = require("../../errorHandlers");
+const logger_1 = require("../../ui/logger");
+async function v3AddComponent(args, projectDir, projectConfig) {
+    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
+    const config = await (0, legacy_1.getConfigForPlatformVersion)(projectConfig.platformVersion);
+    const { components, parentComponents } = config;
+    if (!components || !components.length) {
+        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+    }
+    const projectSrcDirectory = path_1.default.join(projectDir, projectConfig.srcDir);
+    const projectMetadata = await (0, project_1.getProjectMetadata)(projectSrcDirectory);
+    let derivedAuthType;
+    let derivedDistribution;
+    const appsMetadata = projectMetadata.components[constants_2.AppKey];
+    const shouldCreateApp = appsMetadata.count === 0;
+    if (shouldCreateApp) {
+        const { authType, distribution } = await (0, v3_1.createV3App)(args.auth, args.distribution);
+        derivedDistribution = distribution;
+        derivedAuthType = authType;
+    }
+    else if (appsMetadata.count > appsMetadata.maxCount) {
+        throw new Error(en_1.lib.projects.create.errors.exceededMaxNumberOfApps(appsMetadata.maxCount));
+    }
+    else {
+        const apps = appsMetadata.hsMetaFiles.map(appLoc => {
+            try {
+                return JSON.parse(fs_1.default.readFileSync(appLoc, 'utf8'));
+            }
+            catch (err) {
+                throw new Error(en_1.lib.projects.create.errors.unableToParseAppConfig(appLoc));
+            }
+        });
+        derivedDistribution = apps[0].config?.distribution;
+        derivedAuthType = apps[0].config?.auth?.type;
+    }
+    const componentTemplateChoices = (0, v3_1.calculateComponentTemplateChoices)(components, derivedAuthType, derivedDistribution, projectMetadata);
+    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPromptV3)(componentTemplateChoices, args.features);
+    try {
+        const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
+            return path_1.default.join(projectConfig.platformVersion, componentTemplate.path);
+        }) || [];
+        if (shouldCreateApp) {
+            const parentComponent = parentComponents?.find(possibleParent => {
+                return (possibleParent.type === v3_1.PROJECT_WITH_APP &&
+                    possibleParent.authType === derivedAuthType &&
+                    possibleParent.distribution === derivedDistribution);
+            });
+            if (parentComponent) {
+                components.push(path_1.default.join(projectConfig.platformVersion, parentComponent.path));
+            }
+        }
+        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDir, {
+            sourceDir: components,
+            hideLogs: true,
+            branch: 'main',
+            handleCollision: components_1.handleComponentCollision,
+        });
+        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.componentTemplate
+            .map(template => `'${template.label}'`)
+            .join(', '), projectAddPromptResponse.componentTemplate.length > 1));
+    }
+    catch (error) {
+        (0, errorHandlers_1.debugError)(error);
+        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent, {
+            cause: error,
+        });
+    }
+}

package/lib/projects/components.d.ts

@@ -0,0 +1,2 @@
+import { Collision } from '@hubspot/local-dev-lib/types/Archive';
+export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;

package/lib/projects/components.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleComponentCollision = handleComponentCollision;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+// Handles a collision between component source files
+function handleComponentCollision({ dest, src, collisions }) {
+    const hsMetaFiles = [];
+    const packageJsonFiles = [];
+    const sourceFiles = [];
+    collisions.forEach(collision => {
+        if (collision.endsWith(project_parsing_lib_1.metafileExtension)) {
+            hsMetaFiles.push(collision);
+        }
+        else if (path_1.default.parse(collision).base === 'package.json') {
+            packageJsonFiles.push(collision);
+        }
+        else {
+            sourceFiles.push(collision);
+        }
+    });
+    const sourceFilenameMapping = sourceFiles.reduce((acc, filename) => {
+        const { name, ext, dir } = path_1.default.parse(filename);
+        return {
+            ...acc,
+            [filename]: path_1.default.join(dir, `${name}-${Date.now()}${ext}`),
+        };
+    }, {});
+    const metafileExtensionPrefix = path_1.default.parse(project_parsing_lib_1.metafileExtension).name;
+    const metaFilenameMapping = hsMetaFiles.reduce((acc, filename) => {
+        const { name, dir } = path_1.default.parse(filename);
+        return {
+            ...acc,
+            [filename]: path_1.default.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${Date.now()}${project_parsing_lib_1.metafileExtension}`),
+        };
+    }, {});
+    // Update the metafiles that might contain references to the old filenames
+    hsMetaFiles.forEach(file => {
+        updateMetaFile({
+            dest,
+            src,
+            file,
+            sourceFilenameMapping,
+            metaFilenameMapping,
+        });
+    });
+    // Copy the renamed files into their new destination location
+    Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
+        fs_1.default.copyFileSync(path_1.default.join(src, key), path_1.default.join(dest, value));
+    });
+    if (packageJsonFiles.length) {
+        handlePackageJsonCollisions(dest, src, packageJsonFiles);
+    }
+}
+function updateMetaFile({ dest, src, file, sourceFilenameMapping, metaFilenameMapping, }) {
+    let text = fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8');
+    Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
+        const { base: oldFileName } = path_1.default.parse(key);
+        const { base: newFileName } = path_1.default.parse(value);
+        text = text.replace(oldFileName, newFileName);
+    });
+    fs_1.default.writeFileSync(path_1.default.join(dest, metaFilenameMapping[file]), text);
+}
+function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
+    packageJsonFiles.forEach(file => {
+        const existingPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dest, file), 'utf-8'));
+        const newPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8'));
+        existingPackageJsonContents.dependencies = {
+            ...newPackageJsonContents.dependencies,
+            ...existingPackageJsonContents.dependencies,
+        };
+        existingPackageJsonContents.devDependencies = {
+            ...newPackageJsonContents.devDependencies,
+            ...existingPackageJsonContents.devDependencies,
+        };
+        fs_1.default.writeFileSync(path_1.default.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
+    });
+}

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

@@ -0,0 +1,23 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs';
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+export type ProjectCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    dest?: string;
+    templateSource?: RepoPath;
+    template?: string;
+    features?: string[];
+    platformVersion: string;
+    projectBase?: string;
+    auth?: string;
+    distribution?: string;
+};
+export declare function handleProjectCreationFlow(args: ArgumentsCamelCase<ProjectCreateArgs>): Promise<{
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    createProjectPromptResponse: CreateProjectPromptResponse;
+}>;

package/lib/projects/create/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProjectCreationFlow = handleProjectCreationFlow;
+const createProjectPrompt_1 = require("../../prompts/createProjectPrompt");
+const constants_1 = require("../../constants");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const v3_1 = require("./v3");
+const legacy_1 = require("./legacy");
+const logger_1 = require("../../ui/logger");
+const en_1 = require("../../../lang/en");
+const exitCodes_1 = require("../../enums/exitCodes");
+async function handleProjectCreationFlow(args) {
+    const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
+    const repo = templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await (0, v3_1.v3ComponentFlow)(platformVersion, projectBase, providedAuth, providedDistribution);
+        const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, undefined, projectContents !== v3_1.EMPTY_PROJECT ? componentTemplateChoices : undefined);
+        return {
+            authType,
+            distribution,
+            repoConfig,
+            projectContents,
+            createProjectPromptResponse,
+        };
+    }
+    const projectTemplates = await (0, legacy_1.getProjectTemplateListFromRepo)(repo, 'main');
+    if (!projectTemplates.length) {
+        logger_1.uiLogger.error(en_1.commands.project.create.errors.failedToFetchProjectList);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, projectTemplates);
+    return { createProjectPromptResponse };
+}

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

@@ -0,0 +1,6 @@
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+import { ProjectTemplate, ComponentTemplate, ProjectTemplateRepoConfig } from '../../../types/Projects';
+export declare const EMPTY_PROJECT_TEMPLATE_NAME = "no-template";
+export declare function getConfigForPlatformVersion(platformVersion: string): Promise<ProjectTemplateRepoConfig> | never;
+export declare function getProjectComponentListFromRepo(platformVersion: string): Promise<ComponentTemplate[]>;
+export declare function getProjectTemplateListFromRepo(templateSource: RepoPath, githubRef: string): Promise<ProjectTemplate[]>;

package/lib/projects/{create.js → create/legacy.js}

@@ -1,24 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMPTY_PROJECT_TEMPLATE_NAME = void 0;
+exports.getConfigForPlatformVersion = getConfigForPlatformVersion;
 exports.getProjectComponentListFromRepo = getProjectComponentListFromRepo;
 exports.getProjectTemplateListFromRepo = getProjectTemplateListFromRepo;
 const github_1 = require("@hubspot/local-dev-lib/api/github");
-const constants_1 = require("../constants");
-const exitCodes_1 = require("../enums/exitCodes");
-const index_1 = require("../errorHandlers/index");
-const en_1 = require("../../lang/en");
-const logger_1 = require("../ui/logger");
+const constants_1 = require("../../constants");
+const exitCodes_1 = require("../../enums/exitCodes");
+const errorHandlers_1 = require("../../errorHandlers");
+const logger_1 = require("../../ui/logger");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const en_1 = require("../../../lang/en");
+const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 exports.EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
-const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path', 'insertPath'];
-async function getProjectComponentListFromRepo(githubRef) {
+async function getConfigForPlatformVersion(platformVersion) {
+    let path = '';
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        path = `${platformVersion}/`;
+    }
+    const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, 'main');
+    return data;
+}
+async function getProjectComponentListFromRepo(platformVersion) {
     let config;
     try {
-        const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', githubRef);
-        config = data;
+        config = await getConfigForPlatformVersion(platformVersion);
     }
     catch (err) {
-        (0, index_1.debugError)(err);
+        (0, errorHandlers_1.debugError)(err);
     }
     if (config) {
         return config[constants_1.PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
@@ -32,7 +41,7 @@ async function getProjectTemplateListFromRepo(templateSource, githubRef) {
         config = data;
     }
     catch (e) {
-        (0, index_1.debugError)(e);
+        (0, errorHandlers_1.debugError)(e);
         logger_1.uiLogger.error(en_1.lib.projects.create.errors.missingConfigFileTemplateSource);
         return process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }

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

@@ -0,0 +1,27 @@
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+export declare const EMPTY_PROJECT = "empty";
+export declare const PROJECT_WITH_APP = "app";
+export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
+    authType: string;
+    distribution: string;
+}>;
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, projectMetadata?: ProjectMetadata): ComponentTemplateChoice[];
+type V3ComponentInfo = {
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    componentTemplateChoices?: ComponentTemplateChoice[];
+};
+export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined): Promise<V3ComponentInfo>;
+export declare function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
+    createProjectPromptResponse: CreateProjectPromptResponse;
+    platformVersion: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    authType?: string;
+    distribution?: string;
+}): string[];
+export {};

package/lib/projects/create/v3.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJECT_WITH_APP = exports.EMPTY_PROJECT = void 0;
+exports.createV3App = createV3App;
+exports.calculateComponentTemplateChoices = calculateComponentTemplateChoices;
+exports.v3ComponentFlow = v3ComponentFlow;
+exports.generateComponentPaths = generateComponentPaths;
+const constants_1 = require("../../constants");
+const en_1 = require("../../../lang/en");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const chalk_1 = __importDefault(require("chalk"));
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const path_1 = __importDefault(require("path"));
+const legacy_1 = require("./legacy");
+const errorHandlers_1 = require("../../errorHandlers");
+const exitCodes_1 = require("../../enums/exitCodes");
+const inquirer = require('inquirer');
+exports.EMPTY_PROJECT = 'empty';
+exports.PROJECT_WITH_APP = 'app';
+async function createV3App(providedAuth, providedDistribution) {
+    let authType;
+    if (providedAuth &&
+        providedDistribution === constants_1.marketplaceDistribution &&
+        providedAuth !== constants_1.oAuth) {
+        throw new Error(en_1.lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
+    }
+    const distribution = providedDistribution ||
+        (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.distribution, {
+            choices: [
+                {
+                    name: en_1.lib.projects.create.prompt.marketPlaceDistribution,
+                    value: constants_1.marketplaceDistribution,
+                },
+                {
+                    name: en_1.lib.projects.create.prompt.privateDistribution,
+                    value: constants_1.privateDistribution,
+                },
+            ],
+        }));
+    if (distribution === constants_1.marketplaceDistribution) {
+        // This is the only valid auth type for marketplace
+        authType = constants_1.oAuth;
+    }
+    else {
+        authType =
+            providedAuth ||
+                (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.auth, {
+                    choices: [
+                        { name: en_1.lib.projects.create.prompt.staticAuth, value: constants_1.staticAuth },
+                        { name: en_1.lib.projects.create.prompt.oauth, value: constants_1.oAuth },
+                    ],
+                }));
+    }
+    return {
+        distribution,
+        authType,
+    };
+}
+function calculateComponentTemplateChoices(components, authType, distribution, projectMetadata) {
+    const enabledComponents = [];
+    const disabledComponents = [];
+    components.forEach(template => {
+        const { supportedAuthTypes, supportedDistributions } = template;
+        const disabledReasons = [];
+        if (projectMetadata) {
+            const { count, maxCount } = projectMetadata.components[template.type];
+            if (count >= maxCount) {
+                disabledReasons.push(en_1.commands.project.add.error.maxExceeded(maxCount));
+            }
+        }
+        if (Array.isArray(supportedAuthTypes) &&
+            authType &&
+            !supportedAuthTypes.includes(authType)) {
+            disabledReasons.push(en_1.commands.project.add.error.authTypeNotAllowed(authType));
+        }
+        if (Array.isArray(supportedDistributions) &&
+            distribution &&
+            !supportedDistributions.includes(distribution)) {
+            disabledReasons.push(en_1.commands.project.add.error.distributionNotAllowed(distribution));
+        }
+        if (disabledReasons.length > 0) {
+            disabledComponents.push({
+                name: `[${chalk_1.default.yellow('DISABLED')}] ${template.label}`,
+                value: template,
+                disabled: disabledReasons.join(' '),
+            });
+        }
+        else {
+            enabledComponents.push({
+                name: template.label,
+                value: template,
+            });
+        }
+    });
+    return disabledComponents.length
+        ? [...enabledComponents, new inquirer.Separator(), ...disabledComponents]
+        : [...enabledComponents];
+}
+async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution) {
+    let repoConfig = undefined;
+    let authType;
+    let distribution;
+    try {
+        repoConfig = await (0, legacy_1.getConfigForPlatformVersion)(platformVersion);
+    }
+    catch (error) {
+        (0, errorHandlers_1.logError)(error);
+        return process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    const projectContentsChoice = projectBase ||
+        (await (0, promptUtils_1.listPrompt)(en_1.commands.project.create.prompts.parentComponents, {
+            choices: [
+                {
+                    name: en_1.commands.project.create.prompts.emptyProject,
+                    value: exports.EMPTY_PROJECT,
+                },
+                { name: en_1.commands.project.create.prompts.app, value: exports.PROJECT_WITH_APP },
+            ],
+        }));
+    if (projectContentsChoice === exports.PROJECT_WITH_APP) {
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
+        authType = selectedAuthType;
+        distribution = selectedDistribution;
+    }
+    const componentTemplateChoices = calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution);
+    return {
+        componentTemplateChoices,
+        authType,
+        distribution,
+        projectContents: projectContentsChoice,
+        repoConfig,
+    };
+}
+function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
+    if (!(0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        return [];
+    }
+    const components = createProjectPromptResponse.componentTemplates?.map((componentTemplate) => {
+        return path_1.default.join(platformVersion, componentTemplate.path);
+    }) || [];
+    if (projectContents && projectContents !== exports.EMPTY_PROJECT) {
+        const parentComponent = repoConfig?.parentComponents?.find(possibleParent => {
+            return (possibleParent.type === projectContents &&
+                possibleParent.authType === authType &&
+                possibleParent.distribution === distribution);
+        });
+        if (parentComponent) {
+            components.push(path_1.default.join(platformVersion, parentComponent.path));
+        }
+    }
+    if (repoConfig?.defaultFiles) {
+        components.push(path_1.default.join(platformVersion, repoConfig?.defaultFiles));
+    }
+    return components;
+}

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

@@ -1,4 +1,3 @@
-import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
 import { AppIRNode } from '../../../types/ProjectComponents';
 import LocalDevState from './LocalDevState';
 import LocalDevLogger from './LocalDevLogger';
@@ -10,14 +9,16 @@ declare class AppDevModeInterface {
     localDevState: LocalDevState;
     localDevLogger: LocalDevLogger;
     _appNode?: AppIRNode | null;
-    appData?: PublicApp;
     marketplaceAppInstalls?: number;
     constructor(options: AppDevModeInterfaceConstructorOptions);
     private get appNode();
+    private get appData();
+    private set appData(value);
     private getAppInstallUrl;
     private fetchAppData;
     private checkMarketplaceAppInstalls;
     private checkTestAccountAppInstallation;
+    private setUpLocalDevServerMessageListeners;
     setup(args: any): Promise<void>;
     start(): Promise<void>;
     fileChange(filePath: string, event: string): Promise<void>;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -18,7 +18,6 @@ class AppDevModeInterface {
     localDevState;
     localDevLogger;
     _appNode;
-    appData;
     marketplaceAppInstalls;
     constructor(options) {
         this.localDevState = options.localDevState;
@@ -48,6 +47,18 @@ class AppDevModeInterface {
         }
         return this._appNode;
     }
+    get appData() {
+        if (!this.appNode) {
+            return undefined;
+        }
+        return this.localDevState.getAppDataByUid(this.appNode.uid);
+    }
+    set appData(appData) {
+        if (!this.appNode) {
+            return;
+        }
+        this.localDevState.setAppDataForUid(this.appNode.uid, appData);
+    }
     async getAppInstallUrl() {
         if (this.appNode?.config.auth.type === constants_1.APP_AUTH_TYPES.OAUTH) {
             return (0, urls_1.getOauthAppInstallUrl)({
@@ -77,7 +88,12 @@ class AppDevModeInterface {
             return;
         }
         const { data: { uniquePortalInstallCount }, } = await (0, appsDev_1.fetchPublicAppProductionInstallCounts)(appData.id, this.localDevState.targetProjectAccountId);
-        this.appData = appData;
+        this.appData = {
+            id: appData.id,
+            clientId: appData.clientId,
+            name: appData.name,
+            installationState: constants_1.APP_INSTALLATION_STATES.NOT_INSTALLED,
+        };
         this.marketplaceAppInstalls = uniquePortalInstallCount;
     }
     async checkMarketplaceAppInstalls() {
@@ -100,11 +116,30 @@ class AppDevModeInterface {
         }
         const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await (0, localDevAuth_1.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: constants_1.APP_INSTALLATION_STATES.INSTALLED,
+            };
+        }
+        else if (isReinstall) {
+            this.appData = {
+                ...this.appData,
+                installationState: constants_1.APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
+            };
+        }
         if (!isInstalledWithScopeGroups) {
             const installUrl = await this.getAppInstallUrl();
             await (0, installAppPrompt_1.installAppPrompt)(installUrl, isReinstall);
         }
     }
+    setUpLocalDevServerMessageListeners() {
+        this.localDevState.addListener('devServerMessage', message => {
+            if (message === constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
+                this.checkTestAccountAppInstallation();
+            }
+        });
+    }
     // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
     // In the future, update UIE Dev Server to use LocalDevState
     async setup(args) {
@@ -121,6 +156,7 @@ class AppDevModeInterface {
         catch (e) {
             (0, index_1.logError)(e);
         }
+        this.setUpLocalDevServerMessageListeners();
         return ui_extensions_dev_server_1.DevModeUnifiedInterface.setup(args);
     }
     async start() {