@hubspot/cli 7.0.0-experimental.0 → 7.0.0-experimental.2

package/lib/oauth.js

@@ -1,39 +1,53 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const express = require('express');
-const open = require('open');
-const { OAuth2Manager, } = require('@hubspot/local-dev-lib/models/OAuth2Manager');
-const { getAccountConfig } = require('@hubspot/local-dev-lib/config');
-const { getAccountIdentifier, } = require('@hubspot/local-dev-lib/config/getAccountIdentifier');
-const { addOauthToAccountConfig } = require('@hubspot/local-dev-lib/oauth');
-const { handleExit } = require('./process');
-const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { ENVIRONMENTS, } = require('@hubspot/local-dev-lib/constants/environments');
+exports.authenticateWithOauth = authenticateWithOauth;
+const express_1 = __importDefault(require("express"));
+const open_1 = __importDefault(require("open"));
+const OAuth2Manager_1 = require("@hubspot/local-dev-lib/models/OAuth2Manager");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
+const oauth_1 = require("@hubspot/local-dev-lib/oauth");
+const urls_1 = require("@hubspot/local-dev-lib/urls");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const process_1 = require("./process");
+const lang_1 = require("./lang");
+const exitCodes_1 = require("./enums/exitCodes");
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
-const buildAuthUrl = oauthManager => {
-    return (`${getHubSpotWebsiteOrigin(oauthManager.account.env)}/oauth/${oauthManager.account.accountId}/authorize` +
-        `?client_id=${encodeURIComponent(oauthManager.account.clientId)}` + // app's client ID
-        `&scope=${encodeURIComponent(oauthManager.account.scopes.join(' '))}` + // scopes being requested by the app
+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`));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    return (`${(0, urls_1.getHubSpotWebsiteOrigin)(env)}/oauth/${oauthManager.account.accountId}/authorize` +
+        `?client_id=${encodeURIComponent(clientId)}` + // app's client ID
+        `&scope=${encodeURIComponent(scopes.join(' '))}` + // scopes being requested by the app
         `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
     );
-};
-const handleServerOnProcessEnd = server => {
+}
+function handleServerOnProcessEnd(server) {
     const shutdownServerIfRunning = () => {
         server?.close();
     };
-    handleExit(shutdownServerIfRunning);
-};
-const authorize = async (oauthManager) => {
+    (0, process_1.handleExit)(shutdownServerIfRunning);
+}
+async function authorize(oauthManager) {
     if (process.env.BROWSER !== 'none') {
-        open(buildAuthUrl(oauthManager), { url: true });
+        (0, open_1.default)(buildAuthUrl(oauthManager), { url: true });
     }
     // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
         let server;
-        const app = express();
+        const app = (0, express_1.default)();
         app.get('/oauth-callback', async (req, res) => {
             if (req.query.code) {
                 const authCodeProof = {
@@ -70,25 +84,21 @@ const authorize = async (oauthManager) => {
                 reject();
             }
         });
-        server = app.listen(PORT, () => logger.log(`Waiting for authorization...`));
+        server = app.listen(PORT, () => logger_1.logger.log(`Waiting for authorization...`));
         handleServerOnProcessEnd(server);
     });
-};
-const setupOauth = accountConfig => {
-    const id = getAccountIdentifier(accountConfig);
-    const accountId = parseInt(id, 10);
-    const config = getAccountConfig(accountId) || {};
-    return new OAuth2Manager({
+}
+function setupOauth(accountConfig) {
+    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig);
+    const config = (0, config_1.getAccountConfig)(accountId);
+    return new OAuth2Manager_1.OAuth2Manager({
         ...accountConfig,
-        environment: accountConfig.env || config.env || ENVIRONMENTS.PROD,
+        env: accountConfig.env || config?.env || environments_1.ENVIRONMENTS.PROD,
     });
-};
-const authenticateWithOauth = async (configData) => {
-    const oauthManager = setupOauth(configData);
-    logger.log('Authorizing');
+}
+async function authenticateWithOauth(accountConfig) {
+    const oauthManager = setupOauth(accountConfig);
+    logger_1.logger.log('Authorizing');
     await authorize(oauthManager);
-    addOauthToAccountConfig(oauthManager);
-};
-module.exports = {
-    authenticateWithOauth,
-};
+    (0, oauth_1.addOauthToAccountConfig)(oauthManager);
+}

package/lib/polling.d.ts

@@ -1 +1,9 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
+import { POLLING_STATUS } from './constants';
+type GenericPollingResponse = {
+    status: ValueOf<typeof POLLING_STATUS>;
+};
+type PollingCallback<T extends GenericPollingResponse> = (accountId: number, taskId: number | string) => HubSpotPromise<T>;
+export declare function poll<T extends GenericPollingResponse>(callback: PollingCallback<T>, accountId: number, taskId: number | string): Promise<T>;
 export {};

