@hubspot/cli 8.2.0 → 8.2.1-experimental.0

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

@@ -1,5 +1,3 @@
-import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
-import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
@@ -7,96 +5,15 @@ import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constant
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { uiLogger } from '../../../ui/logger.js';
 import { lib } from '../../../../lang/en.js';
-import { EXIT_CODES } from '../../../enums/exitCodes.js';
-import { confirmDefaultAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { isUnifiedAccount } from '../../../accountTypes.js';
-import { isAppDeveloperAccount } from '../../../accountTypes.js';
-import { isDeveloperTestAccount } from '../../../accountTypes.js';
-import { uiAccountDescription } from '../../../ui/index.js';
-import { uiLine } from '../../../ui/index.js';
-import { selectDeveloperTestTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { selectSandboxTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
 import { validateSandboxUsageLimits } from '../../../sandboxes.js';
 import { logError } from '../../../errorHandlers/index.js';
-import { syncSandbox } from '../../../sandboxSync.js';
-import { getAvailableSyncTypes } from '../../../sandboxes.js';
 import { hubspotAccountNamePrompt } from '../../../prompts/accountNamePrompt.js';
 import { trackCommandMetadataUsage } from '../../../usageTracking.js';
 import { validateDevTestAccountUsageLimits } from '../../../developerTestAccounts.js';
-import { buildSandbox, buildDeveloperTestAccount, saveAccountToConfig, } from '../../../buildAccount.js';
+import { buildDeveloperTestAccount, saveAccountToConfig, buildV2Sandbox, } from '../../../buildAccount.js';
 import { debugError } from '../../../errorHandlers/index.js';
 import { listPrompt } from '../../../prompts/promptUtils.js';
 import { confirmUseExistingDeveloperTestAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-// If the user passed in the --account flag, confirm they want to use that account as
-// their target account, otherwise exit
-export async function confirmDefaultAccountIsTarget(accountConfig) {
-    if (!accountConfig.name || !accountConfig.accountType) {
-        uiLogger.error(lib.localDevHelpers.account.confirmDefaultAccountIsTarget.configError);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    uiLogger.log('');
-    const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
-    if (!useDefaultAccount) {
-        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
-            .declineDefaultAccountExplanation);
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-}
-// Confirm the default account is supported for the type of apps being developed
-export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
-    const defaultAccountIsUnified = await isUnifiedAccount(accountConfig);
-    if (hasPublicApps &&
-        !(isAppDeveloperAccount(accountConfig) ||
-            isDeveloperTestAccount(accountConfig) ||
-            defaultAccountIsUnified)) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.privateApp);
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-}
-export function checkIfParentAccountIsAuthed(accountConfig) {
-    if (!accountConfig.parentAccountId ||
-        !getConfigAccountIfExists(accountConfig.parentAccountId)?.accountId) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(accountConfig.accountId)));
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-}
-// Confirm the default account is a developer account if developing public apps
-export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
-    if (hasPublicApps) {
-        if (!isDeveloperTestAccount(accountConfig)) {
-            uiLogger.error(lib.localDevHelpers.account.validateAccountOption
-                .invalidPublicAppAccount);
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        checkIfParentAccountIsAuthed(accountConfig);
-    }
-    else if (isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-}
-// If the user isn't using the recommended account type, prompt them to use or create one
-export async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
-    uiLogger.log('');
-    uiLine();
-    if (hasPublicApps) {
-        uiLogger.log(lib.localDevHelpers.account.validateAccountOption
-            .publicAppNonDeveloperTestAccountWarning);
-    }
-    else {
-        uiLogger.log(lib.localDevHelpers.account.validateAccountOption.nonSandboxWarning);
-    }
-    uiLine();
-    uiLogger.log('');
-    const targetAccountPrompt = hasPublicApps
-        ? selectDeveloperTestTargetAccountPrompt
-        : selectSandboxTargetAccountPrompt;
-    return targetAccountPrompt(accounts, accountConfig);
-}
 // Create a new sandbox and return its accountId
 export async function createSandboxForLocalDev(accountId, accountConfig, env) {
     try {
@@ -112,24 +29,20 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
         else {
             logError(err);
         }
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
     try {
         const { name } = await hubspotAccountNamePrompt({
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         });
         trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
-        const result = await buildSandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
-        const targetAccountId = result.sandbox.sandboxHubId;
-        const sandboxAccountConfig = getConfigAccountById(result.sandbox.sandboxHubId);
-        const syncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
-        // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
-        await syncSandbox(sandboxAccountConfig, accountConfig, env, syncTasks, true);
-        return targetAccountId;
+        const result = await buildV2Sandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, // syncObjectRecords
+        env);
+        return result.sandbox.sandboxHubId;
     }
     catch (err) {
         logError(err);
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
 }
 // Create a developer test account and return its accountId
@@ -155,7 +68,7 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
         else {
             logError(err);
         }
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
     try {
         const { name } = await hubspotAccountNamePrompt({
@@ -163,12 +76,11 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         });
         trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
-        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
-        return result;
+        return await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
     }
     catch (err) {
         logError(err);
-        process.exit(EXIT_CODES.ERROR);
+        throw err;
     }
 }
 // Prompt user to confirm usage of an existing developer test account that is not currently in the config
@@ -176,13 +88,13 @@ export async function useExistingDevTestAccount(env, account) {
     const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
     if (!useExistingDevTestAcct) {
         uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
-            .declineDefaultAccountExplanation);
+        uiLogger.log(lib.localDevHelpers.account.declineDefaultAccountExplanation);
         uiLogger.log('');
-        process.exit(EXIT_CODES.SUCCESS);
+        return false;
     }
     const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
     uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
+    return true;
 }
 export async function hasSandboxes(account) {
     const accountId = account.accountId;

package/lib/projects/localDev/helpers/process.d.ts

@@ -1 +1 @@
-export declare function confirmLocalDevIsNotRunning(): Promise<void>;
+export declare function isLocalDevRunning(): Promise<boolean>;

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

@@ -1,17 +1,11 @@
 import { LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID } from '../../../constants.js';
-import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { getServerPortByInstanceId } from '@hubspot/local-dev-lib/portManager';
-import { uiLogger } from '../../../ui/logger.js';
-import { commands } from '../../../../lang/en.js';
-export async function confirmLocalDevIsNotRunning() {
+export async function isLocalDevRunning() {
     try {
         const existingPortInUse = await getServerPortByInstanceId(LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID);
-        if (existingPortInUse) {
-            uiLogger.error(commands.project.dev.errors.localDevAlreadyRunning);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        return Boolean(existingPortInUse);
     }
-    catch (error) {
-        return;
+    catch {
+        return false;
     }
 }

package/lib/projects/localDev/helpers/project.d.ts

@@ -1,16 +1,18 @@
 import { type IntermediateRepresentationNode, type IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Project } from '@hubspot/local-dev-lib/types/Project';
-import { ProjectConfig } from '../../../../types/Projects.js';
-export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
-export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
+import { LocallyChangedComponents, ProjectConfig } from '../../../../types/Projects.js';
+import { ExitFunction } from '../../../../types/Yargs.js';
+export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean, exit: ExitFunction): Promise<Project>;
+export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, exit: ExitFunction, sendIR?: boolean, profile?: string): Promise<Build>;
 export declare function compareLocalProjectToDeployed(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number | undefined, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
-}, profile?: string): Promise<void>;
+}, exit: ExitFunction, profile?: string): Promise<void>;
 export declare function getDeployedProjectNodes(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, profile?: string): Promise<{
     [key: string]: IntermediateRepresentationNode;
 }>;
