@hubspot/cli 7.7.0-experimental.3 → 7.7.0

package/lib/projects/localDev/helpers/project.js

@@ -0,0 +1,176 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { createProject } from '@hubspot/local-dev-lib/api/projects';
+import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
+import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
+import { sanitizeFileName } from '@hubspot/local-dev-lib/path';
+import { isDeepEqual } from '@hubspot/local-dev-lib/isDeepEqual';
+import { translate } from '@hubspot/project-parsing-lib';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } from '../../../constants.js';
+import { lib } from '../../../../lang/en.js';
+import { uiLogger } from '../../../ui/logger.js';
+import { uiLine } from '../../../ui/index.js';
+import { confirmPrompt } from '../../../prompts/promptUtils.js';
+import { uiAccountDescription } from '../../../ui/index.js';
+import SpinniesManager from '../../../ui/SpinniesManager.js';
+import { EXIT_CODES } from '../../../enums/exitCodes.js';
+import { handleProjectUpload } from '../../upload.js';
+import { pollProjectBuildAndDeploy } from '../../pollProjectBuildAndDeploy.js';
+import { debugError, logError } from '../../../errorHandlers/index.js';
+import { ApiErrorContext } from '../../../errorHandlers/index.js';
+// Prompt the user to create a new project if one doesn't exist on their target account
+export async function createNewProjectForLocalDev(projectConfig, targetAccountId, shouldCreateWithoutConfirmation, hasPublicApps) {
+    // Create the project without prompting if this is a newly created sandbox
+    let shouldCreateProject = shouldCreateWithoutConfirmation;
+    if (!shouldCreateProject) {
+        const explanationLangFunction = hasPublicApps
+            ? lib.localDevHelpers.project.createNewProjectForLocalDev
+                .publicAppProjectMustExistExplanation
+            : lib.localDevHelpers.project.createNewProjectForLocalDev
+                .projectMustExistExplanation;
+        const explanationString = explanationLangFunction(projectConfig.name, targetAccountId);
+        uiLogger.log('');
+        uiLine();
+        uiLogger.log(explanationString);
+        uiLine();
+        shouldCreateProject = await confirmPrompt(lib.localDevHelpers.project.createNewProjectForLocalDev.createProject(projectConfig.name, uiAccountDescription(targetAccountId)));
+    }
+    if (shouldCreateProject) {
+        SpinniesManager.add('createProject', {
+            text: lib.localDevHelpers.project.createNewProjectForLocalDev.creatingProject(projectConfig.name, uiAccountDescription(targetAccountId)),
+        });
+        try {
+            const { data: project } = await createProject(targetAccountId, projectConfig.name);
+            SpinniesManager.succeed('createProject', {
+                text: lib.localDevHelpers.project.createNewProjectForLocalDev.createdProject(projectConfig.name, uiAccountDescription(targetAccountId)),
+                succeedColor: 'white',
+            });
+            return project;
+        }
+        catch (err) {
+            SpinniesManager.fail('createProject');
+            uiLogger.log(lib.localDevHelpers.project.createNewProjectForLocalDev
+                .failedToCreateProject);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        // We cannot continue if the project does not exist in the target account
+        uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.project.createNewProjectForLocalDev
+            .choseNotToCreateProject);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
+    if (!buildId) {
+        uiLogger.error(lib.localDevHelpers.project.createInitialBuildForNewProject.genericError);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    return pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, true);
+}
+// Create an initial build if the project was newly created in the account
+// Return the newly deployed build
+export async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
+    const { result: initialUploadResult, uploadError } = await handleProjectUpload({
+        accountId: targetAccountId,
+        projectConfig,
+        projectDir,
+        callbackFunc: projectUploadCallback,
+        uploadMessage: lib.localDevHelpers.project.createInitialBuildForNewProject
+            .initialUploadMessage,
+        forceCreate: true,
+        skipValidation: true,
+        sendIR,
+        profile,
+    });
+    if (uploadError) {
+        if (isSpecifiedError(uploadError, {
+            subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
+        })) {
+            uiLogger.log('');
+            uiLogger.error(lib.localDevHelpers.project.createInitialBuildForNewProject
+                .projectLockedError);
+            uiLogger.log('');
+        }
+        else {
+            logError(uploadError, new ApiErrorContext({
+                accountId: targetAccountId,
+                projectName: projectConfig.name,
+            }));
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (!initialUploadResult?.succeeded) {
+        let subTasks = [];
+        if (initialUploadResult?.buildResult.status === 'FAILURE') {
+            subTasks =
+                initialUploadResult.buildResult[PROJECT_BUILD_TEXT.SUBTASK_KEY];
+        }
+        else if (initialUploadResult?.deployResult?.status === 'FAILURE') {
+            subTasks =
+                initialUploadResult.deployResult[PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
+        }
+        const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
+        uiLogger.log('');
+        failedSubTasks.forEach(failedSubTask => {
+            uiLogger.error(failedSubTask.errorMessage);
+        });
+        uiLogger.log('');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    return initialUploadResult.buildResult;
+}
+export async function compareLocalProjectToDeployed(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+    uiLogger.log('');
+    if (!deployedBuildId) {
+        uiLogger.error(lib.localDevHelpers.project.compareLocalProjectToDeployed.noDeployedBuild(projectConfig.name, uiAccountDescription(accountId)));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    SpinniesManager.add('compareLocalProjectToDeployed', {
+        text: lib.localDevHelpers.project.compareLocalProjectToDeployed.checking,
+    });
+    const isUpToDate = await isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile);
+    if (isUpToDate) {
+        SpinniesManager.succeed('compareLocalProjectToDeployed', {
+            text: lib.localDevHelpers.project.compareLocalProjectToDeployed.upToDate,
+        });
+    }
+    else {
+        SpinniesManager.fail('compareLocalProjectToDeployed', {
+            text: lib.localDevHelpers.project.compareLocalProjectToDeployed
+                .notUpToDate,
+        });
+        uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed.notUpToDateExplanation(profile));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+    let tempDir = null;
+    try {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hubspot-project-compare-'));
+        const { data: zippedProject } = await downloadProject(accountId, projectConfig.name, deployedBuildId);
+        const extractedProjectPath = path.join(tempDir, sanitizeFileName(projectConfig.name));
+        await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { includesRootDir: false, hideLogs: true });
+        const deployedProjectSourceDir = path.join(extractedProjectPath, projectConfig.srcDir);
+        const { intermediateNodesIndexedByUid: deployedProjectNodes } = await translate({
+            projectSourceDir: deployedProjectSourceDir,
+            platformVersion: projectConfig.platformVersion,
+            accountId: accountId,
+        }, { profile });
+        return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
+    }
+    catch (err) {
+        debugError(err);
+        return false;
+    }
+    finally {
+        // Clean up temporary directory
+        if (tempDir && (await fs.pathExists(tempDir))) {
+            await fs.remove(tempDir);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { LocalDevDeployWebsocketMessage, LocalDevWebsocketMessage } from '../../../types/LocalDev.js';
+export declare function isUploadWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isDeployWebsocketMessage(message: LocalDevWebsocketMessage): message is LocalDevDeployWebsocketMessage;
+export declare function isViewedWelcomeScreenWebsocketMessage(message: LocalDevWebsocketMessage): boolean;

package/lib/projects/localDev/localDevWebsocketServerUtils.js

@@ -0,0 +1,10 @@
+import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES } from '../../constants.js';
+export function isUploadWebsocketMessage(message) {
+    return message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD;
+}
+export function isDeployWebsocketMessage(message) {
+    return message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.DEPLOY;
+}
+export function isViewedWelcomeScreenWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.VIEWED_WELCOME_SCREEN);
+}

package/lib/projects/platformVersion.d.ts

@@ -0,0 +1 @@
+export declare function useV3Api(platformVersion?: string | null): boolean;

package/lib/projects/platformVersion.js

@@ -0,0 +1,10 @@
+export function useV3Api(platformVersion) {
+    if (!platformVersion || typeof platformVersion !== 'string') {
+        return false;
+    }
+    if (platformVersion.toLowerCase() === 'unstable') {
+        return true;
+    }
+    const [year, minor] = platformVersion.split('.');
+    return Number(year) >= 2025 && Number(minor) >= 2;
+}

package/lib/projects/{buildAndDeploy.d.ts → pollProjectBuildAndDeploy.d.ts}

@@ -1,8 +1,7 @@
 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, ProjectPollResult } from '../../types/Projects';
-export declare function useV3Api(platformVersion?: string | null): boolean;
+import { ProjectConfig, ProjectTask, ProjectPollResult } from '../../types/Projects.js';
 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>;

package/lib/projects/{buildAndDeploy.js → pollProjectBuildAndDeploy.js}

@@ -1,37 +1,18 @@
-"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.useV3Api = useV3Api;
-exports.displayWarnLogs = displayWarnLogs;
-exports.pollProjectBuildAndDeploy = pollProjectBuildAndDeploy;
-const chalk_1 = __importDefault(require("chalk"));
-const projects_1 = require("@hubspot/local-dev-lib/api/projects");
-const constants_1 = require("../constants");
-const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
-const errorHandlers_1 = require("../errorHandlers");
-const ui_1 = require("../ui");
-const urls_1 = require("./urls");
-const exitCodes_1 = require("../enums/exitCodes");
-const en_1 = require("../../lang/en");
-const logger_1 = require("../ui/logger");
-const constants_2 = require("@hubspot/project-parsing-lib/src/lib/constants");
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+import chalk from 'chalk';
+import { getBuildStatus, getBuildStructure, getDeployStatus, getDeployStructure, fetchBuildWarnLogs, fetchDeployWarnLogs, } from '@hubspot/local-dev-lib/api/projects';
+import { DEFAULT_POLLING_DELAY, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, PROJECT_TASK_TYPES, PROJECT_ERROR_TYPES, } from '../constants.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { uiLine, uiLink, uiAccountDescription } from '../ui/index.js';
+import { getProjectBuildDetailUrl, getProjectDeployDetailUrl, getProjectActivityUrl, } from './urls.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+import { AppFunctionsPackageKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
+import { mapToInternalType } from '@hubspot/project-parsing-lib';
 const SPINNER_STATUS = {
     SPINNING: 'spinning',
 };
-function useV3Api(platformVersion) {
-    if (!platformVersion || typeof platformVersion !== 'string') {
-        return false;
-    }
-    if (platformVersion.toLowerCase() === 'unstable') {
-        return true;
-    }
-    const [year, minor] = platformVersion.split('.');
-    return Number(year) >= 2025 && Number(minor) >= 2;
-}
 function getSubtasks(task) {
     if ('subbuildStatuses' in task) {
         return task.subbuildStatuses;
@@ -51,22 +32,22 @@ function getSubtaskType(task) {
     return task.deployType;
 }
 function handleTaskStatusError(statusText) {
-    logger_1.uiLogger.error(en_1.lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorFetchingTaskStatus(statusText.TYPE_KEY === constants_1.PROJECT_BUILD_TEXT.TYPE_KEY ? 'build' : 'deploy'));
-    process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    uiLogger.error(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorFetchingTaskStatus(statusText.TYPE_KEY === PROJECT_BUILD_TEXT.TYPE_KEY ? 'build' : 'deploy'));
+    process.exit(EXIT_CODES.ERROR);
 }
 function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrings, linkToHubSpot, }) {
     return async function (accountId, taskName, taskId, deployedBuildId, silenceLogs = false) {
         const displayId = deployedBuildId || taskId;
         if (linkToHubSpot && !silenceLogs) {
-            logger_1.uiLogger.log(`\n${linkToHubSpot(accountId, taskName, taskId, deployedBuildId)}\n`);
+            uiLogger.log(`\n${linkToHubSpot(accountId, taskName, taskId, deployedBuildId)}\n`);
         }
-        SpinniesManager_1.default.init();
+        SpinniesManager.init();
         const overallTaskSpinniesKey = `overallTaskStatus-${statusText.STATUS_TEXT}`;
-        SpinniesManager_1.default.add(overallTaskSpinniesKey, {
+        SpinniesManager.add(overallTaskSpinniesKey, {
             text: 'Beginning',
             succeedColor: 'white',
             failColor: 'white',
-            failPrefix: chalk_1.default.bold('!'),
+            failPrefix: chalk.bold('!'),
         });
         const [{ data: initialTaskStatus }, { data: { topLevelComponentsWithChildren: taskStructure }, },] = await Promise.all([
             statusFn(accountId, taskName, taskId),
@@ -77,7 +58,7 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
         const tasksById = subtasks
             .filter(subtask => {
             // TODO: Remove this filtering logic when visible=false for SERVERLESS_PACKAGE
-            const shouldBeVisible = getSubtaskType(subtask) !== (0, project_parsing_lib_1.mapToInternalType)(constants_2.AppFunctionsPackageKey);
+            const shouldBeVisible = getSubtaskType(subtask) !== mapToInternalType(AppFunctionsPackageKey);
             if (!shouldBeVisible) {
                 hiddenComponentBuildIds.push(subtask.id);
             }
@@ -105,21 +86,21 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
         const componentCountText = silenceLogs
             ? ''
             : numComponents === 1
-                ? en_1.lib.projectBuildAndDeploy.makePollTaskStatusFunc
+                ? lib.projectBuildAndDeploy.makePollTaskStatusFunc
                     .componentCountSingular
-                : en_1.lib.projectBuildAndDeploy.makePollTaskStatusFunc.componentCount(numComponents);
-        SpinniesManager_1.default.update(overallTaskSpinniesKey, {
+                : lib.projectBuildAndDeploy.makePollTaskStatusFunc.componentCount(numComponents);
+        SpinniesManager.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 formattedTaskType = PROJECT_TASK_TYPES[taskType]
+                    ? `[${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, {
+                const text = `${indent <= 2 ? statusText.STATUS_TEXT : ''} ${chalk.bold(taskName)} ${formattedTaskType} ...${newline ? '\n' : ''}`;
+                SpinniesManager.add(subtask.id, {
                     text,
                     indent,
                     succeedColor: 'white',
@@ -139,8 +120,8 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
                     taskStatus = data;
                 }
                 catch (e) {
-                    logger_1.uiLogger.debug(e);
-                    (0, errorHandlers_1.logError)(e, new errorHandlers_1.ApiErrorContext({
+                    uiLogger.debug(e);
+                    logError(e, new ApiErrorContext({
                         accountId,
                         projectName: taskName,
                     }));
@@ -151,10 +132,10 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
                     handleTaskStatusError(statusText);
                 }
                 const { status } = taskStatus;
-                if (SpinniesManager_1.default.hasActiveSpinners()) {
+                if (SpinniesManager.hasActiveSpinners()) {
                     subtasks.forEach(subtask => {
                         const { id, status } = subtask;
-                        const spinner = SpinniesManager_1.default.pick(id);
+                        const spinner = SpinniesManager.pick(id);
                         if (!spinner || spinner.status !== SPINNER_STATUS.SPINNING) {
                             return;
                         }
@@ -162,54 +143,54 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
                         if (status === statusText.STATES.SUCCESS ||
                             status === statusText.STATES.FAILURE) {
                             const taskStatusText = subtask.status === statusText.STATES.SUCCESS
-                                ? en_1.lib.projectBuildAndDeploy.makePollTaskStatusFunc
+                                ? lib.projectBuildAndDeploy.makePollTaskStatusFunc
                                     .successStatusText
-                                : en_1.lib.projectBuildAndDeploy.makePollTaskStatusFunc
+                                : lib.projectBuildAndDeploy.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 });
+                                SpinniesManager.succeed(id, { text: updatedText });
                             }
                             else {
-                                SpinniesManager_1.default.fail(id, { text: updatedText });
+                                SpinniesManager.fail(id, { text: updatedText });
                             }
                             if (topLevelTask) {
-                                topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager_1.default.remove(currentSubtask.id));
+                                topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager.remove(currentSubtask.id));
                             }
                         }
                     });
                     if (status === statusText.STATES.SUCCESS) {
-                        SpinniesManager_1.default.succeed(overallTaskSpinniesKey, {
+                        SpinniesManager.succeed(overallTaskSpinniesKey, {
                             text: statusStrings.SUCCESS(taskName, displayId),
                         });
                         clearInterval(pollInterval);
                         resolve(taskStatus);
                     }
                     else if (status === statusText.STATES.FAILURE) {
-                        SpinniesManager_1.default.fail(overallTaskSpinniesKey, {
+                        SpinniesManager.fail(overallTaskSpinniesKey, {
                             text: statusStrings.FAIL(taskName, displayId),
                         });
                         if (!silenceLogs) {
                             const failedSubtasks = subtasks.filter(subtask => subtask.status === 'FAILURE');
-                            (0, ui_1.uiLine)();
-                            logger_1.uiLogger.log(`${statusStrings.SUBTASK_FAIL(failedSubtasks.length === 1
+                            uiLine();
+                            uiLogger.log(`${statusStrings.SUBTASK_FAIL(failedSubtasks.length === 1
                                 ? getSubtaskName(failedSubtasks[0])
                                 : failedSubtasks.length + ' components', displayId)}\n`);
-                            logger_1.uiLogger.log(en_1.lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorSummary);
-                            (0, ui_1.uiLine)();
+                            uiLogger.log(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorSummary);
+                            uiLine();
                             const displayErrors = failedSubtasks.filter(subtask => subtask?.standardError?.subCategory !==
-                                constants_1.PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
+                                PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
                                 subtask?.standardError?.subCategory !==
-                                    constants_1.PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED);
+                                    PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED);
                             displayErrors.forEach(subTask => {
-                                logger_1.uiLogger.log(`\n--- ${chalk_1.default.bold(getSubtaskName(subTask))} failed with the following error ---`);
-                                logger_1.uiLogger.error(subTask.errorMessage);
+                                uiLogger.log(`\n--- ${chalk.bold(getSubtaskName(subTask))} failed with the following error ---`);
+                                uiLogger.error(subTask.errorMessage);
                                 // Log nested errors
                                 if (subTask.standardError && subTask.standardError.errors) {
-                                    logger_1.uiLogger.log('');
+                                    uiLogger.log('');
                                     subTask.standardError.errors.forEach(error => {
-                                        logger_1.uiLogger.log(error.message);
+                                        uiLogger.log(error.message);
                                     });
                                 }
                             });
@@ -222,25 +203,25 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
                         resolve(taskStatus);
                     }
                 }
-            }, constants_1.DEFAULT_POLLING_DELAY);
+            }, DEFAULT_POLLING_DELAY);
         });
     };
 }
 function pollBuildAutodeployStatus(accountId, taskName, buildId) {
     return new Promise((resolve, reject) => {
-        let maxIntervals = (30 * 1000) / constants_1.DEFAULT_POLLING_DELAY; // Num of intervals in ~30s
+        let maxIntervals = (15 * 1000) / DEFAULT_POLLING_DELAY; // Num of intervals in ~15s
         const pollInterval = setInterval(async () => {
             let build;
             try {
-                const response = await (0, projects_1.getBuildStatus)(accountId, taskName, buildId);
+                const response = await getBuildStatus(accountId, taskName, buildId);
                 build = response.data;
             }
             catch (e) {
-                logger_1.uiLogger.debug(e);
-                return reject(new Error(en_1.lib.projectBuildAndDeploy.pollBuildAutodeployStatusError(buildId)));
+                uiLogger.debug(e);
+                return reject(new Error(lib.projectBuildAndDeploy.pollBuildAutodeployStatusError(buildId)));
             }
             if (!build || !build.status) {
-                return reject(new Error(en_1.lib.projectBuildAndDeploy.pollBuildAutodeployStatusError(buildId)));
+                return reject(new Error(lib.projectBuildAndDeploy.pollBuildAutodeployStatusError(buildId)));
             }
             if (build.deployStatusTaskLocator || maxIntervals <= 0) {
                 clearInterval(pollInterval);
@@ -249,67 +230,67 @@ function pollBuildAutodeployStatus(accountId, taskName, buildId) {
             else {
                 maxIntervals -= 1;
             }
-        }, constants_1.DEFAULT_POLLING_DELAY);
+        }, DEFAULT_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,
+export const pollBuildStatus = makePollTaskStatusFunc({
+    linkToHubSpot: (accountId, taskName, taskId) => uiLink(`View build #${taskId} in HubSpot`, getProjectBuildDetailUrl(taskName, taskId, accountId)),
+    statusFn: getBuildStatus,
+    structureFn: getBuildStructure,
+    statusText: 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)}`,
+        INITIALIZE: (name, buildId) => `Building ${chalk.bold(name)} #${buildId}`,
+        SUCCESS: (name, buildId) => `Built ${chalk.bold(name)} #${buildId}`,
+        FAIL: (name, buildId) => `Failed to build ${chalk.bold(name)} #${buildId}`,
+        SUBTASK_FAIL: (buildId, name) => `Build #${buildId} failed because there was a problem\nbuilding ${chalk.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,
+export const pollDeployStatus = makePollTaskStatusFunc({
+    linkToHubSpot: (accountId, taskName, taskId, deployedBuildId) => uiLink(`View deploy of build #${deployedBuildId} in HubSpot`, getProjectDeployDetailUrl(taskName, taskId, accountId)),
+    statusFn: getDeployStatus,
+    structureFn: getDeployStructure,
+    statusText: 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)}`,
+        INITIALIZE: (name, buildId) => `Deploying build #${buildId} in ${chalk.bold(name)}`,
+        SUCCESS: (name, buildId) => `Deployed build #${buildId} in ${chalk.bold(name)}`,
+        FAIL: (name, buildId) => `Failed to deploy build #${buildId} in ${chalk.bold(name)}`,
+        SUBTASK_FAIL: (deployedBuildId, name) => `Deploy for build #${deployedBuildId} failed because there was a\nproblem deploying ${chalk.bold(name)}`,
     },
 });
-async function displayWarnLogs(accountId, projectName, taskId, isDeploy = false) {
+export async function displayWarnLogs(accountId, projectName, taskId, isDeploy = false) {
     let result;
     if (isDeploy) {
         try {
-            const { data } = await (0, projects_1.fetchDeployWarnLogs)(accountId, projectName, taskId);
+            const { data } = await fetchDeployWarnLogs(accountId, projectName, taskId);
             result = data;
         }
         catch (e) {
-            (0, errorHandlers_1.logError)(e);
+            logError(e);
         }
     }
     else {
         try {
-            const { data } = await (0, projects_1.fetchBuildWarnLogs)(accountId, projectName, taskId);
+            const { data } = await fetchBuildWarnLogs(accountId, projectName, taskId);
             result = data;
         }
         catch (e) {
-            (0, errorHandlers_1.logError)(e);
+            logError(e);
         }
     }
     if (result && result.logs) {
-        const logLength = result.logs.length;
-        result.logs.forEach((log, i) => {
-            logger_1.uiLogger.warn(log.message);
-            if (i < logLength - 1) {
-                logger_1.uiLogger.log('');
+        const dedupedLogs = result.logs.reduce((acc, log) => acc.add(log.message), new Set());
+        Array.from(dedupedLogs).forEach((log, i) => {
+            uiLogger.warn(log);
+            if (i < dedupedLogs.size - 1) {
+                uiLogger.log('');
             }
         });
     }
 }
-async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, silenceLogs = false) {
-    let buildStatus = await (0, exports.pollBuildStatus)(accountId, projectConfig.name, buildId, null, silenceLogs);
+export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, silenceLogs = false) {
+    let buildStatus = await pollBuildStatus(accountId, projectConfig.name, buildId, null, silenceLogs);
     if (!silenceLogs) {
-        (0, ui_1.uiLine)();
+        uiLine();
     }
     const result = {
         succeeded: true,
@@ -323,7 +304,7 @@ async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, bui
     }
     else if (buildStatus.isAutoDeployEnabled) {
         if (!silenceLogs) {
-            logger_1.uiLogger.log(en_1.lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.buildSucceededAutomaticallyDeploying(buildId, (0, ui_1.uiAccountDescription)(accountId)));
+            uiLogger.log(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.buildSucceededAutomaticallyDeploying(buildId, uiAccountDescription(accountId)));
             await displayWarnLogs(accountId, projectConfig.name, buildId);
         }
         // autoDeployId of 0 indicates a skipped deploy
@@ -333,24 +314,24 @@ async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, bui
             buildStatus = await pollBuildAutodeployStatus(accountId, projectConfig.name, buildId);
         }
         if (getIsDeploying()) {
-            const deployStatus = await (0, exports.pollDeployStatus)(accountId, projectConfig.name, Number(buildStatus.deployStatusTaskLocator.id), buildId, silenceLogs);
+            const deployStatus = await 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.uiLogger.log(en_1.lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.unableToFindAutodeployStatus(buildId, (0, ui_1.uiLink)(en_1.lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.viewDeploys, (0, urls_1.getProjectActivityUrl)(projectConfig.name, accountId))));
+            uiLogger.log(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.unableToFindAutodeployStatus(buildId, uiLink(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.viewDeploys, getProjectActivityUrl(projectConfig.name, accountId))));
         }
     }
     try {
         if (tempFile) {
             tempFile.removeCallback();
-            logger_1.uiLogger.debug(en_1.lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.cleanedUpTempFile(tempFile.name));
+            uiLogger.debug(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.cleanedUpTempFile(tempFile.name));
         }
     }
     catch (e) {
-        (0, errorHandlers_1.logError)(e);
+        logError(e);
     }
     if (result && result.deployResult) {
         await displayWarnLogs(accountId, projectConfig.name, result.deployResult.deployId, true);

package/lib/projects/structure.d.ts

@@ -1,6 +1,6 @@
-import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
-import { AppIRNode } from '../../types/ProjectComponents';
+import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects.js';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { AppIRNode } from '../../types/ProjectComponents.js';
 export declare const CONFIG_FILES: {
     [k in ComponentTypes]: string;
 };