@hubspot/cli 8.1.0 → 8.1.2-experimental.0

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

@@ -8,7 +8,7 @@ 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 { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, PROJECT_CONFIG_FILE, } from '../../../constants.js';
 import { lib } from '../../../../lang/en.js';
 import { uiLogger } from '../../../ui/logger.js';
 import { uiLine } from '../../../ui/index.js';
@@ -22,7 +22,7 @@ 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) {
+export async function createNewProjectForLocalDev(projectConfig, targetAccountId, shouldCreateWithoutConfirmation, hasPublicApps, exit) {
     // Create the project without prompting if this is a newly created sandbox
     let shouldCreateProject = shouldCreateWithoutConfirmation;
     if (!shouldCreateProject) {
@@ -54,7 +54,7 @@ export async function createNewProjectForLocalDev(projectConfig, targetAccountId
             SpinniesManager.fail('createProject');
             uiLogger.log(lib.localDevHelpers.project.createNewProjectForLocalDev
                 .failedToCreateProject);
-            process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
     }
     else {
@@ -62,24 +62,24 @@ export async function createNewProjectForLocalDev(projectConfig, targetAccountId
         uiLogger.log('');
         uiLogger.log(lib.localDevHelpers.project.createNewProjectForLocalDev
             .choseNotToCreateProject);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
 }
-function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
+function projectUploadCallback(accountId, projectConfig, tempFile, exit, buildId) {
     if (!buildId) {
         uiLogger.error(lib.localDevHelpers.project.createInitialBuildForNewProject.genericError);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    return pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, true);
+    return pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, { silenceLogs: 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) {
+export async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, exit, sendIR, profile) {
     const { result: initialUploadResult, uploadError } = await handleProjectUpload({
         accountId: targetAccountId,
         projectConfig,
         projectDir,
-        callbackFunc: projectUploadCallback,
+        callbackFunc: (accountId, config, tempFile, buildId) => projectUploadCallback(accountId, config, tempFile, exit, buildId),
         uploadMessage: lib.localDevHelpers.project.createInitialBuildForNewProject
             .initialUploadMessage,
         forceCreate: true,
@@ -102,7 +102,7 @@ export async function createInitialBuildForNewProject(projectConfig, projectDir,
                 projectName: projectConfig.name,
             }));
         }
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     if (!initialUploadResult?.succeeded) {
         let subTasks = [];
@@ -120,15 +120,15 @@ export async function createInitialBuildForNewProject(projectConfig, projectDir,
             uiLogger.error(failedSubTask.errorMessage);
         });
         uiLogger.log('');
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     return initialUploadResult.buildResult;
 }
-export async function compareLocalProjectToDeployed(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+export async function compareLocalProjectToDeployed(projectConfig, accountId, deployedBuildId, localProjectNodes, exit, profile) {
     uiLogger.log('');
     if (!deployedBuildId) {
         uiLogger.error(lib.localDevHelpers.project.compareLocalProjectToDeployed.noDeployedBuild(projectConfig.name, uiAccountDescription(accountId)));
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     SpinniesManager.add('compareLocalProjectToDeployed', {
         text: lib.localDevHelpers.project.compareLocalProjectToDeployed.checking,
@@ -146,7 +146,7 @@ export async function compareLocalProjectToDeployed(projectConfig, accountId, de
         });
         uiLogger.log('');
         uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed.notUpToDateExplanation(profile));
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
 }
 export async function getDeployedProjectNodes(projectConfig, accountId, deployedBuildId, profile) {
@@ -155,7 +155,23 @@ export async function getDeployedProjectNodes(projectConfig, accountId, deployed
         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);
+        // Read the deployed project's hsproject.json to get its srcDir
+        // Deployed projects always use "src" as the srcDir
+        const possibleProjectPaths = [
+            path.join(tempDir, PROJECT_CONFIG_FILE),
+            path.join(tempDir, sanitizeFileName(projectConfig.name), PROJECT_CONFIG_FILE),
+        ];
+        let deployedSrcDir = 'src';
+        for (const projectJsonPath of possibleProjectPaths) {
+            if (await fs.pathExists(projectJsonPath)) {
+                const deployedProjectConfig = await fs.readJson(projectJsonPath);
+                if (deployedProjectConfig.srcDir) {
+                    deployedSrcDir = deployedProjectConfig.srcDir;
+                }
+                break;
+            }
+        }
+        const deployedProjectSourceDir = path.join(tempDir, deployedSrcDir);
         const { intermediateNodesIndexedByUid } = await translate({
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,
@@ -211,6 +227,6 @@ export async function checkAndInstallDependencies() {
             text: lib.localDevHelpers.project.checkAndInstallDependencies
                 .dependenciesFailure,
         });
-        process.exit(EXIT_CODES.ERROR);
+        throw e;
     }
 }

package/lib/projects/npmAuditOnUpload.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedPackageJson } from '@hubspot/project-parsing-lib/workspaces';
+export declare function summarizeNpmAuditJson(source: string): string | null;
+type RunNpmAuditsBeforeProjectUploadArgs = {
+    srcDir: string;
+    projectDir: string;
+    parsedPackageJsons: ParsedPackageJson[];
+    isLegacyPlatform: boolean;
+};
+export declare function runNpmAuditsBeforeProjectUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }: RunNpmAuditsBeforeProjectUploadArgs): Promise<void>;
+export {};

package/lib/projects/npmAuditOnUpload.js

@@ -0,0 +1,73 @@
+import path from 'path';
+import { runNpmAuditJson } from '@hubspot/ui-extensions-dev-server';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export function summarizeNpmAuditJson(source) {
+    try {
+        const data = JSON.parse(source);
+        const errorMessage = data.error?.message ?? data.error?.summary;
+        if (errorMessage) {
+            return errorMessage;
+        }
+        const v = data.metadata?.vulnerabilities;
+        if (!v) {
+            return null;
+        }
+        const total = v.total ?? 0;
+        if (total === 0) {
+            return null;
+        }
+        const severityOrder = [
+            'critical',
+            'high',
+            'moderate',
+            'low',
+            'info',
+        ];
+        const parts = severityOrder
+            .filter(severity => (v[severity] ?? 0) > 0)
+            .map(severity => `${v[severity]} ${severity}`);
+        return `${total} total (${parts.join(', ')})`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runNpmAuditsBeforeProjectUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }) {
+    const auditRoots = new Set();
+    if (isLegacyPlatform) {
+        auditRoots.add(srcDir);
+    }
+    else {
+        for (const { dir } of parsedPackageJsons) {
+            auditRoots.add(dir);
+        }
+        if (auditRoots.size === 0) {
+            auditRoots.add(srcDir);
+        }
+    }
+    const auditRootArray = [...auditRoots];
+    const results = await Promise.all(auditRootArray.map(auditRoot => runNpmAuditJson(auditRoot)));
+    for (let i = 0; i < auditRootArray.length; i++) {
+        const auditRoot = auditRootArray[i];
+        const result = results[i];
+        if (result.skipped) {
+            continue;
+        }
+        const relativeRoot = path.relative(projectDir, auditRoot) || '.';
+        const summary = summarizeNpmAuditJson(result.source);
+        if (result.exitCode === 127) {
+            uiLogger.warn(lib.projectUpload.handleProjectUpload.npmAuditNpmUnavailable(relativeRoot));
+            continue;
+        }
+        if (summary) {
+            uiLogger.warn(lib.projectUpload.handleProjectUpload.npmAuditIssues(relativeRoot, summary));
+            continue;
+        }
+        if (result.exitCode !== 0) {
+            uiLogger.warn(lib.projectUpload.handleProjectUpload.npmAuditNonZeroExit(relativeRoot, result.exitCode));
+            continue;
+        }
+        uiLogger.success(lib.projectUpload.handleProjectUpload.npmAuditClean(relativeRoot));
+    }
+}

package/lib/projects/pollProjectBuildAndDeploy.d.ts

@@ -6,5 +6,9 @@ type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskNam
 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>;
+type PollOptions = {
+    silenceLogs?: boolean;
+    skipDeploy?: boolean;
+};
+export declare function pollProjectBuildAndDeploy(accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number, options?: PollOptions): Promise<ProjectPollResult>;
 export {};

package/lib/projects/pollProjectBuildAndDeploy.js

@@ -5,7 +5,6 @@ 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 { APP_FUNCTIONS_PACKAGE_KEY as AppFunctionsPackageKey } from '@hubspot/project-parsing-lib/constants';
@@ -32,8 +31,8 @@ function getSubtaskType(task) {
     return task.deployType;
 }
 function handleTaskStatusError(statusText) {
-    uiLogger.error(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorFetchingTaskStatus(statusText.TYPE_KEY === PROJECT_BUILD_TEXT.TYPE_KEY ? 'build' : 'deploy'));
-    process.exit(EXIT_CODES.ERROR);
+    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) {
@@ -111,97 +110,103 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
                 task.subtasks.forEach((subtask, i) => addTaskSpinner(subtask, 4, i === task.subtasks.length - 1));
             });
         }
-        return new Promise(resolve => {
+        return new Promise((resolve, reject) => {
             const pollInterval = setInterval(async () => {
-                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 });
+                    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;
                             }
-                            if (topLevelTask) {
-                                topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager.remove(currentSubtask.id));
+                            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);
-                                    });
-                                }
+                        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);
                         }
