@hubspot/cli 7.5.1-experimental.0 → 7.5.2-beta.0

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

@@ -0,0 +1,10 @@
+import LocalDevProcess from './LocalDevProcess';
+declare class LocalDevWatcher {
+    private localDevProcess;
+    private watcher;
+    constructor(localDevProcess: LocalDevProcess);
+    private handleWatchEvent;
+    start(): void;
+    stop(): Promise<void>;
+}
+export default LocalDevWatcher;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const constants_1 = require("../../constants");
+const WATCH_EVENTS = {
+    add: 'add',
+    change: 'change',
+    unlink: 'unlink',
+    unlinkDir: 'unlinkDir',
+};
+class LocalDevWatcher {
+    localDevProcess;
+    watcher;
+    constructor(localDevProcess) {
+        this.localDevProcess = localDevProcess;
+        this.watcher = null;
+    }
+    handleWatchEvent(filePath, event, configPaths) {
+        if (configPaths.includes(filePath)) {
+            return this.localDevProcess.handleConfigFileChange(filePath, event);
+        }
+        return this.localDevProcess.handleFileChange(filePath, event);
+    }
+    start() {
+        this.watcher = chokidar_1.default.watch(this.localDevProcess.projectDir, {
+            ignoreInitial: true,
+            ignored: ['**/dist'],
+        });
+        const configPaths = Object.values(this.localDevProcess.projectNodes).map(component => component.localDev.componentConfigPath);
+        const projectConfigPath = path_1.default.join(this.localDevProcess.projectDir, constants_1.PROJECT_CONFIG_FILE);
+        configPaths.push(projectConfigPath);
+        this.watcher.on('add', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.add, configPaths);
+        });
+        this.watcher.on('change', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.change, configPaths);
+        });
+        this.watcher.on('unlink', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.unlink, configPaths);
+        });
+        this.watcher.on('unlinkDir', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.unlinkDir, configPaths);
+        });
+    }
+    async stop() {
+        await this.watcher?.close();
+    }
+}
+exports.default = LocalDevWatcher;

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

@@ -0,0 +1,20 @@
+import LocalDevProcess from './LocalDevProcess';
+declare class LocalDevWebsocketServer {
+    private server?;
+    private _websocket?;
+    private debug?;
+    private localDevProcess;
+    private ALLOWED_ORIGINS;
+    constructor(localDevProcess: LocalDevProcess, debug?: boolean);
+    private websocket;
+    private log;
+    private logError;
+    private sendMessage;
+    private handleUpload;
+    private setupMessageHandlers;
+    private sendProjectData;
+    private setupStateListeners;
+    start(): Promise<void>;
+    shutdown(): void;
+}
+export default LocalDevWebsocketServer;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -0,0 +1,130 @@
+"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");
+const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
+const LOG_PREFIX = '[LocalDevWebsocketServer]';
+class LocalDevWebsocketServer {
+    server;
+    _websocket;
+    debug;
+    localDevProcess;
+    ALLOWED_ORIGINS = [
+        'https://hubspot.com',
+        'https://hubspotqa.com',
+        'https://local.hubspot.com',
+        'https://local.hubspotqa.com',
+    ];
+    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);
+        }
+    }
+    logError(message) {
+        if (this.debug) {
+            logger_1.logger.error(LOG_PREFIX, message);
+        }
+    }
+    sendMessage(message) {
+        this.websocket().send(JSON.stringify(message));
+    }
+    async handleUpload() {
+        const uploadSuccess = await this.localDevProcess.uploadProject();
+        if (uploadSuccess) {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
+            });
+        }
+        else {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            });
+        }
+    }
+    setupMessageHandlers() {
+        this.websocket().on('message', data => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (!message.type) {
+                    this.logError(en_1.lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
+                    return;
+                }
+                switch (message.type) {
+                    case constants_1.LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
+                        this.handleUpload();
+                        break;
+                    default:
+                        this.logError(en_1.lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
+                }
+            }
+            catch (e) {
+                this.logError(en_1.lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
+            }
+        });
+    }
+    sendProjectData() {
+        this.sendMessage({
+            type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+            data: {
+                projectName: this.localDevProcess.projectName,
+                projectId: this.localDevProcess.projectId,
+                targetProjectAccountId: this.localDevProcess.targetProjectAccountId,
+                targetTestingAccountId: this.localDevProcess.targetTestingAccountId,
+            },
+        });
+    }
+    setupStateListeners() {
+        this.localDevProcess.addStateListener('projectNodes', nodes => {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+                data: nodes,
+            });
+        }, true);
+        this.localDevProcess.addStateListener('appData', appData => {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
+                data: appData,
+            });
+        }, true);
+    }
+    async start() {
+        const portManagerIsRunning = await (0, portManager_1.isPortManagerServerRunning)();
+        if (!portManagerIsRunning) {
+            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
+        }
+        const portData = await (0, portManager_1.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, req) => {
+            const origin = req.headers.origin;
+            if (!origin || !this.ALLOWED_ORIGINS.includes(origin)) {
+                ws.close(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
+                return;
+            }
+            this._websocket = ws;
+            this.sendProjectData();
+            this.setupMessageHandlers();
+            this.setupStateListeners();
+        });
+    }
+    shutdown() {
+        this.server?.close();
+        this.server = undefined;
+        this._websocket = undefined;
+    }
+}
+exports.default = LocalDevWebsocketServer;

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

