@hubspot/cli 7.0.0-experimental.1 → 7.0.1-experimental.0

package/lib/projects/buildAndDeploy.js

@@ -0,0 +1,342 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollDeployStatus = exports.pollBuildStatus = void 0;
+exports.displayWarnLogs = displayWarnLogs;
+exports.pollProjectBuildAndDeploy = pollProjectBuildAndDeploy;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const constants_1 = require("../constants");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const lang_1 = require("../lang");
+const errorHandlers_1 = require("../errorHandlers");
+const ui_1 = require("../ui");
+const urls_1 = require("./urls");
+const i18nKey = 'lib.projectBuildAndDeploy';
+const SPINNER_STATUS = {
+    SPINNING: 'spinning',
+};
+function getSubtasks(task) {
+    if ('subbuildStatuses' in task) {
+        return task.subbuildStatuses;
+    }
+    return task.subdeployStatuses;
+}
+function getSubtaskName(task) {
+    if ('buildName' in task) {
+        return task.buildName;
+    }
+    return task.deployName;
+}
+function getSubtaskType(task) {
+    if ('buildType' in task) {
+        return task.buildType;
+    }
+    return task.deployType;
+}
+function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrings, linkToHubSpot, }) {
+    return async function (accountId, taskName, taskId, deployedBuildId = null, silenceLogs = false) {
+        const displayId = deployedBuildId || taskId;
+        if (linkToHubSpot && !silenceLogs) {
+            logger_1.logger.log(`\n${linkToHubSpot(accountId, taskName, taskId, deployedBuildId)}\n`);
+        }
+        SpinniesManager_1.default.init();
+        const overallTaskSpinniesKey = `overallTaskStatus-${statusText.STATUS_TEXT}`;
+        SpinniesManager_1.default.add(overallTaskSpinniesKey, {
+            text: 'Beginning',
+            succeedColor: 'white',
+            failColor: 'white',
+            failPrefix: chalk_1.default.bold('!'),
+        });
+        const [{ data: initialTaskStatus }, { data: { topLevelComponentsWithChildren: taskStructure }, },] = await Promise.all([
+            statusFn(accountId, taskName, taskId),
+            structureFn(accountId, taskName, taskId),
+        ]);
+        const subtasks = getSubtasks(initialTaskStatus);
+        const tasksById = subtasks.reduce((acc, subtask) => {
+            const { id, visible } = subtask;
+            if (visible) {
+                acc[id] = subtask;
+            }
+            return acc;
+        }, {});
+        const structuredTasks = Object.keys(taskStructure).map(key => {
+            return {
+                ...tasksById[key],
+                subtasks: taskStructure[key]
+                    .filter(taskId => Boolean(tasksById[taskId]))
+                    .map(taskId => tasksById[taskId]),
+            };
+        });
+        const numComponents = structuredTasks.length;
+        const componentCountText = silenceLogs
+            ? ''
+            : (0, lang_1.i18n)(numComponents === 1
+                ? `${i18nKey}.makePollTaskStatusFunc.componentCountSingular`
+                : `${i18nKey}.makePollTaskStatusFunc.componentCount`, { numComponents }) + '\n';
+        SpinniesManager_1.default.update(overallTaskSpinniesKey, {
+            text: `${statusStrings.INITIALIZE(taskName, displayId)}\n${componentCountText}`,
+        });
+        if (!silenceLogs) {
+            function addTaskSpinner(subtask, indent, newline) {
+                const taskName = getSubtaskName(subtask);
+                const taskType = getSubtaskType(subtask);
+                const formattedTaskType = constants_1.PROJECT_TASK_TYPES[taskType]
+                    ? `[${constants_1.PROJECT_TASK_TYPES[taskType]}]`
+                    : '';
+                const text = `${indent <= 2 ? statusText.STATUS_TEXT : ''} ${chalk_1.default.bold(taskName)} ${formattedTaskType} ...${newline ? '\n' : ''}`;
+                SpinniesManager_1.default.add(subtask.id, {
+                    text,
+                    indent,
+                    succeedColor: 'white',
+                    failColor: 'white',
+                });
+            }
+            structuredTasks.forEach(task => {
+                addTaskSpinner(task, 2, !task.subtasks || task.subtasks.length === 0);
+                task.subtasks.forEach((subtask, i) => addTaskSpinner(subtask, 4, i === task.subtasks.length - 1));
+            });
+        }
+        return new Promise((resolve, reject) => {
+            const pollInterval = setInterval(async () => {
+                let taskStatus;
+                try {
+                    const { data } = await statusFn(accountId, taskName, taskId);
+                    taskStatus = data;
+                }
+                catch (e) {
+                    logger_1.logger.debug(e);
+                    (0, errorHandlers_1.logError)(e, new errorHandlers_1.ApiErrorContext({
+                        accountId,
+                        projectName: taskName,
+                    }));
+                    return reject(new Error((0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.errorFetchingTaskStatus`, {
+                        taskType: statusText.TYPE_KEY === constants_1.PROJECT_BUILD_TEXT.TYPE_KEY
+                            ? 'build'
+                            : 'deploy',
+                    })));
+                }
+                const subtasks = getSubtasks(taskStatus);
+                if (!taskStatus || !taskStatus.status || !subtasks) {
+                    return reject(new Error((0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.errorFetchingTaskStatus`, {
+                        taskType: statusText.TYPE_KEY === constants_1.PROJECT_BUILD_TEXT.TYPE_KEY
+                            ? 'build'
+                            : 'deploy',
+                    })));
+                }
+                const { status } = taskStatus;
+                if (SpinniesManager_1.default.hasActiveSpinners()) {
+                    subtasks.forEach(subtask => {
+                        const { id, status } = subtask;
+                        const spinner = SpinniesManager_1.default.pick(id);
+                        if (!spinner || spinner.status !== SPINNER_STATUS.SPINNING) {
+                            return;
+                        }
+                        const topLevelTask = structuredTasks.find(t => t.id == id);
+                        if (status === statusText.STATES.SUCCESS ||
+                            status === statusText.STATES.FAILURE) {
+                            const taskStatusText = subtask.status === statusText.STATES.SUCCESS
+                                ? (0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.successStatusText`)
+                                : (0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.failedStatusText`);
+                            const hasNewline = spinner?.text?.includes('\n') || Boolean(topLevelTask);
+                            const updatedText = `${spinner?.text?.replace('\n', '')} ${taskStatusText}${hasNewline ? '\n' : ''}`;
+                            if (status === statusText.STATES.SUCCESS) {
+                                SpinniesManager_1.default.succeed(id, { text: updatedText });
+                            }
+                            else {
+                                SpinniesManager_1.default.fail(id, { text: updatedText });
+                            }
+                            if (topLevelTask) {
+                                topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager_1.default.remove(currentSubtask.id));
+                            }
+                        }
+                    });
+                    if (status === statusText.STATES.SUCCESS) {
+                        SpinniesManager_1.default.succeed(overallTaskSpinniesKey, {
+                            text: statusStrings.SUCCESS(taskName, displayId),
+                        });
+                        clearInterval(pollInterval);
+                        resolve(taskStatus);
+                    }
+                    else if (status === statusText.STATES.FAILURE) {
+                        SpinniesManager_1.default.fail(overallTaskSpinniesKey, {
+                            text: statusStrings.FAIL(taskName, displayId),
+                        });
+                        if (!silenceLogs) {
+                            const failedSubtasks = subtasks.filter(subtask => subtask.status === 'FAILURE');
+                            (0, ui_1.uiLine)();
+                            logger_1.logger.log(`${statusStrings.SUBTASK_FAIL(failedSubtasks.length === 1
+                                ? getSubtaskName(failedSubtasks[0])
+                                : failedSubtasks.length + ' components', displayId)}\n`);
+                            logger_1.logger.log('See below for a summary of errors.');
+                            (0, ui_1.uiLine)();
+                            const displayErrors = failedSubtasks.filter(subtask => subtask?.standardError?.subCategory !==
+                                constants_1.PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
+                                subtask?.standardError?.subCategory !==
+                                    constants_1.PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED);
+                            displayErrors.forEach(subTask => {
+                                logger_1.logger.log(`\n--- ${chalk_1.default.bold(getSubtaskName(subTask))} failed with the following error ---`);
+                                logger_1.logger.error(subTask.errorMessage);
+                                // Log nested errors
+                                if (subTask.standardError && subTask.standardError.errors) {
+                                    logger_1.logger.log();
+                                    subTask.standardError.errors.forEach(error => {
+                                        logger_1.logger.log(error.message);
+                                    });
+                                }
+                            });
+                        }
+                        clearInterval(pollInterval);
+                        resolve(taskStatus);
+                    }
+                    else if (!subtasks.length) {
+                        clearInterval(pollInterval);
+                        resolve(taskStatus);
+                    }
+                }
+            }, constants_1.POLLING_DELAY);
+        });
+    };
+}
+function pollBuildAutodeployStatus(accountId, taskName, buildId) {
+    return new Promise((resolve, reject) => {
+        let maxIntervals = (30 * 1000) / constants_1.POLLING_DELAY; // Num of intervals in ~30s
+        const pollInterval = setInterval(async () => {
+            let build;
+            try {
+                const response = await (0, projects_1.getBuildStatus)(accountId, taskName, buildId);
+                build = response.data;
+            }
+            catch (e) {
+                logger_1.logger.debug(e);
+                return reject(new Error((0, lang_1.i18n)(`${i18nKey}.pollBuildAutodeployStatusError`, { buildId })));
+            }
+            if (!build || !build.status) {
+                return reject(new Error((0, lang_1.i18n)(`${i18nKey}.pollBuildAutodeployStatusError`, { buildId })));
+            }
+            if (build.deployStatusTaskLocator || maxIntervals <= 0) {
+                clearInterval(pollInterval);
+                resolve(build);
+            }
+            else {
+                maxIntervals -= 1;
+            }
+        }, constants_1.POLLING_DELAY);
+    });
+}
+exports.pollBuildStatus = makePollTaskStatusFunc({
+    linkToHubSpot: (accountId, taskName, taskId) => (0, ui_1.uiLink)(`View build #${taskId} in HubSpot`, (0, urls_1.getProjectBuildDetailUrl)(taskName, taskId, accountId)),
+    statusFn: projects_1.getBuildStatus,
+    structureFn: projects_1.getBuildStructure,
+    statusText: constants_1.PROJECT_BUILD_TEXT,
+    statusStrings: {
+        INITIALIZE: (name, buildId) => `Building ${chalk_1.default.bold(name)} #${buildId}`,
+        SUCCESS: (name, buildId) => `Built ${chalk_1.default.bold(name)} #${buildId}`,
+        FAIL: (name, buildId) => `Failed to build ${chalk_1.default.bold(name)} #${buildId}`,
+        SUBTASK_FAIL: (buildId, name) => `Build #${buildId} failed because there was a problem\nbuilding ${chalk_1.default.bold(name)}`,
+    },
+});
+exports.pollDeployStatus = makePollTaskStatusFunc({
+    linkToHubSpot: (accountId, taskName, taskId, deployedBuildId) => (0, ui_1.uiLink)(`View deploy of build #${deployedBuildId} in HubSpot`, (0, urls_1.getProjectDeployDetailUrl)(taskName, taskId, accountId)),
+    statusFn: projects_1.getDeployStatus,
+    structureFn: projects_1.getDeployStructure,
+    statusText: constants_1.PROJECT_DEPLOY_TEXT,
+    statusStrings: {
+        INITIALIZE: (name, buildId) => `Deploying build #${buildId} in ${chalk_1.default.bold(name)}`,
+        SUCCESS: (name, buildId) => `Deployed build #${buildId} in ${chalk_1.default.bold(name)}`,
+        FAIL: (name, buildId) => `Failed to deploy build #${buildId} in ${chalk_1.default.bold(name)}`,
+        SUBTASK_FAIL: (deployedBuildId, name) => `Deploy for build #${deployedBuildId} failed because there was a\nproblem deploying ${chalk_1.default.bold(name)}`,
+    },
+});
+async function displayWarnLogs(accountId, projectName, taskId, isDeploy = false) {
+    let result;
+    if (isDeploy) {
+        try {
+            const { data } = await (0, projects_1.fetchDeployWarnLogs)(accountId, projectName, taskId);
+            result = data;
+        }
+        catch (e) {
+            (0, errorHandlers_1.logError)(e);
+        }
+    }
+    else {
+        try {
+            const { data } = await (0, projects_1.fetchBuildWarnLogs)(accountId, projectName, taskId);
+            result = data;
+        }
+        catch (e) {
+            (0, errorHandlers_1.logError)(e);
+        }
+    }
+    if (result && result.logs) {
+        const logLength = result.logs.length;
+        result.logs.forEach((log, i) => {
+            logger_1.logger.warn(log.message);
+            if (i < logLength - 1) {
+                logger_1.logger.log('');
+            }
+        });
+    }
+}
+async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, silenceLogs = false) {
+    let buildStatus = await (0, exports.pollBuildStatus)(accountId, projectConfig.name, buildId, null, silenceLogs);
+    if (!silenceLogs) {
+        (0, ui_1.uiLine)();
+    }
+    const result = {
+        succeeded: true,
+        buildId,
+        buildResult: buildStatus,
+        deployResult: null,
+    };
+    if (buildStatus.status === 'FAILURE') {
+        result.succeeded = false;
+        return result;
+    }
+    else if (buildStatus.isAutoDeployEnabled) {
+        if (!silenceLogs) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.buildSucceededAutomaticallyDeploying`, {
+                accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+                buildId,
+            }));
+            await displayWarnLogs(accountId, projectConfig.name, buildId);
+        }
+        // autoDeployId of 0 indicates a skipped deploy
+        const getIsDeploying = () => buildStatus.autoDeployId > 0 && buildStatus.deployStatusTaskLocator;
+        // Sometimes the deploys do not immediately initiate, give them a chance to kick off
+        if (!getIsDeploying()) {
+            buildStatus = await pollBuildAutodeployStatus(accountId, projectConfig.name, buildId);
+        }
+        if (getIsDeploying()) {
+            const deployStatus = await (0, exports.pollDeployStatus)(accountId, projectConfig.name, Number(buildStatus.deployStatusTaskLocator.id), buildId, silenceLogs);
+            result.deployResult = deployStatus;
+            if (deployStatus.status === 'FAILURE') {
+                result.succeeded = false;
+            }
+        }
+        else if (!silenceLogs) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.unableToFindAutodeployStatus`, {
+                buildId,
+                viewDeploysLink: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.viewDeploys`), (0, urls_1.getProjectActivityUrl)(projectConfig.name, accountId)),
+            }));
+        }
+    }
+    try {
+        if (tempFile) {
+            tempFile.removeCallback();
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.cleanedUpTempFile`, {
+                path: tempFile.name,
+            }));
+        }
+    }
+    catch (e) {
+        logger_1.logger.error(e);
+    }
+    if (result && result.deployResult) {
+        await displayWarnLogs(accountId, projectConfig.name, result.deployResult.deployId, true);
+    }
+    return result;
+}