-export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
+export declare function hasLocalComponentChanges(changed: LocallyChangedComponents): boolean;
+export declare function getLocallyChangedComponents(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
-}, profile?: string): Promise<boolean>;
+}, profile?: string): Promise<LocallyChangedComponents>;
 export declare function checkAndInstallDependencies(): Promise<void>;

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

@@ -1,28 +1,27 @@
 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 { createProject, 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 { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
+import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
 import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
-import { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } from '../../../constants.js';
+import { PROJECT_BUILD_TEXT, PROJECT_CONFIG_FILE, PROJECT_DEPLOY_TEXT, PROJECT_ERROR_TYPES, } from '../../../constants.js';
 import { lib } from '../../../../lang/en.js';
 import { uiLogger } from '../../../ui/logger.js';
-import { uiLine } from '../../../ui/index.js';
+import { uiAccountDescription, 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 { ApiErrorContext, debugError, logError, } 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 +53,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,30 +61,31 @@ 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,
         skipValidation: true,
         sendIR,
         profile,
+        force: true,
     });
     if (uploadError) {
         if (isSpecifiedError(uploadError, {
@@ -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,21 +120,21 @@ 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,
     });
-    const isUpToDate = await isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile);
-    if (isUpToDate) {
+    const changedComponents = await getLocallyChangedComponents(projectConfig, accountId, deployedBuildId, localProjectNodes, profile);
+    if (!hasLocalComponentChanges(changedComponents)) {
         SpinniesManager.succeed('compareLocalProjectToDeployed', {
             text: lib.localDevHelpers.project.compareLocalProjectToDeployed.upToDate,
         });
@@ -145,8 +145,10 @@ export async function compareLocalProjectToDeployed(projectConfig, accountId, de
                 .notUpToDate,
         });
         uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed.changedFiles(changedComponents));
+        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,13 +157,29 @@ 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);
-        const { intermediateNodesIndexedByUid } = await translate({
+        // 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 { intermediateRepresentation } = await translate({
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,
             accountId: accountId,
         }, { profile });
-        return intermediateNodesIndexedByUid;
+        return intermediateRepresentation.intermediateNodesIndexedByUid;
     }
     finally {
         if (tempDir && (await fs.pathExists(tempDir))) {
@@ -169,14 +187,47 @@ export async function getDeployedProjectNodes(projectConfig, accountId, deployed
         }
     }
 }