@@ -2,11 +2,11 @@ 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 { ProjectConfig } from '../types/Projects';
-import { ProjectDevTargetAccountPromptResponse } from '../types/Prompts';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { ProjectConfig } from '../../../types/Projects';
+import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt';
 export declare function confirmDefaultAccountIsTarget(accountConfig: CLIAccount): Promise<void>;
-export declare function checkIfDefaultAccountIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): 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>;
@@ -14,5 +14,7 @@ export declare function createSandboxForLocalDev(accountId: number, accountConfi
 export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): 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): Promise<Build>;
+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/{localDev.js → projects/localDev/helpers.js}

@@ -14,7 +14,8 @@ exports.useExistingDevTestAccount = useExistingDevTestAccount;
 exports.createNewProjectForLocalDev = createNewProjectForLocalDev;
 exports.createInitialBuildForNewProject = createInitialBuildForNewProject;
 exports.getAccountHomeUrl = getAccountHomeUrl;
-const logger_1 = require("@hubspot/local-dev-lib/logger");
+exports.hasSandboxes = hasSandboxes;
+exports.selectAccountTypePrompt = selectAccountTypePrompt;
 const config_1 = require("@hubspot/local-dev-lib/constants/config");
 const index_1 = require("@hubspot/local-dev-lib/errors/index");
 const urls_1 = require("@hubspot/local-dev-lib/urls");
@@ -23,70 +24,59 @@ const projects_1 = require("@hubspot/local-dev-lib/api/projects");
 const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
 const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
 const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