-                        clearInterval(pollInterval);
-                        resolve(taskStatus);
-                    }
-                    else if (!subtasks.length) {
-                        clearInterval(pollInterval);
-                        resolve(taskStatus);
                     }
                 }
+                catch (e) {
+                    clearInterval(pollInterval);
+                    reject(e);
+                }
             }, DEFAULT_POLLING_DELAY);
         });
     };
@@ -286,7 +291,8 @@ export async function displayWarnLogs(accountId, projectName, taskId, isDeploy =
         });
     }
 }
-export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, silenceLogs = false) {
+export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, options = {}) {
+    const { silenceLogs = false, skipDeploy = false } = options;
     let buildStatus = await pollBuildStatus(accountId, projectConfig.name, buildId, null, silenceLogs);
     if (!silenceLogs) {
         uiLine();
@@ -301,7 +307,7 @@ export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFi
         result.succeeded = false;
         return result;
     }
-    else if (buildStatus.isAutoDeployEnabled) {
+    else if (buildStatus.isAutoDeployEnabled && !skipDeploy) {
         if (!silenceLogs) {
             uiLogger.log(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.buildSucceededAutomaticallyDeploying(buildId, uiAccountDescription(accountId)));
             await displayWarnLogs(accountId, projectConfig.name, buildId);

package/lib/projects/preview.d.ts

@@ -0,0 +1,7 @@
+type PreviewResult = {
+    succeeded: boolean;
+    releaseTag?: string;
+    appId?: number;
+};
+export declare function triggerAndPollPreview(accountId: number, projectId: number, buildId: number, targetPortalId: number): Promise<PreviewResult>;
+export {};

package/lib/projects/preview.js

@@ -0,0 +1,48 @@
+import { triggerAutoRelease, getAutoReleaseStatus, } from '../../api/releases.js';
+import { PREVIEW_POLL_TIMEOUT } from '../constants.js';
+import { poll } from '../polling.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+export async function triggerAndPollPreview(accountId, projectId, buildId, targetPortalId) {
+    let triggerResponse;
+    SpinniesManager.add('preview', {
+        text: lib.projectPreview.triggeringPreview(buildId, targetPortalId),
+        succeedColor: 'white',
+    });
+    try {
+        const { data } = await triggerAutoRelease(accountId, projectId, buildId, targetPortalId);
+        triggerResponse = data;
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.triggerFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview trigger',
+        }));
+        return { succeeded: false };
+    }
+    const { releaseTag, appId } = triggerResponse;
+    SpinniesManager.update('preview', {
+        text: lib.projectPreview.pollingStatus(releaseTag, targetPortalId),
+    });
+    try {
+        await poll(() => getAutoReleaseStatus(accountId, projectId, targetPortalId, releaseTag, appId), { successStates: ['COMPLETE'], errorStates: [] }, PREVIEW_POLL_TIMEOUT);
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.pollFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview status',
+        }));
+        return { succeeded: false, releaseTag, appId };
+    }
+    SpinniesManager.succeed('preview', {
+        text: lib.projectPreview.succeeded(releaseTag, targetPortalId),
+    });
+    return { succeeded: true, releaseTag, appId };
+}

