@hubspot/cli 8.0.10-experimental.5 → 8.0.10-experimental.6

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

@@ -1,216 +0,0 @@
-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/translate';
-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';
-import { getProjectPackageJsonLocations, hasMissingPackages, installPackages, } from '../../../dependencyManagement.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 getDeployedProjectNodes(projectConfig, accountId, deployedBuildId, 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);
-        await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { hideLogs: true });
-        const deployedProjectSourceDir = path.join(tempDir, projectConfig.srcDir);
-        const { intermediateNodesIndexedByUid } = await translate({
-            projectSourceDir: deployedProjectSourceDir,
-            platformVersion: projectConfig.platformVersion,
-            accountId: accountId,
-        }, { profile });
-        return intermediateNodesIndexedByUid;
-    }
-    finally {
-        if (tempDir && (await fs.pathExists(tempDir))) {
-            await fs.remove(tempDir);
-        }
-    }
-}
-export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
-    try {
-        const deployedProjectNodes = await getDeployedProjectNodes(projectConfig, accountId, deployedBuildId, profile);
-        return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
-    }
-    catch (err) {
-        debugError(err);
-        return false;
-    }
-}
-export async function checkAndInstallDependencies() {
-    uiLogger.log('');
-    SpinniesManager.add('checkingDependencies', {
-        text: lib.localDevHelpers.project.checkAndInstallDependencies
-            .checkingDependencies,
-    });
-    try {
-        const installLocations = await getProjectPackageJsonLocations();
-        const locationsToInstall = [];
-        for (const location of installLocations) {
-            if (await hasMissingPackages(location)) {
-                locationsToInstall.push(location);
-            }
-        }
-        if (locationsToInstall.length > 0) {
-            SpinniesManager.remove('checkingDependencies');
-            await installPackages({ installLocations: locationsToInstall });
-        }
-        else {
-            SpinniesManager.succeed('checkingDependencies', {
-                text: lib.localDevHelpers.project.checkAndInstallDependencies
-                    .dependenciesUpToDate,
-            });
-        }
-        uiLogger.log('');
-    }
-    catch (e) {
-        logError(e);
-        SpinniesManager.fail('checkingDependencies', {
-            text: lib.localDevHelpers.project.checkAndInstallDependencies
-                .dependenciesFailure,
-        });
-        process.exit(EXIT_CODES.ERROR);
-    }
-}

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

@@ -1,8 +0,0 @@
-import { LocalDevDeployWebsocketMessage } from '../../../types/LocalDev.js';
-import { CLIWebSocketMessage } from '../../CLIWebSocketServer.js';
-export declare function isUploadWebsocketMessage(message: CLIWebSocketMessage): boolean;
-export declare function isDeployWebsocketMessage(message: CLIWebSocketMessage): message is LocalDevDeployWebsocketMessage;
-export declare function isViewedWelcomeScreenWebsocketMessage(message: CLIWebSocketMessage): boolean;
-export declare function isAppInstallSuccessWebsocketMessage(message: CLIWebSocketMessage): boolean;
-export declare function isAppInstallInitiatedWebsocketMessage(message: CLIWebSocketMessage): boolean;
-export declare function isAppInstallFailureWebsocketMessage(message: CLIWebSocketMessage): boolean;

package/lib/projects/localDev/localDevWebsocketServerUtils.js

@@ -1,19 +0,0 @@
-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);
-}
-export function isAppInstallSuccessWebsocketMessage(message) {
-    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_SUCCESS);
-}
-export function isAppInstallInitiatedWebsocketMessage(message) {
-    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_INITIATED);
-}
-export function isAppInstallFailureWebsocketMessage(message) {
-    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_FAILURE);
-}

package/lib/projects/platformVersion.d.ts

@@ -1,9 +0,0 @@
-/**
- * Used to surface warnings when users attempt to interact with new platform versions
- * that were released after this version of the CLI was released.
- *
- * We are unable to reliably support versions of projects that are newer than any given CLI release
- * */
-export declare const LATEST_SUPPORTED_PLATFORM_VERSION = "2026.03";
-export declare function isV2Project(platformVersion?: string | null): boolean;
-export declare function isUnsupportedPlatformVersion(platformVersion?: string | null): boolean;