-const projectDevTargetAccountPrompt_1 = require("./prompts/projectDevTargetAccountPrompt");
-const promptUtils_1 = require("./prompts/promptUtils");
-const sandboxes_1 = require("./sandboxes");
-const sandboxSync_1 = require("./sandboxSync");
-const developerTestAccounts_1 = require("./developerTestAccounts");
-const ui_1 = require("./ui");
-const SpinniesManager_1 = __importDefault(require("./ui/SpinniesManager"));
-const lang_1 = require("./lang");
-const exitCodes_1 = require("./enums/exitCodes");
-const usageTracking_1 = require("./usageTracking");
-const accountTypes_1 = require("./accountTypes");
-const upload_1 = require("./projects/upload");
-const buildAndDeploy_1 = require("./projects/buildAndDeploy");
-const constants_1 = require("./constants");
-const index_2 = require("./errorHandlers/index");
-const buildAccount_1 = require("./buildAccount");
-const accountNamePrompt_1 = require("./prompts/accountNamePrompt");
-const i18nKey = 'lib.localDev';
+const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
+const projectDevTargetAccountPrompt_1 = require("../../prompts/projectDevTargetAccountPrompt");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const sandboxes_1 = require("../../sandboxes");
+const sandboxSync_1 = require("../../sandboxSync");
+const developerTestAccounts_1 = require("../../developerTestAccounts");
+const ui_1 = require("../../ui");
+const SpinniesManager_1 = __importDefault(require("../../ui/SpinniesManager"));
+const exitCodes_1 = require("../../enums/exitCodes");
+const usageTracking_1 = require("../../usageTracking");
+const accountTypes_1 = require("../../accountTypes");
+const upload_1 = require("../../projects/upload");
+const buildAndDeploy_1 = require("../../projects/buildAndDeploy");
+const constants_1 = require("../../constants");
+const index_2 = require("../../errorHandlers/index");
+const buildAccount_1 = require("../../buildAccount");
+const accountNamePrompt_1 = require("../../prompts/accountNamePrompt");
+const en_1 = require("../../../lang/en");
+const logger_1 = require("../../ui/logger");
 // If the user passed in the --account flag, confirm they want to use that account as
 // their target account, otherwise exit
 async function confirmDefaultAccountIsTarget(accountConfig) {
     if (!accountConfig.name || !accountConfig.accountType) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.confirmDefaultAccountIsTarget.configError`, {
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
-        }));
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.confirmDefaultAccountIsTarget.configError);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-    logger_1.logger.log();
+    logger_1.uiLogger.log('');
     const useDefaultAccount = await (0, projectDevTargetAccountPrompt_1.confirmDefaultAccountPrompt)(accountConfig.name, config_1.HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
     if (!useDefaultAccount) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`, {
-            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
-            devCommand: (0, ui_1.uiCommandReference)('hs project dev'),
-        }));
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.confirmDefaultAccountIsTarget
+            .declineDefaultAccountExplanation);
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
 // Confirm the default account is supported for the type of apps being developed