package/lib/projects/projectInfo.d.ts

@@ -0,0 +1,5 @@
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import { ProjectInfo } from '../../types/Projects.js';
+export type { ProjectInfo };
+export declare function getProjectInfo(project: Project, platformVersion: string, accountId: number): Promise<ProjectInfo>;
+export declare function logProjectInfo(projectInfo: ProjectInfo): void;

package/lib/projects/projectInfo.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
+import { APP_KEY, USER_FACING_TO_INTERNAL_TYPE, } from '@hubspot/project-parsing-lib/constants';
+import { debugError } from '../errorHandlers/index.js';
+import { getProjectDetailUrl } from './urls.js';
+import { commands } from '../../lang/en.js';
+import { uiLine, uiLink } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+export async function getProjectInfo(project, platformVersion, accountId) {
+    const deployedBuild = project.deployedBuild;
+    const projectInfo = {
+        projectName: project.name,
+        platformVersion,
+        projectId: project.id,
+        deployedBuildId: deployedBuild.buildId,
+        autoDeployEnabled: deployedBuild.isAutoDeployEnabled,
+        components: [],
+    };
+    const projectUrl = getProjectDetailUrl(project.name, accountId);
+    if (projectUrl) {
+        projectInfo.projectUrl = projectUrl;
+    }
+    const appSubbuild = deployedBuild.subbuildStatuses.find(s => s.buildType === USER_FACING_TO_INTERNAL_TYPE[APP_KEY]);
+    if (appSubbuild) {
+        try {
+            const { data: appMetadata } = await fetchAppMetadataBySourceId(project.id, appSubbuild.buildName, accountId);
+            projectInfo.app = {
+                name: appMetadata.name,
+                id: appMetadata.id,
+                uid: appSubbuild.buildName,
+                authType: appMetadata.authType,
+                distributionType: appMetadata.distributionType,
+            };
+        }
+        catch (err) {
+            debugError(err);
+        }
+    }
+    projectInfo.components = deployedBuild.subbuildStatuses
+        .filter(s => s.buildType !== USER_FACING_TO_INTERNAL_TYPE[APP_KEY])
+        .map(s => ({
+        uid: s.buildName,
+        type: s.buildType,
+    }));
+    return projectInfo;
+}
+export function logProjectInfo(projectInfo) {
+    uiLogger.log(chalk.bold(commands.project.info.project.title(projectInfo.projectName)));
+    uiLine();
+    uiLogger.log(commands.project.info.project.platformVersion(projectInfo.platformVersion));
+    uiLogger.log(commands.project.info.project.id(projectInfo.projectId));
+    uiLogger.log(commands.project.info.project.deployedBuild(projectInfo.deployedBuildId));
+    uiLogger.log(commands.project.info.project.autoDeploy(projectInfo.autoDeployEnabled));
+    if (projectInfo.projectUrl) {
+        uiLogger.log('');
+        uiLogger.log(uiLink(commands.project.info.viewProjectLink, projectInfo.projectUrl));
+    }
+    if (projectInfo.app) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.project.info.app.title));
+        uiLine();
+        uiLogger.log(commands.project.info.app.name(projectInfo.app.name));
+        uiLogger.log(commands.project.info.app.id(projectInfo.app.id));
+        uiLogger.log(commands.project.info.app.uid(projectInfo.app.uid));
+        if (projectInfo.app.authType) {
+            uiLogger.log(commands.project.info.app.authType(projectInfo.app.authType));
+        }
+        if (projectInfo.app.distributionType) {
+            uiLogger.log(commands.project.info.app.distributionType(projectInfo.app.distributionType));
+        }
+    }
+    if (projectInfo.components.length > 0) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.project.info.componentsHeader));
+        uiLine();
+        const typeColWidth = Math.max(commands.project.info.labels.type.length, ...projectInfo.components.map(c => c.type.length));
+        uiLogger.log(`${commands.project.info.labels.type.padEnd(typeColWidth)}   ${commands.project.info.labels.uid}`);
+        for (const component of projectInfo.components) {
+            uiLogger.log(`${component.type.padEnd(typeColWidth)}   ${component.uid}`);
+        }
+    }
+}

package/lib/projects/projectProfiles.d.ts

@@ -3,8 +3,7 @@ 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>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string, silent?: boolean): Promise<HsProfileFile | never>;
 type ValidateProjectForProfileOptions = {
     projectConfig: ProjectConfig;
     projectDir: string;