package/lib/projects/platformVersion.js

@@ -1,39 +0,0 @@
-/**
- * Used to surface warnings when users attempt to interact with new platform versions
- * that were released after this version of the CLI was released.
- *
- * We are unable to reliably support versions of projects that are newer than any given CLI release
- * */
-export const LATEST_SUPPORTED_PLATFORM_VERSION = '2026.03';
-function parsePlatformVersion(platformVersion) {
-    const [year, minor] = platformVersion.split(/[.-]/);
-    return {
-        year: Number(year),
-        minor: Number(minor),
-    };
-}
-export function isV2Project(platformVersion) {
-    if (!platformVersion || typeof platformVersion !== 'string') {
-        return false;
-    }
-    if (platformVersion.toLowerCase() === 'unstable') {
-        return true;
-    }
-    const { year, minor } = parsePlatformVersion(platformVersion);
-    return (year === 2025 && minor >= 2) || year > 2025;
-}
-export function isUnsupportedPlatformVersion(platformVersion) {
-    if (!platformVersion || typeof platformVersion !== 'string') {
-        return false;
-    }
-    if (platformVersion.toLowerCase() === 'unstable') {
-        return false;
-    }
-    const { year, minor } = parsePlatformVersion(platformVersion);
-    if (isNaN(year) || isNaN(minor)) {
-        return false;
-    }
-    const { year: latestSupportedYear, minor: latestSupportedMinor } = parsePlatformVersion(LATEST_SUPPORTED_PLATFORM_VERSION);
-    return (year > latestSupportedYear ||
-        (year === latestSupportedYear && minor > latestSupportedMinor));
-}

package/lib/projects/pollProjectBuildAndDeploy.d.ts

@@ -1,10 +0,0 @@
-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.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>;
-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/pollProjectBuildAndDeploy.js