-function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
+async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
+    const defaultAccountIsUnified = await (0, accountTypes_1.isUnifiedAccount)(accountConfig);
     if (hasPublicApps &&
         !((0, accountTypes_1.isAppDeveloperAccount)(accountConfig) ||
-            (0, accountTypes_1.isDeveloperTestAccount)(accountConfig))) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.checkIfDefaultAccountIsSupported.publicApp`, {
-            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
-        }));
+            (0, accountTypes_1.isDeveloperTestAccount)(accountConfig) ||
+            defaultAccountIsUnified)) {
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.checkIfDefaultAccountIsSupported.publicApp);
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
     else if (!hasPublicApps && (0, accountTypes_1.isAppDeveloperAccount)(accountConfig)) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.checkIfDefaultAccountIsSupported.privateApp`, {
-            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
-        }));
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.checkIfDefaultAccountIsSupported.privateApp);
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
 function checkIfParentAccountIsAuthed(accountConfig) {
     if (!accountConfig.parentAccountId ||
         !(0, config_2.getAccountConfig)(accountConfig.parentAccountId)) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.checkIfParentAccountIsAuthed.notAuthedError`, {
-            accountId: accountConfig.parentAccountId || '',
-            accountIdentifier: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig)),
-            authCommand: (0, ui_1.uiCommandReference)(`hs auth --account=${accountConfig.parentAccountId}`),
-        }));
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig))));
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
@@ -94,34 +84,30 @@ function checkIfParentAccountIsAuthed(accountConfig) {
 function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
     if (hasPublicApps) {
         if (!(0, accountTypes_1.isDeveloperTestAccount)(accountConfig)) {
-            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.invalidPublicAppAccount`, {
-                useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
-                devCommand: (0, ui_1.uiCommandReference)('hs project dev'),
-            }));
+            logger_1.uiLogger.error(en_1.lib.localDevHelpers.validateAccountOption.invalidPublicAppAccount);
             process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
         }
         checkIfParentAccountIsAuthed(accountConfig);
     }
     else if ((0, accountTypes_1.isAppDeveloperAccount)(accountConfig)) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.invalidPrivateAppAccount`, {
-            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
-        }));
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.validateAccountOption.invalidPrivateAppAccount);
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
 // If the user isn't using the recommended account type, prompt them to use or create one
 async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
-    logger_1.logger.log();
+    logger_1.uiLogger.log('');
     (0, ui_1.uiLine)();
     if (hasPublicApps) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.publicAppNonDeveloperTestAccountWarning`));
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.validateAccountOption
+            .publicAppNonDeveloperTestAccountWarning);
     }
     else {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.nonSandboxWarning`));
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.validateAccountOption.nonSandboxWarning);
     }
     (0, ui_1.uiLine)();
-    logger_1.logger.log();
-    const targetAccountPrompt = (0, accountTypes_1.isAppDeveloperAccount)(accountConfig)
+    logger_1.uiLogger.log('');
+    const targetAccountPrompt = hasPublicApps
         ? projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt
         : projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt;
     return targetAccountPrompt(accounts, accountConfig);
@@ -133,15 +119,10 @@ async function createSandboxForLocalDev(accountId, accountConfig, env) {
     }
     catch (err) {
         if ((0, index_1.isMissingScopeError)(err)) {
-            logger_1.logger.error((0, lang_1.i18n)('lib.sandbox.create.failure.scopes.message', {
-                accountName: accountConfig.name || accountId,
-            }));
+            logger_1.uiLogger.error(en_1.lib.sandbox.create.developer.failure.scopes.message);
             const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
             const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-            logger_1.logger.info((0, lang_1.i18n)('lib.sandbox.create.failure.scopes.instructions', {
-                accountName: accountConfig.name || accountId,
-                url,
-            }));
+            logger_1.uiLogger.info(en_1.lib.sandbox.create.developer.failure.scopes.instructions(accountConfig.name || accountId, url));
         }
         else {
             (0, index_2.logError)(err);
@@ -157,7 +138,7 @@ async function createSandboxForLocalDev(accountId, accountConfig, env) {
         const targetAccountId = result.sandbox.sandboxHubId;
         const sandboxAccountConfig = (0, config_2.getAccountConfig)(result.sandbox.sandboxHubId);
         if (!sandboxAccountConfig) {
-            logger_1.logger.error((0, lang_1.i18n)('lib.sandbox.create.failure.generic'));
+            logger_1.uiLogger.error(en_1.lib.sandbox.create.developer.failure.generic);
             process.exit(exitCodes_1.EXIT_CODES.ERROR);
         }
         const syncTasks = await (0, sandboxes_1.getAvailableSyncTypes)(accountConfig, sandboxAccountConfig);
@@ -185,15 +166,10 @@ async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, e
     }
     catch (err) {
         if ((0, index_1.isMissingScopeError)(err)) {
-            logger_1.logger.error((0, lang_1.i18n)('lib.developerTestAccount.create.failure.scopes.message', {
-                accountName: accountConfig.name || accountId,
-            }));
+            logger_1.uiLogger.error(en_1.lib.developerTestAccount.create.failure.scopes.message);
             const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
             const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-            logger_1.logger.info((0, lang_1.i18n)('lib.developerTestAccount.create.failure.scopes.instructions', {
-                accountName: accountConfig.name || accountId,
-                url,
-            }));
+            logger_1.uiLogger.info(en_1.lib.developerTestAccount.create.failure.scopes.instructions(accountConfig.name || accountId, url));
         }
         else {
             (0, index_2.logError)(err);
@@ -207,7 +183,7 @@ async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, e
         });
         (0, usageTracking_1.trackCommandMetadataUsage)('developer-test-account-create', { step: 'project-dev' }, accountId);
         const result = await (0, buildAccount_1.buildDeveloperTestAccount)(name, accountConfig, env, maxTestPortals);
-        return result.id;
+        return result;
     }
     catch (err) {
         (0, index_2.logError)(err);
@@ -218,91 +194,86 @@ async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, e
 async function useExistingDevTestAccount(env, account) {
     const useExistingDevTestAcct = await (0, projectDevTargetAccountPrompt_1.confirmUseExistingDeveloperTestAccountPrompt)(account);
     if (!useExistingDevTestAcct) {
-        logger_1.logger.log('');
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`, {
-            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
-            devCommand: (0, ui_1.uiCommandReference)('hs project dev'),
-        }));
-        logger_1.logger.log('');
+        logger_1.uiLogger.log('');
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.confirmDefaultAccountIsTarget
+            .declineDefaultAccountExplanation);
+        logger_1.uiLogger.log('');
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
     const devTestAcctConfigName = await (0, buildAccount_1.saveAccountToConfig)(account.id, account.accountName, env);