package/lib/polling.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const { POLLING_DELAY, POLLING_STATUS } = require('./constants');
-const poll = (callback, accountId, taskId) => {
+exports.poll = poll;
+const constants_1 = require("./constants");
+function poll(callback, accountId, taskId) {
     return new Promise((resolve, reject) => {
         const pollInterval = setInterval(async () => {
             try {
                 const { data: pollResp } = await callback(accountId, taskId);
                 const { status } = pollResp;
-                if (status === POLLING_STATUS.SUCCESS) {
+                if (status === constants_1.POLLING_STATUS.SUCCESS) {
                     clearInterval(pollInterval);
                     resolve(pollResp);
                 }
-                else if (status === POLLING_STATUS.ERROR ||
-                    status === POLLING_STATUS.REVERTED ||
-                    status === POLLING_STATUS.FAILURE) {
+                else if (status === constants_1.POLLING_STATUS.ERROR ||
+                    status === constants_1.POLLING_STATUS.REVERTED ||
+                    status === constants_1.POLLING_STATUS.FAILURE) {
                     clearInterval(pollInterval);
                     reject(pollResp);
                 }
@@ -23,9 +23,6 @@ const poll = (callback, accountId, taskId) => {
                 clearInterval(pollInterval);
                 reject(error);
             }
-        }, POLLING_DELAY);
+        }, constants_1.POLLING_DELAY);
     });
-};
-module.exports = {
-    poll,
-};
+}

package/lib/projects/ProjectLogsManager.d.ts

@@ -0,0 +1,20 @@
+import { AppFunctionComponentMetadata } from '@hubspot/local-dev-lib/types/ComponentStructure';
+declare class _ProjectLogsManager {
+    projectName: string | undefined;
+    projectId: number | undefined;
+    accountId: number | undefined;
+    functions: AppFunctionComponentMetadata[];
+    selectedFunction: AppFunctionComponentMetadata | undefined;
+    functionName: string | undefined;
+    appId: number | undefined;
+    isPublicFunction: boolean | undefined;
+    endpointName: string | undefined;
+    reset(): void;
+    constructor();
+    init(accountId: number): Promise<void>;
+    fetchFunctionDetails(): Promise<void>;
+    getFunctionNames(): string[];
+    setFunction(functionName: string): void;
+}
+export declare const ProjectLogsManager: _ProjectLogsManager;
+export {};

package/lib/projects/ProjectLogsManager.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectLogsManager = void 0;
+const index_1 = require("./index");
+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';
+class _ProjectLogsManager {
+    projectName;
+    projectId;
+    accountId;
+    functions;
+    selectedFunction;
+    functionName;
+    appId;
+    isPublicFunction;
+    endpointName;
+    reset() {
+        this.projectName = undefined;
+        this.projectId = undefined;
+        this.accountId = undefined;
+        this.functions = [];
+        this.selectedFunction = undefined;
+        this.functionName = undefined;
+        this.appId = undefined;
+        this.isPublicFunction = undefined;
+        this.endpointName = undefined;
+    }
+    constructor() {
+        this.functions = [];
+    }
+    async init(accountId) {
+        const { projectConfig } = await (0, index_1.getProjectConfig)();
+        if (!projectConfig || !projectConfig.name) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.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, {
+            allowCreate: false,
+        });
+        if (!project ||
+            !project.deployedBuild ||
+            !project.deployedBuild.subbuildStatuses) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchProjectDetails`));
+        }
+        this.projectId = project.id;
+        await this.fetchFunctionDetails();
+    }
+    async fetchFunctionDetails() {
+        if (!this.projectId) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.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`));
+        }
+        const { data: { topLevelComponentMetadata }, } = await (0, projects_1.fetchProjectComponentsMetadata)(this.accountId, this.projectId);
+        const apps = topLevelComponentMetadata.filter(componentMetadata => {
+            const { type } = componentMetadata;
+            return type && type.name === 'PRIVATE_APP';
+        });
+        apps.forEach(app => {
+            this.functions.push(
+            // If component type is APP_FUNCTION, we can safely cast as AppFunctionComponentMetadata
+            ...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'),
+            }));
+        }
+    }
+    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'),
+            }));
+        }
+        this.selectedFunction = this.functions.find(serverlessFunction => serverlessFunction.componentName === functionName);
+        if (!this.selectedFunction) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionWithName`, { name: functionName }));
+        }
+        this.functionName = functionName;
+        if (!this.selectedFunction.deployOutput) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.functionNotDeployed`, { name: functionName }));
+        }
+        this.appId = this.selectedFunction.deployOutput.appId;
+        if (this.selectedFunction.deployOutput.endpoint) {
+            this.endpointName = this.selectedFunction.deployOutput.endpoint.path;
+            this.isPublicFunction = true;
+        }
+        else {
+            this.isPublicFunction = false;
+        }
+    }
+}
+exports.ProjectLogsManager = new _ProjectLogsManager();

package/lib/projects/buildAndDeploy.d.ts

@@ -0,0 +1,16 @@
+import { FileResult } from 'tmp';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
+import { ProjectConfig, ProjectTask } from '../../types/Projects';
+type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskName: string, taskId: number, deployedBuildId: number | null, silenceLogs: boolean) => Promise<T>;
+export declare const pollBuildStatus: PollTaskStatusFunction<Build>;
+export declare const pollDeployStatus: PollTaskStatusFunction<Deploy>;
+type ProjectPollResult = {
+    succeeded: boolean;
+    buildId: number;
+    buildResult: Build;
+    deployResult: Deploy | null;
+};
+export declare function displayWarnLogs(accountId: number, projectName: string, taskId: number, isDeploy?: boolean): Promise<void>;
+export declare function pollProjectBuildAndDeploy(accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number, silenceLogs?: boolean): Promise<ProjectPollResult>;
+export {};

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