package/lib/projects/index.d.ts

@@ -0,0 +1,24 @@
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import { ProjectTemplate, ProjectConfig, ProjectAddComponentData, ComponentTemplate } from '../../types/Projects';
+export declare function writeProjectConfig(configPath: string, config: ProjectConfig): boolean;
+export declare function getIsInProject(dir?: string): boolean;
+export declare function getProjectConfig(dir?: string): Promise<{
+    projectDir: string | null;
+    projectConfig: ProjectConfig | null;
+}>;
+export declare function createProjectConfig(projectPath: string, projectName: string, template: ProjectTemplate, templateSource: RepoPath, githubRef: string): Promise<boolean>;
+export declare function validateProjectConfig(projectConfig: ProjectConfig, projectDir: string): void;
+export declare function ensureProjectExists(accountId: number, projectName: string, { forceCreate, allowCreate, noLogs, withPolling, uploadCommand, }?: {
+    forceCreate?: boolean | undefined;
+    allowCreate?: boolean | undefined;
+    noLogs?: boolean | undefined;
+    withPolling?: boolean | undefined;
+    uploadCommand?: boolean | undefined;
+}): Promise<{
+    projectExists: boolean;
+    project?: Project;
+}>;
+export declare function logFeedbackMessage(buildId: number): void;
+export declare function createProjectComponent(component: ProjectAddComponentData, name: string, projectComponentsVersion: string): Promise<void>;
+export declare function getProjectComponentsByVersion(projectComponentsVersion: string): Promise<ComponentTemplate[]>;

