@hubspot/cli 7.7.0-experimental.3 → 7.7.0

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -1,92 +1,183 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ws_1 = require("ws");
-const portManager_1 = require("@hubspot/local-dev-lib/portManager");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const constants_1 = require("../../constants");
-const en_1 = require("../../../lang/en");
+import { WebSocketServer } from 'ws';
+import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { addLocalStateFlag } from '@hubspot/local-dev-lib/config';
+import { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, } from '../../constants.js';
+import { lib } from '../../../lang/en.js';
+import { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
+import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, } from './localDevWebsocketServerUtils.js';
+import pkg from '../../../package.json' with { type: 'json' };
 const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
+const LOCAL_DEV_WEBSOCKET_SERVER_VERSION = 1;
 const LOG_PREFIX = '[LocalDevWebsocketServer]';
+const DOMAINS = ['hubspot.com', 'hubspotqa.com'];
+const SUBDOMAINS = ['local', 'app', 'app-na2', 'app-na3', 'app-ap1', 'app-eu1'];
+const ALLOWED_ORIGIN_REGEX = new RegExp(`^https://(${SUBDOMAINS.join('|')})\\.(${DOMAINS.join('|')})$`);
 class LocalDevWebsocketServer {
     server;
-    _websocket;
     debug;
     localDevProcess;
     constructor(localDevProcess, debug) {
         this.localDevProcess = localDevProcess;
         this.debug = debug;
     }
-    websocket() {
-        if (!this._websocket) {
-            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.notInitialized(LOG_PREFIX));
-        }
-        return this._websocket;
-    }
     log(message) {
         if (this.debug) {
-            logger_1.logger.log(LOG_PREFIX, message);
+            logger.log(LOG_PREFIX, message);
         }
     }
     logError(message) {
         if (this.debug) {
-            logger_1.logger.error(LOG_PREFIX, message);
+            logger.error(LOG_PREFIX, message);
         }
     }
-    sendMessage(message) {
-        this.websocket().send(JSON.stringify(message));
+    sendMessage(websocket, message) {
+        websocket.send(JSON.stringify(message));
+    }
+    async handleUpload(websocket) {
+        const { uploadSuccess, buildSuccess, deploySuccess, deployId } = await this.localDevProcess.uploadProject();
+        this.sendMessage(websocket, {
+            type: uploadSuccess
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                buildSuccess,
+                deploySuccess,
+                deployId,
+            },
+        });
+    }
+    async handleDeploy(websocket, force) {
+        const { success, deployId } = await this.localDevProcess.deployLatestBuild(force);
+        this.sendMessage(websocket, {
+            type: success
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                latestDeployId: deployId,
+            },
+        });
     }