-    logger_1.logger.success((0, lang_1.i18n)(`lib.developerTestAccount.create.success.configFileUpdated`, {
-        accountName: devTestAcctConfigName,
-        authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.name,
-    }));
+    logger_1.uiLogger.success(en_1.lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
 }
 // Prompt the user to create a new project if one doesn't exist on their target account
 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 explanationString = (0, lang_1.i18n)(hasPublicApps
-            ? `${i18nKey}.createNewProjectForLocalDev.publicAppProjectMustExistExplanation`
-            : `${i18nKey}.createNewProjectForLocalDev.projectMustExistExplanation`, {
-            accountIdentifier: (0, ui_1.uiAccountDescription)(targetAccountId),
-            projectName: projectConfig.name,
-        });
-        logger_1.logger.log();
+        const explanationLangFunction = hasPublicApps
+            ? en_1.lib.localDevHelpers.createNewProjectForLocalDev
+                .publicAppProjectMustExistExplanation
+            : en_1.lib.localDevHelpers.createNewProjectForLocalDev
+                .projectMustExistExplanation;
+        const explanationString = explanationLangFunction(projectConfig.name, targetAccountId);
+        logger_1.uiLogger.log('');
         (0, ui_1.uiLine)();
-        logger_1.logger.log(explanationString);
+        logger_1.uiLogger.log(explanationString);
         (0, ui_1.uiLine)();
-        shouldCreateProject = await (0, promptUtils_1.confirmPrompt)((0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.createProject`, {
-            accountIdentifier: (0, ui_1.uiAccountDescription)(targetAccountId),
-            projectName: projectConfig.name,
-        }));
+        shouldCreateProject = await (0, promptUtils_1.confirmPrompt)(en_1.lib.localDevHelpers.createNewProjectForLocalDev.createProject(projectConfig.name, (0, ui_1.uiAccountDescription)(targetAccountId)));
     }
     if (shouldCreateProject) {
         SpinniesManager_1.default.add('createProject', {
-            text: (0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.creatingProject`, {
-                accountIdentifier: (0, ui_1.uiAccountDescription)(targetAccountId),
-                projectName: projectConfig.name,
-            }),
+            text: en_1.lib.localDevHelpers.createNewProjectForLocalDev.creatingProject(projectConfig.name, (0, ui_1.uiAccountDescription)(targetAccountId)),
         });
         try {
             const { data: project } = await (0, projects_1.createProject)(targetAccountId, projectConfig.name);
             SpinniesManager_1.default.succeed('createProject', {
-                text: (0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.createdProject`, {
-                    accountIdentifier: (0, ui_1.uiAccountDescription)(targetAccountId),
-                    projectName: projectConfig.name,
-                }),
+                text: en_1.lib.localDevHelpers.createNewProjectForLocalDev.createdProject(projectConfig.name, (0, ui_1.uiAccountDescription)(targetAccountId)),
                 succeedColor: 'white',
             });
             return project;
         }
         catch (err) {
             SpinniesManager_1.default.fail('createProject');
-            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.failedToCreateProject`));
+            logger_1.uiLogger.log(en_1.lib.localDevHelpers.createNewProjectForLocalDev.failedToCreateProject);
             process.exit(exitCodes_1.EXIT_CODES.ERROR);
         }
     }
     else {
         // We cannot continue if the project does not exist in the target account
-        logger_1.logger.log();
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.choseNotToCreateProject`));
+        logger_1.uiLogger.log('');
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.createNewProjectForLocalDev.choseNotToCreateProject);
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
 function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
     if (!buildId) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.createInitialBuildForNewProject.initialUploadMessage`, {
-            uploadCommand: (0, ui_1.uiCommandReference)('hs project upload'),
-        }));
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.createInitialBuildForNewProject.genericError);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     return (0, buildAndDeploy_1.pollProjectBuildAndDeploy)(accountId, projectConfig, tempFile, buildId, true);
 }
 // Create an initial build if the project was newly created in the account
 // Return the newly deployed build