@@ -1,344 +0,0 @@
-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 { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-import { APP_FUNCTIONS_PACKAGE_KEY as AppFunctionsPackageKey } from '@hubspot/project-parsing-lib/constants';
-import { mapToInternalType } from '@hubspot/project-parsing-lib/transform';
-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 handleTaskStatusError(statusText) {
-    const taskType = statusText.TYPE_KEY === PROJECT_BUILD_TEXT.TYPE_KEY ? 'build' : 'deploy';
-    throw new Error(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorFetchingTaskStatus(taskType));
-}
-function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrings, linkToHubSpot, }) {
-    return async function (accountId, taskName, taskId, deployedBuildId, silenceLogs = false) {
-        const displayId = deployedBuildId || taskId;
-        if (linkToHubSpot && !silenceLogs) {
-            uiLogger.log(`\n${linkToHubSpot(accountId, taskName, taskId, deployedBuildId)}\n`);
-        }
-        const overallTaskSpinniesKey = `overallTaskStatus-${statusText.STATUS_TEXT}`;
-        SpinniesManager.add(overallTaskSpinniesKey, {
-            text: 'Beginning',
-            succeedColor: 'white',
-            failColor: 'white',
-            failPrefix: chalk.bold('!'),
-        });
-        const [{ data: initialTaskStatus }, { data: { topLevelComponentsWithChildren: taskStructure }, },] = await Promise.all([
-            statusFn(accountId, taskName, taskId),
-            structureFn(accountId, taskName, taskId),
-        ]);
-        const subtasks = getSubtasks(initialTaskStatus);
-        const hiddenComponentBuildIds = [];
-        const tasksById = subtasks
-            .filter(subtask => {
-            // TODO: Remove this filtering logic when visible=false for SERVERLESS_PACKAGE
-            const shouldBeVisible = getSubtaskType(subtask) !== mapToInternalType(AppFunctionsPackageKey);
-            if (!shouldBeVisible) {
-                hiddenComponentBuildIds.push(subtask.id);
-            }
-            return shouldBeVisible;
-        })
-            .reduce((acc, subtask) => {
-            const { id, visible } = subtask;
-            if (visible) {
-                acc[id] = subtask;
-            }
-            return acc;
-        }, {});
-        const structuredTasks = Object.keys(taskStructure)
-            // TODO: Remove this filtering logic when visible=false for SERVERLESS_PACKAGE
-            .filter(buildId => !hiddenComponentBuildIds.includes(buildId))
-            .map(key => {
-            return {
-                ...tasksById[key],
-                subtasks: taskStructure[key]
-                    .filter(taskId => Boolean(tasksById[taskId]))
-                    .map(taskId => tasksById[taskId]),
-            };
-        });
-        const numComponents = structuredTasks.length;
-        const componentCountText = silenceLogs
-            ? ''
-            : numComponents === 1
-                ? lib.projectBuildAndDeploy.makePollTaskStatusFunc
-                    .componentCountSingular
-                : 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 = PROJECT_TASK_TYPES[taskType]
-                    ? `[${PROJECT_TASK_TYPES[taskType]}]`
-                    : '';
-                const text = `${indent <= 2 ? statusText.STATUS_TEXT : ''} ${chalk.bold(taskName)} ${formattedTaskType} ...${newline ? '\n' : ''}`;
-                SpinniesManager.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 () => {
-                try {
-                    let taskStatus;
-                    try {
-                        const { data } = await statusFn(accountId, taskName, taskId);
-                        taskStatus = data;
-                    }
-                    catch (e) {
-                        uiLogger.debug(e);
-                        logError(e, new ApiErrorContext({
-                            accountId,
-                            projectName: taskName,
-                        }));
-                        handleTaskStatusError(statusText);
-                    }
-                    const subtasks = getSubtasks(taskStatus);
-                    if (!taskStatus || !taskStatus.status || !subtasks) {
-                        handleTaskStatusError(statusText);
-                    }
-                    const { status } = taskStatus;
-                    if (SpinniesManager.hasActiveSpinners()) {
-                        subtasks.forEach(subtask => {
-                            const { id, status } = subtask;
-                            const spinner = SpinniesManager.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
-                                    ? lib.projectBuildAndDeploy.makePollTaskStatusFunc
-                                        .successStatusText
-                                    : 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.succeed(id, { text: updatedText });
-                                }
-                                else {
-                                    SpinniesManager.fail(id, { text: updatedText });
-                                }
-                                if (topLevelTask) {
-                                    topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager.remove(currentSubtask.id));
-                                }
-                            }
-                        });
-                        if (status === statusText.STATES.SUCCESS) {
-                            SpinniesManager.succeed(overallTaskSpinniesKey, {
-                                text: statusStrings.SUCCESS(taskName, displayId),
-                            });
-                            clearInterval(pollInterval);
-                            resolve(taskStatus);
-                        }
-                        else if (status === statusText.STATES.FAILURE) {
-                            SpinniesManager.fail(overallTaskSpinniesKey, {
-                                text: statusStrings.FAIL(taskName, displayId),
-                            });
-                            if (!silenceLogs) {
-                                const failedSubtasks = subtasks.filter(subtask => subtask.status === 'FAILURE');
-                                uiLine();
-                                uiLogger.log(`${statusStrings.SUBTASK_FAIL(failedSubtasks.length === 1
-                                    ? getSubtaskName(failedSubtasks[0])
-                                    : failedSubtasks.length + ' components', displayId)}\n`);
-                                uiLogger.log(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorSummary);
-                                uiLine();
-                                const displayErrors = failedSubtasks.filter(subtask => subtask?.standardError?.subCategory !==
-                                    PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
-                                    subtask?.standardError?.subCategory !==
-                                        PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED);
-                                displayErrors.forEach(subTask => {
-                                    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) {
-                                        uiLogger.log('');
-                                        subTask.standardError.errors.forEach(error => {
-                                            uiLogger.log(error.message);
-                                        });
-                                    }
-                                });
-                            }
-                            clearInterval(pollInterval);
-                            resolve(taskStatus);
-                        }
-                        else if (!subtasks.length) {
-                            clearInterval(pollInterval);
-                            resolve(taskStatus);
-                        }
-                    }
-                }
-                catch (e) {
-                    clearInterval(pollInterval);
-                    reject(e);
-                }
-            }, DEFAULT_POLLING_DELAY);
-        });
-    };
-}
-function pollBuildAutodeployStatus(accountId, taskName, buildId) {
-    return new Promise((resolve, reject) => {
-        let maxIntervals = (15 * 1000) / DEFAULT_POLLING_DELAY; // Num of intervals in ~15s
-        const pollInterval = setInterval(async () => {
-            let build;
-            try {
-                const response = await getBuildStatus(accountId, taskName, buildId);
-                build = response.data;
-            }
-            catch (e) {
-                uiLogger.debug(e);
-                return reject(new Error(lib.projectBuildAndDeploy.pollBuildAutodeployStatusError(buildId)));
-            }
-            if (!build || !build.status) {
-                return reject(new Error(lib.projectBuildAndDeploy.pollBuildAutodeployStatusError(buildId)));
-            }
-            if (build.deployStatusTaskLocator || maxIntervals <= 0) {
-                clearInterval(pollInterval);
-                resolve(build);
-            }
-            else {
-                maxIntervals -= 1;
-            }
-        }, DEFAULT_POLLING_DELAY);
-    });
-}
-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.bold(name)} #${buildId}`,
-        SUCCESS: (name, buildId) => `Built ${chalk.bold(name)} #${buildId}`,
-        FAIL: (name, buildId) => `Failed to build ${chalk.bold(name)} #${buildId}`,
-        SUBTASK_FAIL: (name, buildId) => `Build #${buildId} failed because there was a problem\nbuilding ${chalk.bold(name)}`,
-    },
-});
-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.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: (name, deployedBuildId) => `Deploy for build #${deployedBuildId} failed because there was a\nproblem deploying ${chalk.bold(name)}`,
-    },
-});
-export async function displayWarnLogs(accountId, projectName, taskId, isDeploy = false) {
-    let result;
-    if (isDeploy) {
-        try {
-            const { data } = await fetchDeployWarnLogs(accountId, projectName, taskId);
-            result = data;
-        }
-        catch (e) {
-            logError(e);
-        }
-    }
-    else {
-        try {
-            const { data } = await fetchBuildWarnLogs(accountId, projectName, taskId);
-            result = data;
-        }
-        catch (e) {
-            logError(e);
-        }
-    }
-    if (result && result.logs) {
-        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('');
-            }
-        });
-    }
-}
-export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, silenceLogs = false) {
-    let buildStatus = await pollBuildStatus(accountId, projectConfig.name, buildId, null, silenceLogs);
-    if (!silenceLogs) {
-        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) {
-            uiLogger.log(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.buildSucceededAutomaticallyDeploying(buildId, uiAccountDescription(accountId)));
-            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 pollDeployStatus(accountId, projectConfig.name, Number(buildStatus.deployStatusTaskLocator.id), buildId, silenceLogs);
-            result.deployResult = deployStatus;
-            if (deployStatus.status === 'FAILURE') {
-                result.succeeded = false;
-            }
-        }
-        else if (!silenceLogs) {
-            uiLogger.log(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.unableToFindAutodeployStatus(buildId, uiLink(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.viewDeploys, getProjectActivityUrl(projectConfig.name, accountId))));
-        }
-    }
-    try {
-        if (tempFile) {
-            tempFile.removeCallback();
-            uiLogger.debug(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.cleanedUpTempFile(tempFile.name));
-        }
-    }
-    catch (e) {
-        logError(e);
-    }
-    if (result && result.deployResult) {
-        await displayWarnLogs(accountId, projectConfig.name, result.deployResult.deployId, true);
-    }
-    return result;
-}

package/lib/projects/projectProfiles.d.ts

@@ -1,17 +0,0 @@
-import { type HsProfileFile } from '@hubspot/project-parsing-lib/profiles';
-import { ProjectConfig } from '../../types/Projects.js';
-export declare function logProfileHeader(profileName: string): void;
-export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
-export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | never;
-export declare function enforceProfileUsage(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string | undefined, silent?: boolean): Promise<number | undefined>;
-type ValidateProjectForProfileOptions = {
-    projectConfig: ProjectConfig;
-    projectDir: string;
-    profileName: string;
-    derivedAccountId: number;
-    indentSpinners?: boolean;
-    silent?: boolean;
-};
-export declare function validateProjectForProfile({ projectConfig, projectDir, profileName, derivedAccountId, indentSpinners, silent, }: ValidateProjectForProfileOptions): Promise<(string | Error)[]>;
-export {};