@hubspot/cli 7.5.11-experimental.0 → 7.6.0-beta.1

package/lib/projects/localDev/LocalDevProcess.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const path_1 = __importDefault(require("path"));
+const LocalDevState_1 = __importDefault(require("./LocalDevState"));
+const LocalDevLogger_1 = __importDefault(require("./LocalDevLogger"));
+const DevServerManagerV2_1 = __importDefault(require("./DevServerManagerV2"));
+const exitCodes_1 = require("../../enums/exitCodes");
+const transform_1 = require("@hubspot/project-parsing-lib/src/lib/transform");
+const config_1 = require("../config");
+const upload_1 = require("../upload");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+class LocalDevProcess {
+    state;
+    _logger;
+    devServerManager;
+    constructor(options) {
+        this.state = new LocalDevState_1.default(options);
+        this._logger = new LocalDevLogger_1.default(this.state);
+        this.devServerManager = new DevServerManagerV2_1.default({
+            localDevState: this.state,
+            logger: this._logger,
+        });
+    }
+    get projectDir() {
+        return this.state.projectDir;
+    }
+    get projectId() {
+        return this.state.projectId;
+    }
+    get projectName() {
+        return this.state.projectName;
+    }
+    get targetProjectAccountId() {
+        return this.state.targetProjectAccountId;
+    }
+    get targetTestingAccountId() {
+        return this.state.targetTestingAccountId;
+    }
+    get projectNodes() {
+        return this.state.projectNodes;
+    }
+    get logger() {
+        return this._logger;
+    }
+    get configFilesUpdatedSinceLastUpload() {
+        return this.state.configFilesUpdatedSinceLastUpload;
+    }
+    async setupDevServers() {
+        try {
+            await this.devServerManager.setup();
+            return true;
+        }
+        catch (e) {
+            this.logger.devServerSetupError(e);
+            return false;
+        }
+    }
+    async startDevServers() {
+        try {
+            await this.devServerManager.start();
+        }
+        catch (e) {
+            this.logger.devServerStartError(e);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+    async cleanupDevServers() {
+        try {
+            await this.devServerManager.cleanup();
+            return true;
+        }
+        catch (e) {
+            this.logger.devServerCleanupError(e);
+            return false;
+        }
+    }
+    compareLocalProjectToDeployed() {
+        const deployedComponentNames = this.state.deployedBuild.subbuildStatuses.map(subbuildStatus => subbuildStatus.buildName);
+        const missingProjectNodes = [];
+        Object.values(this.projectNodes).forEach(node => {
+            if (!deployedComponentNames.includes(node.uid)) {
+                const userFriendlyName = (0, transform_1.mapToUserFriendlyName)(node.componentType);
+                const label = userFriendlyName ? `[${userFriendlyName}] ` : '';
+                missingProjectNodes.push(`${label}${node.uid}`);
+            }
+        });
+        if (missingProjectNodes.length) {
+            this.logger.missingComponentsWarning(missingProjectNodes);
+        }
+    }
+    async projectConfigValidForUpload() {
+        const { projectConfig } = await (0, config_1.getProjectConfig)();
+        if (!projectConfig) {
+            return false;
+        }
+        Object.keys(projectConfig).forEach(key => {
+            const field = key;
+            if (projectConfig[field] !== this.state.projectConfig[field]) {
+                return false;
+            }
+        });
+        return true;
+    }
+    async updateProjectNodes() {
+        const intermediateRepresentation = await (0, project_parsing_lib_1.translateForLocalDev)({
+            projectSourceDir: path_1.default.join(this.state.projectDir, this.state.projectConfig.srcDir),
+            platformVersion: this.state.projectConfig.platformVersion,
+            accountId: this.state.targetProjectAccountId,
+        }, {
+            configFilesUpdatedSinceLastUpload: this.state.configFilesUpdatedSinceLastUpload,
+        });
+        this.state.projectNodes =
+            intermediateRepresentation.intermediateNodesIndexedByUid;
+    }
+    async handleFileChange(filePath, event) {
+        await this.updateProjectNodes();
+        try {
+            this.devServerManager.fileChange({ filePath, event });
+        }
+        catch (e) {
+            this.logger.fileChangeError(e);
+        }
+    }
+    async handleConfigFileChange(filePath, event) {
+        if (event === 'add' || event === 'change') {
+            this.state.addUpdatedConfigFileUpdatedSinceLastUpload(filePath);
+        }
+        await this.updateProjectNodes();
+        this.logger.uploadWarning();
+    }
+    async start() {
+        this.logger.resetSpinnies();
+        // Local dev currently relies on the existence of a deployed build in the target account
+        if (!this.state.deployedBuild) {
+            this.logger.noDeployedBuild();
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        }
+        const setupSucceeded = await this.setupDevServers();
+        if (!setupSucceeded) {
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        this.logger.startupMessage();
+        await this.startDevServers();
+        this.logger.monitorConsoleOutput();
+        // Verify that there are no mismatches between components in the local project
+        // and components in the deployed build of the project.
+        this.compareLocalProjectToDeployed();
+    }
+    async stop(showProgress = true) {
+        if (showProgress) {
+            this.logger.cleanupStart();
+        }
+        const cleanupSucceeded = await this.cleanupDevServers();
+        if (!cleanupSucceeded) {
+            if (showProgress) {
+                this.logger.cleanupError();
+            }
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        if (showProgress) {
+            this.logger.cleanupSuccess();
+        }
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    async uploadProject() {
+        this.logger.uploadInitiated();
+        const isUploadable = await this.projectConfigValidForUpload();
+        if (!isUploadable) {
+            this.logger.projectConfigMismatch();
+            return false;
+        }
+        const { uploadError } = await (0, upload_1.handleProjectUpload)({
+            accountId: this.state.targetProjectAccountId,
+            projectConfig: this.state.projectConfig,
+            projectDir: this.state.projectDir,
+            callbackFunc: buildAndDeploy_1.pollProjectBuildAndDeploy,
+            sendIR: true,
+            skipValidation: true,
+        });
+        if (uploadError) {
+            this.logger.uploadError(uploadError);
+            return false;
+        }
+        this.state.resetConfigFilesUpdatedSinceLastUpload();
+        this.updateProjectNodes();
+        this.logger.uploadSuccess();
+        this.logger.clearUploadWarnings();
+        return true;
+    }
+    addStateListener(key, listener, callOnInit = false) {
+        this.state.addListener(key, listener, callOnInit);
+    }
+    sendDevServerMessage(message) {
+        this.state.devServerMessage = message;
+    }
+}
+exports.default = LocalDevProcess;

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

@@ -0,0 +1,50 @@
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { ProjectConfig } from '../../../types/Projects';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev';
+declare class LocalDevState {
+    private _targetProjectAccountId;
+    private _targetTestingAccountId;
+    private _projectConfig;
+    private _projectDir;
+    private _projectId;
+    private _projectName;
+    private _debug;
+    private _deployedBuild?;
+    private _isGithubLinked;
+    private _projectNodes;
+    private _env;
+    private _listeners;
+    private _configFilesUpdatedSinceLastUpload;
+    private _appData;
+    private _devServerMessage;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevStateConstructorOptions);
+    private runListeners;
+    get targetProjectAccountId(): number;
+    get targetTestingAccountId(): number;
+    get projectConfig(): ProjectConfig;
+    get projectDir(): string;
+    get projectId(): number;
+    get projectName(): string;
+    get debug(): boolean;
+    get deployedBuild(): Build | undefined;
+    get isGithubLinked(): boolean;
+    get projectNodes(): {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    set projectNodes(nodes: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    });
+    get env(): Environment;
+    get configFilesUpdatedSinceLastUpload(): Set<string>;
+    addUpdatedConfigFileUpdatedSinceLastUpload(filePath: string): void;
+    resetConfigFilesUpdatedSinceLastUpload(): void;
+    get appData(): Record<string, AppLocalDevData>;
+    getAppDataByUid(uid: string): AppLocalDevData | undefined;
+    setAppDataForUid(uid: string, appData: AppLocalDevData): void;
+    get devServerMessage(): string;
+    set devServerMessage(message: LocalDevServerMessage);
+    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+}
+export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+class LocalDevState {
+    _targetProjectAccountId;
+    _targetTestingAccountId;
+    _projectConfig;
+    _projectDir;
+    _projectId;
+    _projectName;
+    _debug;
+    _deployedBuild;
+    _isGithubLinked;
+    _projectNodes;
+    _env;
+    _listeners;
+    _configFilesUpdatedSinceLastUpload;
+    _appData;
+    _devServerMessage;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
+        this._targetProjectAccountId = targetProjectAccountId;
+        this._targetTestingAccountId = targetTestingAccountId;
+        this._projectConfig = projectConfig;
+        this._projectDir = projectDir;
+        this._projectId = projectId;
+        this._projectName = projectName;
+        this._debug = debug || false;
+        this._deployedBuild = deployedBuild;
+        this._isGithubLinked = isGithubLinked;
+        this._projectNodes = initialProjectNodes;
+        this._env = env;
+        this._configFilesUpdatedSinceLastUpload = new Set();
+        this._appData = {};
+        this._devServerMessage = constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
+        this._listeners = {};
+    }
+    runListeners(key) {
+        if (this._listeners[key] && this._listeners[key].length) {
+            this._listeners[key].forEach(listener => listener(this[key]));
+        }
+    }
+    get targetProjectAccountId() {
+        return this._targetProjectAccountId;
+    }
+    get targetTestingAccountId() {
+        return this._targetTestingAccountId;
+    }
+    get projectConfig() {
+        return {
+            ...this._projectConfig,
+        };
+    }
+    get projectDir() {
+        return this._projectDir;
+    }
+    get projectId() {
+        return this._projectId;
+    }
+    get projectName() {
+        return this._projectName;
+    }
+    get debug() {
+        return this._debug;
+    }
+    get deployedBuild() {
+        return (this._deployedBuild && {
+            ...this._deployedBuild,
+        });
+    }
+    get isGithubLinked() {
+        return this._isGithubLinked;
+    }
+    get projectNodes() {
+        return { ...this._projectNodes };
+    }
+    set projectNodes(nodes) {
+        this._projectNodes = nodes;
+        this.runListeners('projectNodes');
+    }
+    get env() {
+        return this._env;
+    }
+    get configFilesUpdatedSinceLastUpload() {
+        return this._configFilesUpdatedSinceLastUpload;
+    }
+    addUpdatedConfigFileUpdatedSinceLastUpload(filePath) {
+        this._configFilesUpdatedSinceLastUpload.add(filePath);
+    }
+    resetConfigFilesUpdatedSinceLastUpload() {
+        this._configFilesUpdatedSinceLastUpload.clear();
+    }
+    get appData() {
+        return { ...this._appData };
+    }
+    getAppDataByUid(uid) {
+        return { ...this._appData[uid] };
+    }
+    setAppDataForUid(uid, appData) {
+        this._appData[uid] = appData;
+        this.runListeners('appData');
+    }
+    get devServerMessage() {
+        return this._devServerMessage;
+    }
+    set devServerMessage(message) {
+        this._devServerMessage = message;
+        this.runListeners('devServerMessage');
+    }
+    addListener(key, listener, callOnInit = false) {
+        if (!this._listeners[key]) {
+            this._listeners[key] = [];
+        }
+        this._listeners[key].push(listener);
+        if (callOnInit) {
+            listener(this[key]);
+        }
+    }
+}
+exports.default = LocalDevState;

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,131 @@
+"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://app.hubspot.com',
+        'https://app.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();
+            this.localDevProcess.sendDevServerMessage(constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+        });
+    }
+    shutdown() {
+        this.server?.close();
+        this.server = undefined;
+        this._websocket = undefined;
+    }
+}
+exports.default = LocalDevWebsocketServer;

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