-async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIr) {
-    const { result: initialUploadResult, uploadError } = await (0, upload_1.handleProjectUpload)(targetAccountId, projectConfig, projectDir, projectUploadCallback, (0, lang_1.i18n)(`${i18nKey}.createInitialBuildForNewProject.initialUploadMessage`), sendIr);
+async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
+    const { result: initialUploadResult, uploadError } = await (0, upload_1.handleProjectUpload)({
+        accountId: targetAccountId,
+        projectConfig,
+        projectDir,
+        callbackFunc: projectUploadCallback,
+        uploadMessage: en_1.lib.localDevHelpers.createInitialBuildForNewProject
+            .initialUploadMessage,
+        forceCreate: true,
+        skipValidation: true,
+        sendIR,
+        profile,
+    });
     if (uploadError) {
         if ((0, index_1.isSpecifiedError)(uploadError, {
             subCategory: constants_1.PROJECT_ERROR_TYPES.PROJECT_LOCKED,
         })) {
-            logger_1.logger.log();
-            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.createInitialBuildForNewProject.projectLockedError`));
-            logger_1.logger.log();
+            logger_1.uiLogger.log('');
+            logger_1.uiLogger.error(en_1.lib.localDevHelpers.createInitialBuildForNewProject.projectLockedError);
+            logger_1.uiLogger.log('');
         }
         else {
             (0, index_2.logError)(uploadError, new index_2.ApiErrorContext({
@@ -323,11 +294,11 @@ async function createInitialBuildForNewProject(projectConfig, projectDir, target
                 initialUploadResult.deployResult[constants_1.PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
         }
         const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
-        logger_1.logger.log();
+        logger_1.uiLogger.log('');
         failedSubTasks.forEach(failedSubTask => {
-            logger_1.logger.error(failedSubTask.errorMessage);
+            logger_1.uiLogger.error(failedSubTask.errorMessage);
         });
-        logger_1.logger.log();
+        logger_1.uiLogger.log('');
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     return initialUploadResult.buildResult;
@@ -336,3 +307,45 @@ function getAccountHomeUrl(accountId) {
     const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_2.getEnv)(accountId) === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
     return `${baseUrl}/home?portalId=${accountId}`;
 }
+async function hasSandboxes(account) {
+    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(account);
+    if (!accountId) {
+        return false;
+    }
+    try {
+        const { data: { usage }, } = await (0, sandboxHubs_1.getSandboxUsageLimits)(accountId);
+        return usage.STANDARD.limit > 0 || usage.DEVELOPER.limit > 0;
+    }
+    catch (e) {
+        (0, index_2.debugError)(e);
+        return false;
+    }
+}
+// Top level prompt to choose the type of account to test on
+async function selectAccountTypePrompt(accountConfig) {
+    const hasAccessToSandboxes = await hasSandboxes(accountConfig);
+    const result = await (0, promptUtils_1.listPrompt)(en_1.lib.localDevHelpers.selectAccountTypePrompt.message, {
+        choices: [
+            {
+                name: en_1.lib.localDevHelpers.selectAccountTypePrompt
+                    .developerTestAccountOption,
+                value: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            },
+            {
+                name: en_1.lib.localDevHelpers.selectAccountTypePrompt
+                    .sandboxAccountOption,
+                value: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                disabled: !hasAccessToSandboxes
+                    ? en_1.lib.localDevHelpers.selectAccountTypePrompt
+                        .sandboxAccountOptionDisabled
+                    : false,
+            },
+            {
+                name: en_1.lib.localDevHelpers.selectAccountTypePrompt
+                    .productionAccountOption,
+                value: null,
+            },
+        ],
+    });
+    return result;
+}

package/lib/projects/ui.d.ts

@@ -0,0 +1 @@
+export declare function logFeedbackMessage(buildId: number): void;