-    setupMessageHandlers() {
-        this.websocket().on('message', data => {
+    setupMessageHandlers(websocket) {
+        websocket.on('message', data => {
             try {
                 const message = JSON.parse(data.toString());
                 if (!message.type) {
-                    this.logError(en_1.lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
+                    this.logError(lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
                     return;
                 }
-                switch (message.type) {
-                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.UPLOAD:
-                        this.localDevProcess.uploadProject();
-                        break;
-                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.INSTALL_DEPS:
-                        break;
-                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.APP_INSTALLED:
-                        break;
-                    default:
-                        this.logError(en_1.lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
+                if (isUploadWebsocketMessage(message)) {
+                    this.handleUpload(websocket);
+                }
+                else if (isDeployWebsocketMessage(message)) {
+                    this.handleDeploy(websocket, message.data.force);
+                }
+                else if (isViewedWelcomeScreenWebsocketMessage(message)) {
+                    addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
+                }
+                else {
+                    this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
                 }
             }
             catch (e) {
-                this.logError(en_1.lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
+                this.logError(lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
             }
         });
     }
-    setupStateListeners() {
-        this.localDevProcess.addStateListener('projectNodes', nodes => {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.UPDATE_PROJECT_NODES,
+    sendCliMetadata(websocket) {
+        this.sendMessage(websocket, {
+            type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.CLI_METADATA,
+            data: {
+                cliVersion: pkg.version,
+                localDevWebsocketServerVersion: LOCAL_DEV_WEBSOCKET_SERVER_VERSION,
+            },
+        });
+    }
+    sendProjectData(websocket) {
+        this.sendMessage(websocket, {
+            type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+            data: {
+                projectName: this.localDevProcess.projectData.name,
+                projectId: this.localDevProcess.projectData.id,
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                targetProjectAccountId: this.localDevProcess.targetProjectAccountId,
+                targetTestingAccountId: this.localDevProcess.targetTestingAccountId,
+            },
+        });
+    }
+    setupProjectNodesListener(websocket) {
+        const listener = (nodes) => {
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
                 data: nodes,
             });
+        };
+        this.localDevProcess.addStateListener('projectNodes', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('projectNodes', listener);
+        });
+    }
+    setupAppDataListener(websocket) {
+        const listener = (appData) => {
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
+                data: appData,
+            });
+        };
+        this.localDevProcess.addStateListener('appData', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('appData', listener);
         });
     }
+    setupUploadWarningsListener(websocket) {
+        const listener = (uploadWarnings) => {
+            const formattedUploadWarnings = Array.from(uploadWarnings).map(removeAnsiCodes);
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_UPLOAD_WARNINGS,
+                data: { uploadWarnings: formattedUploadWarnings },
+            });
+        };
+        this.localDevProcess.addStateListener('uploadWarnings', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('uploadWarnings', listener);
+        });
+    }
+    setupStateListeners(websocket) {
+        this.setupProjectNodesListener(websocket);
+        this.setupAppDataListener(websocket);
+        this.setupUploadWarningsListener(websocket);
+    }
     async start() {
-        const portManagerIsRunning = await (0, portManager_1.isPortManagerServerRunning)();
+        const portManagerIsRunning = await isPortManagerServerRunning();
         if (!portManagerIsRunning) {
-            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
+            throw new Error(lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
         }
-        const portData = await (0, portManager_1.requestPorts)([{ instanceId: SERVER_INSTANCE_ID }]);
+        const portData = await requestPorts([{ instanceId: SERVER_INSTANCE_ID }]);
         const port = portData[SERVER_INSTANCE_ID];
-        this.server = new ws_1.WebSocketServer({ port });
-        this.log(en_1.lib.LocalDevWebsocketServer.logs.startup(port));
-        this.server.on('connection', ws => {
-            this._websocket = ws;
-            this.setupMessageHandlers();
-            this.setupStateListeners();
+        this.server = new WebSocketServer({ port });
+        this.log(lib.LocalDevWebsocketServer.logs.startup(port));
+        this.server.on('connection', (ws, req) => {
+            const origin = req.headers.origin;
+            if (!origin || !ALLOWED_ORIGIN_REGEX.test(origin)) {
+                ws.close(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
+                return;
+            }
+            this.sendCliMetadata(ws);
+            this.sendProjectData(ws);
+            this.setupMessageHandlers(ws);
+            this.setupStateListeners(ws);
+            this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
+        this.server.on('close', () => { });
     }
     shutdown() {
         this.server?.close();
         this.server = undefined;
-        this._websocket = undefined;
     }
 }
-exports.default = LocalDevWebsocketServer;
+export default LocalDevWebsocketServer;

package/lib/projects/localDev/{helpers.d.ts → helpers/account.d.ts}

@@ -1,20 +1,14 @@
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
-import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts';
-import { Project } from '@hubspot/local-dev-lib/types/Project';
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { ProjectConfig } from '../../../types/Projects';
-import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt';
+import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
+import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
 export declare function confirmDefaultAccountIsTarget(accountConfig: CLIAccount): Promise<void>;
 export declare function checkIfDefaultAccountIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): Promise<void>;
 export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount): void;
 export declare function checkIfAccountFlagIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): void;
 export declare function suggestRecommendedNestedAccount(accounts: CLIAccount[], accountConfig: CLIAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
-export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
+export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV3?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
-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 getAccountHomeUrl(accountId: number): string;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;

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

@@ -0,0 +1,233 @@
+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 { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+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 { 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 ||
+        !getAccountConfig(accountConfig.parentAccountId)) {
+        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
+        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 {
+        await validateSandboxUsageLimits(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
+    }
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            uiLogger.error(lib.sandbox.create.developer.failure.scopes.message);
+            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+            uiLogger.info(lib.sandbox.create.developer.failure.scopes.instructions(accountConfig.name || accountId, url));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    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 = getAccountConfig(result.sandbox.sandboxHubId);
+        if (!sandboxAccountConfig) {
+            uiLogger.error(lib.sandbox.create.developer.failure.generic);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        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;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+// Create a developer test account and return its accountId
+export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV3 = false) {
+    let currentPortalCount = 0;
+    let maxTestPortals = 10;
+    try {
+        const validateResult = await validateDevTestAccountUsageLimits(accountConfig);
+        if (validateResult) {
+            currentPortalCount = validateResult.results
+                ? validateResult.results.length
+                : 0;
+            maxTestPortals = validateResult.maxTestPortals;
+        }
+    }
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            uiLogger.error(lib.developerTestAccount.create.failure.scopes.message);
+            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+            uiLogger.info(lib.developerTestAccount.create.failure.scopes.instructions(accountConfig.name || accountId, url));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const { name } = await hubspotAccountNamePrompt({
+            currentPortalCount,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        });
+        trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
+        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV3);
+        return result;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+// Prompt user to confirm usage of an existing developer test account that is not currently in the config
+export async function useExistingDevTestAccount(env, account) {
+    const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
+    if (!useExistingDevTestAcct) {
+        uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
+            .declineDefaultAccountExplanation);
+        uiLogger.log('');
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
+    uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
+}
+export async function hasSandboxes(account) {
+    const accountId = getAccountIdentifier(account);
+    if (!accountId) {
+        return false;
+    }
+    try {
+        const { data: { usage }, } = await getSandboxUsageLimits(accountId);
+        return usage.STANDARD.limit > 0 || usage.DEVELOPER.limit > 0;
+    }
+    catch (e) {
+        debugError(e);
+        return false;
+    }
+}
+// Top level prompt to choose the type of account to test on
+export async function selectAccountTypePrompt(accountConfig) {
+    const hasAccessToSandboxes = await hasSandboxes(accountConfig);
+    const accountId = getAccountIdentifier(accountConfig);
+    const result = await listPrompt(lib.localDevHelpers.account.selectAccountTypePrompt.message, {
+        choices: [
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
+                    .developerTestAccountOption,
+                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            },
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
+                    .sandboxAccountOption,
+                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                disabled: !hasAccessToSandboxes
+                    ? lib.localDevHelpers.account.selectAccountTypePrompt
+                        .sandboxAccountOptionDisabled
+                    : false,
+            },
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt.productionAccountOption(accountId),
+                value: null,
+            },
+        ],
+    });
+    return result;
+}

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;
+}, profile?: string): Promise<void>;
+export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}, profile?: string): Promise<boolean>;