-export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+function filterAutoGeneratedNodes(nodes) {
+    return Object.fromEntries(Object.entries(nodes).filter(([, node]) => !AUTO_GENERATED_COMPONENT_TYPES.includes(mapToUserFacingType(node.componentType))));
+}
+export function hasLocalComponentChanges(changed) {
+    return (changed.added.length > 0 ||
+        changed.updated.length > 0 ||
+        changed.removed.length > 0);
+}
+export async function getLocallyChangedComponents(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+    const result = {
+        added: [],
+        updated: [],
+        removed: [],
+    };
     try {
         const deployedProjectNodes = await getDeployedProjectNodes(projectConfig, accountId, deployedBuildId, profile);
-        return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
+        const filteredLocal = filterAutoGeneratedNodes(localProjectNodes);
+        const filteredDeployed = filterAutoGeneratedNodes(deployedProjectNodes);
+        const allUids = new Set([
+            ...Object.keys(filteredLocal),
+            ...Object.keys(filteredDeployed),
+        ]);
+        for (const uid of allUids) {
+            const local = filteredLocal[uid];
+            const deployed = filteredDeployed[uid];
+            if (!local) {
+                result.removed.push(path.join(projectConfig.srcDir, deployed.metaFilePath));
+            }
+            else if (!deployed) {
+                result.added.push(path.join(projectConfig.srcDir, local.metaFilePath));
+            }
+            else if (!isDeepEqual(local, deployed, ['localDev', 'componentDeps'])) {
+                result.updated.push(path.join(projectConfig.srcDir, local.metaFilePath));
+            }
+        }
+        return result;
     }
     catch (err) {
         debugError(err);
-        return false;
+        uiLogger.warn(lib.localDevHelpers.project.compareLocalProjectToDeployed.unableToCompare);
+        return result;
     }
 }
 export async function checkAndInstallDependencies() {
@@ -211,6 +262,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

@@ -291,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();
@@ -306,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;