@hubspot/cli 7.7.27-experimental.1 → 7.7.28-experimental.0

package/lib/projects/localDev/{helpers.js → helpers/account.js}

@@ -1,41 +1,44 @@
-import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
-import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { getAccountConfig, getEnv } from '@hubspot/local-dev-lib/config';
-import { createProject } from '@hubspot/local-dev-lib/api/projects';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
 import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { confirmDefaultAccountPrompt, selectSandboxTargetAccountPrompt, selectDeveloperTestTargetAccountPrompt, confirmUseExistingDeveloperTestAccountPrompt, } from '../../prompts/projectDevTargetAccountPrompt.js';
-import { confirmPrompt, listPrompt } from '../../prompts/promptUtils.js';
-import { validateSandboxUsageLimits, getAvailableSyncTypes, } from '../../sandboxes.js';
-import { syncSandbox } from '../../sandboxSync.js';
-import { validateDevTestAccountUsageLimits } from '../../developerTestAccounts.js';
-import { uiLine, uiAccountDescription } from '../../ui/index.js';
-import SpinniesManager from '../../ui/SpinniesManager.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { trackCommandMetadataUsage } from '../../usageTracking.js';
-import { isAppDeveloperAccount, isDeveloperTestAccount, isUnifiedAccount, } from '../../accountTypes.js';
-import { handleProjectUpload } from '../../projects/upload.js';
-import { pollProjectBuildAndDeploy } from '../../projects/buildAndDeploy.js';
-import { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } from '../../constants.js';
-import { logError, ApiErrorContext, debugError, } from '../../errorHandlers/index.js';
-import { buildSandbox, buildDeveloperTestAccount, saveAccountToConfig, } from '../../buildAccount.js';
-import { hubspotAccountNamePrompt } from '../../prompts/accountNamePrompt.js';
-import { lib } from '../../../lang/en.js';
-import { uiLogger } from '../../ui/logger.js';
+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 { 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.confirmDefaultAccountIsTarget.configError);
+        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.confirmDefaultAccountIsTarget
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
         process.exit(EXIT_CODES.SUCCESS);
     }
@@ -47,18 +50,18 @@ export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicA
         !(isAppDeveloperAccount(accountConfig) ||
             isDeveloperTestAccount(accountConfig) ||
             defaultAccountIsUnified)) {
-        uiLogger.error(lib.localDevHelpers.checkIfDefaultAccountIsSupported.publicApp);
+        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
         process.exit(EXIT_CODES.SUCCESS);
     }
     else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.checkIfDefaultAccountIsSupported.privateApp);