@@ -4,7 +4,7 @@ import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTest
 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 '../../../types/Prompts';
+import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt';
 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;
@@ -14,6 +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/projects/localDev/helpers.js

@@ -15,6 +15,7 @@ exports.createNewProjectForLocalDev = createNewProjectForLocalDev;
 exports.createInitialBuildForNewProject = createInitialBuildForNewProject;
 exports.getAccountHomeUrl = getAccountHomeUrl;
 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");
@@ -212,7 +213,7 @@ async function createNewProjectForLocalDev(projectConfig, targetAccountId, shoul
                 .publicAppProjectMustExistExplanation
             : en_1.lib.localDevHelpers.createNewProjectForLocalDev
                 .projectMustExistExplanation;
-        const explanationString = explanationLangFunction((0, ui_1.uiAccountDescription)(targetAccountId), projectConfig.name);
+        const explanationString = explanationLangFunction(projectConfig.name, targetAccountId);
         logger_1.uiLogger.log('');
         (0, ui_1.uiLine)();
         logger_1.uiLogger.log(explanationString);
@@ -253,7 +254,7 @@ function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
 }
 // 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) {
+async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
     const { result: initialUploadResult, uploadError } = await (0, upload_1.handleProjectUpload)({
         accountId: targetAccountId,
         projectConfig,
@@ -264,6 +265,7 @@ async function createInitialBuildForNewProject(projectConfig, projectDir, target
         forceCreate: true,
         skipValidation: true,
         sendIR,
+        profile,
     });
     if (uploadError) {
         if ((0, index_1.isSpecifiedError)(uploadError, {
@@ -319,3 +321,31 @@ async function hasSandboxes(account) {
         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/upload.d.ts

@@ -15,6 +15,10 @@ type HandleProjectUploadArg<T> = {
     isUploadCommand?: boolean;
     sendIR?: boolean;
     skipValidation?: boolean;
+    profile?: string;
 };
-export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
+export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
+export declare function validateSourceDirectory(srcDir: string, projectConfig: ProjectConfig): void;
+export declare function validateNoHSMetaMismatch(srcDir: string, projectConfig: ProjectConfig): Promise<void>;
+export declare function handleTranslate(projectDir: string, projectConfig: ProjectConfig, accountId: number, skipValidation: boolean, profile: string | undefined): Promise<unknown>;
 export {};