@hubspot/cli 7.5.4-experimental.0 → 7.5.4

package/lib/middleware/configMiddleware.js

@@ -40,10 +40,17 @@ async function injectAccountIdMiddleware(argv) {
 const SKIP_CONFIG_VALIDATION = {
     init: { target: true },
     auth: { target: true },
+    mcp: {
+        target: false,
+        subCommands: {
+            setup: { target: true },
+            start: { target: true },
+        },
+    },
 };
 async function loadConfigMiddleware(argv) {
     // Skip this when no command is provided
-    if (!argv._.length) {
+    if (!argv._.length || argv.help) {
         return;
     }
     const maybeValidateConfig = () => {
@@ -52,6 +59,13 @@ async function loadConfigMiddleware(argv) {
             process.exit(exitCodes_1.EXIT_CODES.ERROR);
         }
     };
+    if (!(0, config_1.configFileExists)(true) &&
+        (0, utils_1.isTargetedCommand)(argv._, {
+            account: { target: false, subCommands: { auth: { target: true } } },
+            config: { target: false, subCommands: { migrate: { target: true } } },
+        })) {
+        return;
+    }
     if ((0, config_1.configFileExists)(true) &&
         argv.config &&
         !(0, utils_1.isTargetedCommand)(argv._, {
@@ -75,10 +89,12 @@ async function loadConfigMiddleware(argv) {
 const accountsSubCommands = {
     target: false,
     subCommands: {
+        auth: { target: true },
         clean: { target: true },
         list: { target: true },
         ls: { target: true },
         remove: { target: true },
+        use: { target: true },
     },
 };
 const sandboxesSubCommands = {
@@ -87,17 +103,31 @@ const sandboxesSubCommands = {
         delete: { target: true },
     },
 };
+const configSubCommands = {
+    target: false,
+    subCommands: {
+        migrate: { target: true },
+    },
+};
 const SKIP_ACCOUNT_VALIDATION = {
     init: { target: true },
     auth: { target: true },
+    mcp: {
+        target: false,
+        subCommands: {
+            setup: { target: true },
+            start: { target: true },
+        },
+    },
     account: accountsSubCommands,
     accounts: accountsSubCommands,
     sandbox: sandboxesSubCommands,
     sandboxes: sandboxesSubCommands,
+    config: configSubCommands,
 };
 async function validateAccountOptions(argv) {
     // Skip this when no command is provided
-    if (argv._.length) {
+    if (argv._.length && !argv.help) {
         let validAccount = true;
         if (!(0, utils_1.isTargetedCommand)(argv._, SKIP_ACCOUNT_VALIDATION)) {
             validAccount = await (0, validation_1.validateAccount)(argv);

package/lib/middleware/fireAlarmMiddleware.d.ts

@@ -1,4 +1,4 @@
 import { Arguments } from 'yargs';
-export declare function checkFireAlarms(args: Arguments<{
-    derivedAccountId: number;
+export declare function checkFireAlarms(argv: Arguments<{
+    derivedAccountId?: number;
 }>): Promise<void>;

package/lib/middleware/fireAlarmMiddleware.js

@@ -6,11 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkFireAlarms = checkFireAlarms;
 const chalk_1 = __importDefault(require("chalk"));
 const fireAlarm_1 = require("@hubspot/local-dev-lib/api/fireAlarm");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
 const errorHandlers_1 = require("../errorHandlers");
 const package_json_1 = __importDefault(require("../../package.json"));
-const ui_1 = require("../ui");
-const lang_1 = require("../lang");
+const boxen_1 = require("../ui/boxen");
 /*
  * Versions can be formatted like this:
  * =7.2.2 -> targets the exact version 7.2.2
@@ -106,30 +104,20 @@ async function logFireAlarms(accountId, command, version) {
             }
             return acc;
         }, '');
-        let boxen;
-        try {
-            // The boxen package is exported as a module, so we have to use a dynamic import
-            boxen = (await import('boxen')).default;
-        }
-        catch (error) {
-            logger_1.logger.debug(`${(0, lang_1.i18n)('lib.middleware.fireAlarm.failedToLoadBoxen')}`);
-            return;
-        }
-        logger_1.logger.log(boxen(notifications, {
-            title: 'Notifications',
-            titleAlignment: 'left',
-            borderColor: ui_1.UI_COLORS.MARIGOLD,
-            margin: 1,
-            padding: 1,
-            textAlignment: 'left',
-            borderStyle: 'round',
-        }));
+        await (0, boxen_1.logInBox)({
+            contents: notifications,
+            options: {
+                title: 'Notifications',
+            },
+        });
     }
 }
-async function checkFireAlarms(args) {
-    const { derivedAccountId } = args;
+async function checkFireAlarms(argv) {
+    const { derivedAccountId } = argv;
     try {
-        await logFireAlarms(derivedAccountId, args._.join(' '), package_json_1.default.version);
+        if (derivedAccountId) {
+            await logFireAlarms(derivedAccountId, argv._.join(' '), package_json_1.default.version);
+        }
     }
     catch (error) {
         (0, errorHandlers_1.debugError)(error);

package/lib/middleware/yargsChecksMiddleware.js

@@ -4,7 +4,7 @@ exports.performChecks = performChecks;
 const logger_1 = require("@hubspot/local-dev-lib/logger");
 const exitCodes_1 = require("../enums/exitCodes");
 const lang_1 = require("../lang");
-const projects_1 = require("../projects");
+const config_1 = require("../projects/config");
 const utils_1 = require("./utils");
 const UPLOAD_AND_WATCH_COMMANDS = {
     upload: { target: true },
@@ -13,7 +13,7 @@ const UPLOAD_AND_WATCH_COMMANDS = {
 function performChecks(argv) {
     // Require "project" command when running upload/watch inside of a project
     if ((0, utils_1.isTargetedCommand)(argv._, UPLOAD_AND_WATCH_COMMANDS) &&
-        (0, projects_1.getIsInProject)(argv.src)) {
+        (0, config_1.getIsInProject)(argv.src)) {
         logger_1.logger.error((0, lang_1.i18n)(`commands.generalErrors.srcIsProject`, {
             src: argv.src || './',
             command: argv._.join(' '),

package/lib/npm.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_PACKAGE_MANAGER = "npm";
+export declare function isGloballyInstalled(packageName: string): Promise<boolean>;
+export declare function getLatestCliVersion(): Promise<{
+    latest: string;
+    next: string;
+}>;
+export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
+    cwd?: string;
+}): Promise<void>;

package/lib/npm.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PACKAGE_MANAGER = void 0;
+exports.isGloballyInstalled = isGloballyInstalled;
+exports.getLatestCliVersion = getLatestCliVersion;
+exports.executeInstall = executeInstall;
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const package_json_1 = __importDefault(require("../package.json"));
+exports.DEFAULT_PACKAGE_MANAGER = 'npm';
+async function isGloballyInstalled(packageName) {
+    const exec = util_1.default.promisify(child_process_1.exec);
+    try {
+        await exec(`${packageName} --version`);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+async function getLatestCliVersion() {
+    const exec = util_1.default.promisify(child_process_1.exec);
+    const { stdout } = await exec(`npm info ${package_json_1.default.name} dist-tags --json`);
+    const { latest, next } = JSON.parse(stdout);
+    return { latest, next };
+}
+async function executeInstall(packages = [], flags, options) {
+    const installCommand = `${exports.DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
+    logger_1.logger.debug('Running ', installCommand);
+    const exec = util_1.default.promisify(child_process_1.exec);
+    await exec(installCommand, options);
+}

package/lib/oauth.js

@@ -19,13 +19,12 @@ const lang_1 = require("./lang");
 const exitCodes_1 = require("./enums/exitCodes");
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
-const i18nKey = 'lib.oauth';
 function buildAuthUrl(oauthManager) {
     const { env: accountEnv, clientId, scopes: accountScopes, } = oauthManager.account;
     const env = accountEnv || environments_1.ENVIRONMENTS.PROD;
     const scopes = accountScopes || auth_1.DEFAULT_OAUTH_SCOPES;
     if (!clientId) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.missingClientId`));
+        logger_1.logger.error((0, lang_1.i18n)(`lib.oauth.missingClientId`));
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     return (`${(0, urls_1.getHubSpotWebsiteOrigin)(env)}/oauth/${oauthManager.account.accountId}/authorize` +

package/lib/process.js

@@ -9,7 +9,6 @@ exports.handleKeypress = handleKeypress;
 const readline_1 = __importDefault(require("readline"));
 const logger_1 = require("@hubspot/local-dev-lib/logger");
 const lang_1 = require("./lang");
-const i18nKey = 'lib.process';
 exports.TERMINATION_SIGNALS = [
     'beforeExit',
     'SIGINT', // Terminal trying to interrupt (Ctrl + C)
@@ -32,7 +31,7 @@ function handleExit(callback) {
                 if (isSIGHUP) {
                     (0, logger_1.setLogLevel)(logger_1.LOG_LEVEL.NONE);
                 }
-                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.exitDebug`, { signal }));
+                logger_1.logger.debug((0, lang_1.i18n)(`lib.process.exitDebug`, { signal }));
                 await callback({ isSIGHUP });
             }
         });

package/lib/projectProfiles.d.ts

@@ -0,0 +1,7 @@
+import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types';
+import { ProjectConfig } from '../types/Projects';
+export declare function logProfileHeader(profileName: string): void;
+export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
+export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
+export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logProfileHeader = logProfileHeader;
+exports.logProfileFooter = logProfileFooter;
+exports.loadProfile = loadProfile;
+exports.exitIfUsingProfiles = exitIfUsingProfiles;
+exports.loadAndValidateProfile = loadAndValidateProfile;
+const path_1 = __importDefault(require("path"));
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const en_1 = require("../lang/en");
+const ui_1 = require("./ui");
+const logger_1 = require("./ui/logger");
+const exitCodes_1 = require("./enums/exitCodes");
+function logProfileHeader(profileName) {
+    (0, ui_1.uiLine)();
+    (0, ui_1.uiBetaTag)(en_1.lib.projectProfiles.logs.usingProfile((0, project_parsing_lib_1.getHsProfileFilename)(profileName)));
+    logger_1.uiLogger.log('');
+}
+function logProfileFooter(profile, includeVariables = false) {
+    logger_1.uiLogger.log(en_1.lib.projectProfiles.logs.profileTargetAccount(profile.accountId));
+    if (includeVariables) {
+        logger_1.uiLogger.log('');
+        logger_1.uiLogger.log(en_1.lib.projectProfiles.logs.profileVariables);
+        Object.entries(profile.variables ?? {}).forEach(([key, value]) => {
+            logger_1.uiLogger.log(`  ${key}: ${value}`);
+        });
+    }
+    (0, ui_1.uiLine)();
+    logger_1.uiLogger.log('');
+}
+function loadProfile(projectConfig, projectDir, profileName) {
+    if (!projectConfig || !projectDir) {
+        logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        return;
+    }
+    const projectSourceDir = path_1.default.join(projectDir, projectConfig.srcDir);
+    const profileFilename = (0, project_parsing_lib_1.getHsProfileFilename)(profileName);
+    try {
+        const profile = (0, project_parsing_lib_1.loadHsProfileFile)(projectSourceDir, profileName);
+        if (!profile) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
+            return;
+        }
+        if (!profile.accountId) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
+            return;
+        }
+        return profile;
+    }
+    catch (e) {
+        logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
+        return;
+    }
+}
+async function exitIfUsingProfiles(projectConfig, projectDir) {
+    if (projectConfig && projectDir) {
+        const existingProfiles = await (0, project_parsing_lib_1.getAllHsProfiles)(path_1.default.join(projectDir, projectConfig.srcDir));
+        if (existingProfiles.length > 0) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+}
+async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
+    if (argsProfile) {
+        logProfileHeader(argsProfile);
+        const profile = loadProfile(projectConfig, projectDir, argsProfile);
+        if (!profile) {
+            (0, ui_1.uiLine)();
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        logProfileFooter(profile, true);
+        return profile.accountId;
+    }
+    else {
+        // A profile must be specified if this project has profiles configured
+        await exitIfUsingProfiles(projectConfig, projectDir);
+    }
+    return undefined;
+}

package/lib/projects/ProjectLogsManager.d.ts

@@ -14,7 +14,7 @@ declare class _ProjectLogsManager {
     init(accountId: number): Promise<void>;
     fetchFunctionDetails(): Promise<void>;
     getFunctionNames(): string[];
-    setFunction(functionName: string): void;
+    setFunction(functionName?: string): void;
 }
 export declare const ProjectLogsManager: _ProjectLogsManager;
 export {};

package/lib/projects/ProjectLogsManager.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectLogsManager = void 0;
-const index_1 = require("./index");
+const config_1 = require("./config");
+const ensureProjectExists_1 = require("./ensureProjectExists");
 const projects_1 = require("@hubspot/local-dev-lib/api/projects");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const lang_1 = require("../lang");
-const ui_1 = require("../ui");
-const i18nKey = 'commands.project.subcommands.logs';
+const logger_1 = require("../ui/logger");
+const en_1 = require("../../lang/en");
 class _ProjectLogsManager {
     projectName;
     projectId;
@@ -32,32 +31,32 @@ class _ProjectLogsManager {
         this.functions = [];
     }
     async init(accountId) {
-        const { projectConfig } = await (0, index_1.getProjectConfig)();
+        const { projectConfig } = await (0, config_1.getProjectConfig)();
         if (!projectConfig || !projectConfig.name) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectConfig`));
+            throw new Error(en_1.commands.project.logs.errors.noProjectConfig);
         }
         const { name: projectName } = projectConfig;
         this.projectName = projectName;
         this.accountId = accountId;
         this.functions = [];
-        const { project } = await (0, index_1.ensureProjectExists)(this.accountId, this.projectName, {
+        const { project } = await (0, ensureProjectExists_1.ensureProjectExists)(this.accountId, this.projectName, {
             allowCreate: false,
         });
         if (!project ||
             !project.deployedBuild ||
             !project.deployedBuild.subbuildStatuses) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchProjectDetails`));
+            throw new Error(en_1.commands.project.logs.errors.failedToFetchProjectDetails);
         }
         this.projectId = project.id;
         await this.fetchFunctionDetails();
     }
     async fetchFunctionDetails() {
         if (!this.projectId) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectConfig`));
+            throw new Error(en_1.commands.project.logs.errors.noProjectConfig);
         }
         if (!this.accountId) {
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errors.projectLogsManagerNotInitialized`));
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.generic`));
+            logger_1.uiLogger.debug(en_1.commands.project.logs.errors.projectLogsManagerNotInitialized);
+            throw new Error(en_1.commands.project.logs.errors.generic);
         }
         const { data: { topLevelComponentMetadata }, } = await (0, projects_1.fetchProjectComponentsMetadata)(this.accountId, this.projectId);
         const apps = topLevelComponentMetadata.filter(componentMetadata => {
@@ -70,27 +69,23 @@ class _ProjectLogsManager {
             ...app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION'));
         });
         if (this.functions.length === 0) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsInProject`, {
-                link: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsLinkText`), 'https://developers.hubspot.com/docs/platform/serverless-functions'),
-            }));
+            throw new Error(en_1.commands.project.logs.errors.noFunctionsInProject);
         }
     }
     getFunctionNames() {
         return this.functions.map(serverlessFunction => serverlessFunction.componentName);
     }
     setFunction(functionName) {
-        if (!(this.functions.length > 0)) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsInProject`, {
-                link: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsLinkText`), 'https://developers.hubspot.com/docs/platform/serverless-functions'),
-            }));
+        if (!functionName || this.functions.length === 0) {
+            throw new Error(en_1.commands.project.logs.errors.noFunctionsInProject);
         }
         this.selectedFunction = this.functions.find(serverlessFunction => serverlessFunction.componentName === functionName);
         if (!this.selectedFunction) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionWithName`, { name: functionName }));
+            throw new Error(en_1.commands.project.logs.errors.noFunctionWithName(functionName));
         }
         this.functionName = functionName;
         if (!this.selectedFunction.deployOutput) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.functionNotDeployed`, { name: functionName }));
+            throw new Error(en_1.commands.project.logs.errors.functionNotDeployed(functionName));
         }
         this.appId = this.selectedFunction.deployOutput.appId;
         if (this.selectedFunction.deployOutput.endpoint) {

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,
+        });
+    }
+}