package/lib/projects/index.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeProjectConfig = writeProjectConfig;
+exports.getIsInProject = getIsInProject;
+exports.getProjectConfig = getProjectConfig;
+exports.createProjectConfig = createProjectConfig;
+exports.validateProjectConfig = validateProjectConfig;
+exports.ensureProjectExists = ensureProjectExists;
+exports.logFeedbackMessage = logFeedbackMessage;
+exports.createProjectComponent = createProjectComponent;
+exports.getProjectComponentsByVersion = getProjectComponentsByVersion;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const path_2 = require("@hubspot/local-dev-lib/path");
+const github_2 = require("@hubspot/local-dev-lib/github");
+const constants_1 = require("../constants");
+const promptUtils_1 = require("../prompts/promptUtils");
+const exitCodes_1 = require("../enums/exitCodes");
+const ui_1 = require("../ui");
+const lang_1 = require("../lang");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const index_2 = require("../errorHandlers/index");
+const i18nKey = 'lib.projects';
+function writeProjectConfig(configPath, config) {
+    try {
+        fs_extra_1.default.ensureFileSync(configPath);
+        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        logger_1.logger.debug(`Wrote project config at ${configPath}`);
+    }
+    catch (e) {
+        logger_1.logger.debug(e);
+        return false;
+    }
+    return true;
+}
+function getIsInProject(dir) {
+    const configPath = getProjectConfigPath(dir);
+    return !!configPath;
+}
+function getProjectConfigPath(dir) {
+    const projectDir = dir ? (0, path_2.getAbsoluteFilePath)(dir) : (0, path_2.getCwd)();
+    const configPath = (0, findup_sync_1.default)(constants_1.PROJECT_CONFIG_FILE, {
+        cwd: projectDir,
+        nocase: true,
+    });
+    return configPath;
+}
+async function getProjectConfig(dir) {
+    const configPath = await getProjectConfigPath(dir);
+    if (!configPath) {
+        return { projectConfig: null, projectDir: null };
+    }
+    try {
+        const config = fs_extra_1.default.readFileSync(configPath);
+        const projectConfig = JSON.parse(config.toString());
+        return {
+            projectDir: path_1.default.dirname(configPath),
+            projectConfig,
+        };
+    }
+    catch (e) {
+        logger_1.logger.error('Could not read from project config');
+        return { projectConfig: null, projectDir: null };
+    }
+}
+async function createProjectConfig(projectPath, projectName, template, templateSource, githubRef) {
+    const { projectConfig, projectDir } = await getProjectConfig(projectPath);
+    if (projectConfig) {
+        logger_1.logger.warn(projectPath === projectDir
+            ? 'A project already exists in that location.'
+            : `Found an existing project definition in ${projectDir}.`);
+        const { shouldContinue } = await (0, promptUtils_1.promptUser)([
+            {
+                name: 'shouldContinue',
+                message: () => {
+                    return projectPath === projectDir
+                        ? 'Do you want to overwrite the existing project definition with a new one?'
+                        : `Continue creating a new project in ${projectPath}?`;
+                },
+                type: 'confirm',
+                default: false,
+            },
+        ]);
+        if (!shouldContinue) {
+            return false;
+        }
+    }
+    const projectConfigPath = path_1.default.join(projectPath, constants_1.PROJECT_CONFIG_FILE);
+    logger_1.logger.log(`Creating project config in ${projectPath ? projectPath : 'the current folder'}`);
+    const hasCustomTemplateSource = Boolean(templateSource);
+    await (0, github_2.downloadGithubRepoContents)(templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, template.path, projectPath, hasCustomTemplateSource ? undefined : githubRef);
+    const _config = JSON.parse(fs_extra_1.default.readFileSync(projectConfigPath).toString());
+    writeProjectConfig(projectConfigPath, {
+        ..._config,
+        name: projectName,
+    });
+    if (template.name === 'no-template') {
+        fs_extra_1.default.ensureDirSync(path_1.default.join(projectPath, 'src'));
+    }
+    return true;
+}
+function validateProjectConfig(projectConfig, projectDir) {
+    if (!projectConfig) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.configNotFound`, {
+            createCommand: (0, ui_1.uiCommandReference)('hs project create'),
+        }));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    if (!projectConfig.name || !projectConfig.srcDir) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.configMissingFields`));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const resolvedPath = path_1.default.resolve(projectDir, projectConfig.srcDir);
+    if (!resolvedPath.startsWith(projectDir)) {
+        const projectConfigFile = path_1.default.relative('.', path_1.default.join(projectDir, constants_1.PROJECT_CONFIG_FILE));
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.srcOutsideProjectDir`, {
+            srcDir: projectConfig.srcDir,
+            projectConfig: projectConfigFile,
+        }));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    if (!fs_extra_1.default.existsSync(resolvedPath)) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.srcDirNotFound`, {
+            srcDir: projectConfig.srcDir,
+            projectDir: projectDir,
+        }));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+}
+async function pollFetchProject(accountId, projectName) {
+    // Temporary solution for gating slowness. Retry on 403 statusCode
+    return new Promise((resolve, reject) => {
+        let pollCount = 0;
+        SpinniesManager_1.default.init();
+        SpinniesManager_1.default.add('pollFetchProject', {
+            text: (0, lang_1.i18n)(`${i18nKey}.pollFetchProject.checkingProject`, {
+                accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+            }),
+        });
+        const pollInterval = setInterval(async () => {
+            try {
+                const response = await (0, projects_1.fetchProject)(accountId, projectName);
+                if (response && response.data) {
+                    SpinniesManager_1.default.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    resolve(response);
+                }
+            }
+            catch (err) {
+                if ((0, index_1.isSpecifiedError)(err, {
+                    statusCode: 403,
+                    category: 'GATED',
+                    subCategory: 'BuildPipelineErrorType.PORTAL_GATED',
+                }) &&
+                    pollCount < 15) {
+                    pollCount += 1;
+                }
+                else {
+                    SpinniesManager_1.default.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    reject(err);
+                }
+            }
+        }, constants_1.POLLING_DELAY);
+    });
+}
+async function ensureProjectExists(accountId, projectName, { forceCreate = false, allowCreate = true, noLogs = false, withPolling = false, uploadCommand = false, } = {}) {
+    const accountIdentifier = (0, ui_1.uiAccountDescription)(accountId);
+    try {
+        const { data: project } = withPolling
+            ? await pollFetchProject(accountId, projectName)
+            : await (0, projects_1.fetchProject)(accountId, projectName);
+        return { projectExists: !!project, project };
+    }
+    catch (err) {
+        if ((0, index_1.isSpecifiedError)(err, { statusCode: 404 })) {
+            let shouldCreateProject = forceCreate;
+            if (allowCreate && !shouldCreateProject) {
+                const promptKey = uploadCommand ? 'createPromptUpload' : 'createPrompt';
+                const promptResult = await (0, promptUtils_1.promptUser)([
+                    {
+                        name: 'shouldCreateProject',
+                        message: (0, lang_1.i18n)(`${i18nKey}.ensureProjectExists.${promptKey}`, {
+                            projectName,
+                            accountIdentifier,
+                        }),
+                        type: 'confirm',
+                    },
+                ]);
+                shouldCreateProject = promptResult.shouldCreateProject;
+            }
+            if (shouldCreateProject) {
+                try {
+                    const { data: project } = await (0, projects_1.createProject)(accountId, projectName);
+                    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.ensureProjectExists.createSuccess`, {
+                        projectName,
+                        accountIdentifier,
+                    }));
+                    return { projectExists: true, project };
+                }
+                catch (err) {
+                    (0, index_2.logError)(err, new index_2.ApiErrorContext({ accountId }));
+                    return { projectExists: false };
+                }
+            }
+            else {
+                if (!noLogs) {
+                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.ensureProjectExists.notFound`, {
+                        projectName,
+                        accountIdentifier,
+                    }));
+                }
+                return { projectExists: false };
+            }
+        }
+        if ((0, index_1.isSpecifiedError)(err, {
+            statusCode: 401,
+        })) {
+            logger_1.logger.error(err.message);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        (0, index_2.logError)(err, new index_2.ApiErrorContext({ accountId }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+}
+function logFeedbackMessage(buildId) {
+    if (buildId > 0 && buildId % constants_1.FEEDBACK_INTERVAL === 0) {
+        (0, ui_1.uiLine)();
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logFeedbackMessage.feedbackHeader`));
+        (0, ui_1.uiLine)();
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logFeedbackMessage.feedbackMessage`));
+    }
+}
+async function createProjectComponent(component, name, projectComponentsVersion) {
+    const i18nKey = 'commands.project.subcommands.add';
+    const componentName = name;
+    const configInfo = await getProjectConfig();
+    if (!configInfo.projectDir || !configInfo.projectConfig) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.error.locationInProject`));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const componentPath = path_1.default.join(configInfo.projectDir, configInfo.projectConfig.srcDir, component.insertPath, componentName);
+    await (0, github_2.downloadGithubRepoContents)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, component.path, componentPath, projectComponentsVersion);
+}
+async function getProjectComponentsByVersion(projectComponentsVersion) {
+    const config = await (0, github_1.fetchFileFromRepository)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', projectComponentsVersion);
+    return config[constants_1.PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
+}