+        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.privateApp);
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
 export function checkIfParentAccountIsAuthed(accountConfig) {
     if (!accountConfig.parentAccountId ||
         !getAccountConfig(accountConfig.parentAccountId)) {
-        uiLogger.error(lib.localDevHelpers.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
+        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
@@ -66,13 +69,14 @@ export function checkIfParentAccountIsAuthed(accountConfig) {
 export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
     if (hasPublicApps) {
         if (!isDeveloperTestAccount(accountConfig)) {
-            uiLogger.error(lib.localDevHelpers.validateAccountOption.invalidPublicAppAccount);
+            uiLogger.error(lib.localDevHelpers.account.validateAccountOption
+                .invalidPublicAppAccount);
             process.exit(EXIT_CODES.SUCCESS);
         }
         checkIfParentAccountIsAuthed(accountConfig);
     }
     else if (isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.validateAccountOption.invalidPrivateAppAccount);
+        uiLogger.error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
@@ -81,11 +85,11 @@ export async function suggestRecommendedNestedAccount(accounts, accountConfig, h
     uiLogger.log('');
     uiLine();
     if (hasPublicApps) {
-        uiLogger.log(lib.localDevHelpers.validateAccountOption
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption
             .publicAppNonDeveloperTestAccountWarning);
     }
     else {
-        uiLogger.log(lib.localDevHelpers.validateAccountOption.nonSandboxWarning);
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption.nonSandboxWarning);
     }
     uiLine();
     uiLogger.log('');
@@ -177,7 +181,7 @@ export async function useExistingDevTestAccount(env, account) {
     const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
     if (!useExistingDevTestAcct) {
         uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.confirmDefaultAccountIsTarget
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
         uiLogger.log('');
         process.exit(EXIT_CODES.SUCCESS);
@@ -185,110 +189,6 @@ export async function useExistingDevTestAccount(env, account) {
     const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
     uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
 }
-// 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.createNewProjectForLocalDev
-                .publicAppProjectMustExistExplanation
-            : lib.localDevHelpers.createNewProjectForLocalDev
-                .projectMustExistExplanation;
-        const explanationString = explanationLangFunction(projectConfig.name, targetAccountId);
-        uiLogger.log('');
-        uiLine();
-        uiLogger.log(explanationString);
-        uiLine();
-        shouldCreateProject = await confirmPrompt(lib.localDevHelpers.createNewProjectForLocalDev.createProject(projectConfig.name, uiAccountDescription(targetAccountId)));
-    }
-    if (shouldCreateProject) {
-        SpinniesManager.add('createProject', {
-            text: lib.localDevHelpers.createNewProjectForLocalDev.creatingProject(projectConfig.name, uiAccountDescription(targetAccountId)),
-        });
-        try {
-            const { data: project } = await createProject(targetAccountId, projectConfig.name);
-            SpinniesManager.succeed('createProject', {
-                text: lib.localDevHelpers.createNewProjectForLocalDev.createdProject(projectConfig.name, uiAccountDescription(targetAccountId)),
-                succeedColor: 'white',
-            });
-            return project;
-        }
-        catch (err) {
-            SpinniesManager.fail('createProject');
-            uiLogger.log(lib.localDevHelpers.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.createNewProjectForLocalDev.choseNotToCreateProject);
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-}
-function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
-    if (!buildId) {
-        uiLogger.error(lib.localDevHelpers.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.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.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 function getAccountHomeUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
-    return `${baseUrl}/home?portalId=${accountId}`;
-}
 export async function hasSandboxes(account) {
     const accountId = getAccountIdentifier(account);
     if (!accountId) {
@@ -306,25 +206,25 @@ export async function hasSandboxes(account) {
 // Top level prompt to choose the type of account to test on
 export async function selectAccountTypePrompt(accountConfig) {
     const hasAccessToSandboxes = await hasSandboxes(accountConfig);
-    const result = await listPrompt(lib.localDevHelpers.selectAccountTypePrompt.message, {
+    const accountId = getAccountIdentifier(accountConfig);
+    const result = await listPrompt(lib.localDevHelpers.account.selectAccountTypePrompt.message, {
         choices: [
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
                     .developerTestAccountOption,
                 value: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
             },
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
                     .sandboxAccountOption,
                 value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 disabled: !hasAccessToSandboxes
-                    ? lib.localDevHelpers.selectAccountTypePrompt
+                    ? lib.localDevHelpers.account.selectAccountTypePrompt
                         .sandboxAccountOptionDisabled
                     : false,
             },
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
-                    .productionAccountOption,
+                name: lib.localDevHelpers.account.selectAccountTypePrompt.productionAccountOption(accountId),
                 value: null,
             },
         ],

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

@@ -0,0 +1,12 @@
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+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>;
+export declare function compareLocalProjectToDeployed(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number | undefined, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}): Promise<void>;
+export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}): Promise<boolean>;

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

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

package/lib/projects/urls.d.ts

@@ -6,3 +6,4 @@ export declare function getProjectActivityUrl(projectName: string, accountId: nu
 export declare function getProjectBuildDetailUrl(projectName: string, buildId: number, accountId: number): string;
 export declare function getProjectDeployDetailUrl(projectName: string, deployId: number, accountId: number): string;
 export declare function getLocalDevUiUrl(accountId: number, showWelcomeScreen?: boolean): string;
+export declare function getAccountHomeUrl(accountId: number): string;

package/lib/projects/urls.js

@@ -37,3 +37,7 @@ export function getProjectDeployDetailUrl(projectName, deployId, accountId) {
 export function getLocalDevUiUrl(accountId, showWelcomeScreen) {
     return `${getBaseUrl(accountId)}/developer-projects-local-dev/${accountId}${showWelcomeScreen ? '?welcome' : ''}`;
 }
+export function getAccountHomeUrl(accountId) {
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    return `${baseUrl}/home?portalId=${accountId}`;
+}

package/lib/prompts/__tests__/createFunctionPrompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/prompts/__tests__/createFunctionPrompt.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createFunctionPrompt } from '../createFunctionPrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createFunctionPrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when all parameters are provided', () => {
+        it('should return provided values without prompting', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointMethod: 'POST',
+                endpointPath: '/api/test',
+            };
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointMethod: 'POST',
+                endpointPath: '/api/test',
+            });
+        });
+        it('should use default GET method when endpointMethod not provided', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointPath: '/api/test',
+            };
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointMethod: 'GET',
+                endpointPath: '/api/test',
+            });
+        });
+    });
+    describe('when some parameters are missing', () => {
+        it('should only prompt for missing parameters', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-functions',
+                endpointMethod: 'POST',
+            };
+            mockPromptUser.mockResolvedValue({
+                filename: 'prompted-function',
+                endpointPath: '/prompted-path',
+            });
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'filename' }),
+                expect.objectContaining({ name: 'endpointPath' }),
+            ]);
+            expect(result).toEqual({
+                functionsFolder: 'my-functions',
+                filename: 'prompted-function',
+                endpointMethod: 'POST',
+                endpointPath: '/prompted-path',
+            });
+        });
+    });
+    describe('when no parameters are provided', () => {
+        it('should prompt for all parameters', async () => {
+            mockPromptUser.mockResolvedValue({
+                functionsFolder: 'prompted-functions',
+                filename: 'prompted-function',
+                endpointMethod: 'GET',
+                endpointPath: '/prompted-path',
+            });
+            const result = await createFunctionPrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'functionsFolder' }),
+                expect.objectContaining({ name: 'filename' }),
+                expect.objectContaining({ name: 'endpointMethod' }),
+                expect.objectContaining({ name: 'endpointPath' }),
+            ]);
+            expect(result).toEqual({
+                functionsFolder: 'prompted-functions',
+                filename: 'prompted-function',
+                endpointMethod: 'GET',
+                endpointPath: '/prompted-path',
+            });
+        });
+    });
+    describe('parameter precedence', () => {
+        it('should prioritize command args over prompted values', async () => {
+            const commandArgs = {
+                functionsFolder: 'arg-functions',
+            };
+            mockPromptUser.mockResolvedValue({
+                filename: 'prompted-function',
+                endpointMethod: 'POST',
+                endpointPath: '/prompted-path',
+            });
+            const result = await createFunctionPrompt(commandArgs);
+            expect(result).toEqual({
+                functionsFolder: 'arg-functions', // from commandArgs
+                filename: 'prompted-function', // from prompt
+                endpointMethod: 'POST', // from prompt
+                endpointPath: '/prompted-path', // from prompt
+            });
+        });
+        it('should handle mixed scenario with partial command args and prompting', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-funcs',
+                endpointMethod: 'DELETE',
+            };
+            mockPromptUser.mockResolvedValue({
+                filename: 'delete-handler',
+                endpointPath: '/api/delete',
+            });
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'filename' }),
+                expect.objectContaining({ name: 'endpointPath' }),
+            ]);
+            expect(result).toEqual({
+                functionsFolder: 'my-funcs', // from commandArgs
+                filename: 'delete-handler', // from prompt
+                endpointMethod: 'DELETE', // from commandArgs
+                endpointPath: '/api/delete', // from prompt
+            });
+        });
+    });
+});

package/lib/prompts/__tests__/createModulePrompt.test.d.ts

@@ -0,0 +1 @@
+export {};