@hubspot/cli 7.8.12-experimental.0 → 7.9.0-beta.0

package/lib/projects/localDev/DevServerManager_DEPRECATED.js

@@ -0,0 +1,120 @@
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { DevModeInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
+import { startPortManagerServer, stopPortManagerServer, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { ComponentTypes, } from '../../../types/Projects.js';
+import { lib } from '../../../lang/en.js';
+import { uiLogger } from '../../ui/logger.js';
+const SERVER_KEYS = {
+    privateApp: 'privateApp',
+    publicApp: 'publicApp',
+};
+class DevServerManager_DEPRECATED {
+    initialized;
+    started;
+    componentsByType;
+    devServers;
+    constructor() {
+        this.initialized = false;
+        this.started = false;
+        this.componentsByType = {};
+        this.devServers = {
+            [SERVER_KEYS.privateApp]: {
+                componentType: ComponentTypes.PrivateApp,
+                serverInterface: UIEDevModeInterface,
+            },
+            [SERVER_KEYS.publicApp]: {
+                componentType: ComponentTypes.PublicApp,
+                serverInterface: UIEDevModeInterface,
+            },
+        };
+    }
+    async iterateDevServers(callback) {
+        const serverKeys = Object.keys(this.devServers);
+        for (let i = 0; i < serverKeys.length; i++) {
+            const serverKey = serverKeys[i];
+            const devServer = this.devServers[serverKey];
+            const compatibleComponents = this.componentsByType[devServer.componentType] || {};
+            if (Object.keys(compatibleComponents).length) {
+                await callback(devServer.serverInterface, compatibleComponents);
+            }
+            else {
+                uiLogger.debug(lib.DevServerManager.noCompatibleComponents(serverKey));
+            }
+        }
+    }
+    arrangeComponentsByType(components) {
+        return components.reduce((acc, component) => {
+            if (!acc[component.type]) {
+                acc[component.type] = {};
+            }
+            if ('name' in component.config && component.config.name) {
+                acc[component.type][component.config.name] = component;
+            }
+            return acc;
+        }, {});
+    }
+    async setup({ components, onUploadRequired, accountId, setActiveApp, }) {
+        this.componentsByType = this.arrangeComponentsByType(components);
+        let env;
+        const accountConfig = getAccountConfig(accountId);
+        if (accountConfig) {
+            env = accountConfig.env;
+        }
+        await startPortManagerServer();
+        await this.iterateDevServers(async (serverInterface, compatibleComponents) => {
+            if (serverInterface.setup) {
+                await serverInterface.setup({
+                    components: compatibleComponents,
+                    onUploadRequired,
+                    logger,
+                    urls: {
+                        api: getHubSpotApiOrigin(env),
+                        web: getHubSpotWebsiteOrigin(env),
+                    },
+                    setActiveApp,
+                });
+            }
+        });
+        this.initialized = true;
+    }
+    async start({ accountId, projectConfig, }) {
+        if (this.initialized) {
+            await this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.start) {
+                    await serverInterface.start({
+                        accountId,
+                        projectConfig,
+                        requestPorts,
+                    });
+                }
+            });
+        }
+        else {
+            throw new Error(lib.DevServerManager.notInitialized);
+        }
+        this.started = true;
+    }
+    async fileChange({ filePath, event, }) {
+        if (this.started) {
+            this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.fileChange) {
+                    await serverInterface.fileChange(filePath, event);
+                }
+            });
+        }
+    }
+    async cleanup() {
+        if (this.started) {
+            await this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.cleanup) {
+                    await serverInterface.cleanup();
+                }
+            });
+            await stopPortManagerServer();
+        }
+    }
+}
+const Manager = new DevServerManager_DEPRECATED();
+export default Manager;

package/lib/projects/localDev/LocalDevLogger.js

@@ -1,6 +1,5 @@
 import { getAccountId, hasLocalStateFlag } from '@hubspot/local-dev-lib/config';
 import { getConfigDefaultAccount } from '@hubspot/local-dev-lib/config';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { uiLogger } from '../../ui/logger.js';
 import { uiBetaTag, uiLine, uiAccountDescription, uiCommandReference, } from '../../ui/index.js';
 import { lib } from '../../../lang/en.js';
@@ -26,7 +25,7 @@ class LocalDevLogger {
     }
     handleError(e, langFunction) {
         if (this.state.debug) {
-            logger.error(e);
+            uiLogger.error(e instanceof Error ? e.message : String(e));
         }
         uiLogger.error(langFunction(e instanceof Error ? e.message : ''));
     }
@@ -119,35 +118,35 @@ class LocalDevLogger {
         uiLogger.log(lib.LocalDevProcess.projectConfigMismatch);
     }
     uploadError(error) {
-        logger.log('');
+        uiLogger.log('');
         logError(error);
         uiLogger.log(lib.LocalDevProcess.uploadFailed);
-        logger.log('');
+        uiLogger.log('');
     }
     uploadSuccess() {
-        logger.log('');
+        uiLogger.log('');
         uiLogger.log(lib.LocalDevProcess.uploadSuccess);
         uiLine();
-        logger.log('');
+        uiLogger.log('');
     }
     uploadSuccessAutoDeployDisabled() {
         uiLogger.warn(lib.LocalDevProcess.uploadSuccessAutoDeployDisabled);
         uiLine();
-        logger.log('');
+        uiLogger.log('');
     }
     deployError(error) {
-        logger.log('');
+        uiLogger.log('');
         if (error) {
             logError(error);
         }
         uiLogger.log(lib.LocalDevProcess.deployFailed);
-        logger.log('');
+        uiLogger.log('');
     }
     deploySuccess() {
-        logger.log('');
+        uiLogger.log('');
         uiLogger.log(lib.LocalDevProcess.deploySuccess);
         uiLine();
-        logger.log('');
+        uiLogger.log('');
     }
     monitorConsoleOutput() {
         const originalStdoutWrite = process.stdout.write.bind(process.stdout);

package/lib/projects/localDev/{LocalDevManager.js → LocalDevManager_DEPRECATED.js}

@@ -4,13 +4,12 @@ import chalk from 'chalk';
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, } from '@hubspot/local-dev-lib/api/appsDev';
 import { getAccountId, getConfigDefaultAccount, } from '@hubspot/local-dev-lib/config';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { PROJECT_CONFIG_FILE } from '../../constants.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
-import DevServerManager from './DevServerManager.js';
+import DevServerManager_DEPRECATED from './DevServerManager_DEPRECATED.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { getAccountHomeUrl } from '../urls.js';
-import { componentIsApp, componentIsPublicApp, CONFIG_FILES, getAppCardConfigs, getComponentUid, } from '../../projects/structure.js';
+import { componentIsApp, componentIsPublicApp, CONFIG_FILES, getAppCardConfigs, getComponentUid, } from '../structure.js';
 import { ComponentTypes, } from '../../../types/Projects.js';
 import { UI_COLORS, uiCommandReference, uiAccountDescription, uiBetaTag, uiLink, uiLine, } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
@@ -314,7 +313,7 @@ class LocalDevManager {
     }
     async devServerSetup() {
         try {
-            await DevServerManager.setup({
+            await DevServerManager_DEPRECATED.setup({
                 components: this.runnableComponents,
                 onUploadRequired: this.logUploadWarning.bind(this),
                 accountId: this.targetAccountId,
@@ -324,7 +323,7 @@ class LocalDevManager {
         }
         catch (e) {
             if (this.debug) {
-                logger.error(e);
+                uiLogger.error(e instanceof Error ? e.message : String(e));
             }
             uiLogger.error(lib.LocalDevManager.devServer.setupError(e instanceof Error ? e.message : ''));
             return false;
@@ -332,14 +331,14 @@ class LocalDevManager {
     }
     async devServerStart() {
         try {
-            await DevServerManager.start({
+            await DevServerManager_DEPRECATED.start({
                 accountId: this.targetAccountId,
                 projectConfig: this.projectConfig,
             });
         }
         catch (e) {
             if (this.debug) {
-                logger.error(e);
+                uiLogger.error(e instanceof Error ? e.message : String(e));
             }
             uiLogger.error(lib.LocalDevManager.devServer.startError(e instanceof Error ? e.message : ''));
             process.exit(EXIT_CODES.ERROR);
@@ -347,23 +346,23 @@ class LocalDevManager {
     }
     devServerFileChange(filePath, event) {
         try {
-            DevServerManager.fileChange({ filePath, event });
+            DevServerManager_DEPRECATED.fileChange({ filePath, event });
         }
         catch (e) {
             if (this.debug) {
-                logger.error(e);
+                uiLogger.error(e instanceof Error ? e.message : String(e));
             }
             uiLogger.error(lib.LocalDevManager.devServer.fileChangeError(e instanceof Error ? e.message : ''));
         }
     }
     async devServerCleanup() {
         try {
-            await DevServerManager.cleanup();
+            await DevServerManager_DEPRECATED.cleanup();
             return true;
         }
         catch (e) {
             if (this.debug) {
-                logger.error(e);
+                uiLogger.error(e instanceof Error ? e.message : String(e));
             }
             uiLogger.error(lib.LocalDevManager.devServer.cleanupError(e instanceof Error ? e.message : ''));
             return false;

package/lib/projects/localDev/LocalDevProcess.js

@@ -5,7 +5,7 @@ import path from 'path';
 import open from 'open';
 import LocalDevState from './LocalDevState.js';
 import LocalDevLogger from './LocalDevLogger.js';
-import DevServerManagerV2 from './DevServerManagerV2.js';
+import DevServerManager from './DevServerManager.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { getProjectConfig } from '../config.js';
 import { handleProjectUpload } from '../upload.js';
@@ -23,7 +23,7 @@ class LocalDevProcess {
     constructor(options) {
         this.state = new LocalDevState(options);
         this._logger = new LocalDevLogger(this.state);
-        this.devServerManager = new DevServerManagerV2({
+        this.devServerManager = new DevServerManager({
             localDevState: this.state,
             logger: this._logger,
         });
@@ -149,6 +149,7 @@ class LocalDevProcess {
             this.openLocalDevUi();
         }
         await this.startDevServers();
+        this.state.devServersStarted = true;
         this.logger.monitorConsoleOutput();
     }
     async stop(showProgress = true) {

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

@@ -19,6 +19,7 @@ declare class LocalDevState {
     private _appData;
     private _devServerMessage;
     private _uploadWarnings;
+    private _devServersStarted;
     constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
@@ -51,6 +52,8 @@ declare class LocalDevState {
     get devServerMessage(): string;
     set devServerMessage(message: LocalDevServerMessage);
     get uploadWarnings(): Set<string>;
+    get devServersStarted(): boolean;
+    set devServersStarted(started: boolean);
     addUploadWarning(warning: string): void;
     clearUploadWarnings(): void;
     addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;

package/lib/projects/localDev/LocalDevState.js

@@ -15,6 +15,7 @@ class LocalDevState {
     _appData;
     _devServerMessage;
     _uploadWarnings;
+    _devServersStarted;
     constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
@@ -30,6 +31,7 @@ class LocalDevState {
         this._appData = {};
         this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
         this._uploadWarnings = new Set();
+        this._devServersStarted = false;
         this._listeners = {};
     }
     runListeners(key) {
@@ -106,6 +108,13 @@ class LocalDevState {
     get uploadWarnings() {
         return this._uploadWarnings;
     }
+    get devServersStarted() {
+        return this._devServersStarted;
+    }
+    set devServersStarted(started) {
+        this._devServersStarted = started;
+        this.runListeners('devServersStarted');
+    }
     addUploadWarning(warning) {
         this.uploadWarnings.add(warning);
         this.runListeners('uploadWarnings');

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

@@ -3,19 +3,22 @@ declare class LocalDevWebsocketServer {
     private server?;
     private debug?;
     private localDevProcess;
-    private ALLOWED_ORIGINS;
     constructor(localDevProcess: LocalDevProcess, debug?: boolean);
     private log;
     private logError;
     private sendMessage;
     private handleUpload;
     private handleDeploy;
+    private handleAppInstallSuccess;
+    private handleAppInstallFailure;
+    private handleAppInstallInitiated;
     private setupMessageHandlers;
     private sendCliMetadata;
     private sendProjectData;
     private setupProjectNodesListener;
     private setupAppDataListener;
     private setupUploadWarningsListener;
+    private setupDevServersStartedListener;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -1,37 +1,33 @@
 import { WebSocketServer } from 'ws';
 import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../ui/logger.js';
 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 { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID, } from '../../constants.js';
 import { lib } from '../../../lang/en.js';
 import { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
-import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, } from './localDevWebsocketServerUtils.js';
+import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, isAppInstallFailureWebsocketMessage, isAppInstallSuccessWebsocketMessage, isAppInstallInitiatedWebsocketMessage, } 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 LOCAL_DEV_WEBSOCKET_SERVER_VERSION = 2;
 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;
     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;
     }
     log(message) {
         if (this.debug) {
-            logger.log(LOG_PREFIX, message);
+            uiLogger.log(`${LOG_PREFIX} ${message}`);
         }
     }
     logError(message) {
         if (this.debug) {
-            logger.error(LOG_PREFIX, message);
+            uiLogger.error(`${LOG_PREFIX} ${message}`);
         }
     }
     sendMessage(websocket, message) {
@@ -65,6 +61,15 @@ class LocalDevWebsocketServer {
             },
         });
     }
+    async handleAppInstallSuccess() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+    }
+    async handleAppInstallFailure() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_FAILURE);
+    }
+    async handleAppInstallInitiated() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.OAUTH_APP_INSTALL_INITIATED);
+    }
     setupMessageHandlers(websocket) {
         websocket.on('message', data => {
             try {
@@ -82,6 +87,15 @@ class LocalDevWebsocketServer {
                 else if (isViewedWelcomeScreenWebsocketMessage(message)) {
                     addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
                 }
+                else if (isAppInstallSuccessWebsocketMessage(message)) {
+                    this.handleAppInstallSuccess();
+                }
+                else if (isAppInstallFailureWebsocketMessage(message)) {
+                    this.handleAppInstallFailure();
+                }
+                else if (isAppInstallInitiatedWebsocketMessage(message)) {
+                    this.handleAppInstallInitiated();
+                }
                 else {
                     this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
                 }
@@ -150,23 +164,39 @@ class LocalDevWebsocketServer {
             this.localDevProcess.removeStateListener('uploadWarnings', listener);
         });
     }
+    setupDevServersStartedListener(websocket) {
+        const listener = (devServersStarted) => {
+            if (devServersStarted) {
+                this.sendMessage(websocket, {
+                    type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEV_SERVERS_STARTED,
+                });
+            }
+        };
+        this.localDevProcess.addStateListener('devServersStarted', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('devServersStarted', listener);
+        });
+    }
     setupStateListeners(websocket) {
         this.setupProjectNodesListener(websocket);
         this.setupAppDataListener(websocket);
         this.setupUploadWarningsListener(websocket);
+        this.setupDevServersStartedListener(websocket);
     }
     async start() {
         const portManagerIsRunning = await isPortManagerServerRunning();
         if (!portManagerIsRunning) {
             throw new Error(lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
         }
-        const portData = await requestPorts([{ instanceId: SERVER_INSTANCE_ID }]);
-        const port = portData[SERVER_INSTANCE_ID];
+        const portData = await requestPorts([
+            { instanceId: LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID },
+        ]);
+        const port = portData[LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID];
         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 || !this.ALLOWED_ORIGINS.includes(origin)) {
+            if (!origin || !ALLOWED_ORIGIN_REGEX.test(origin)) {
                 ws.close(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
                 return;
             }

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

@@ -0,0 +1,13 @@
+import LocalDevState from './LocalDevState.js';
+type UIExtensionsDevModeInterfaceConstructorOptions = {
+    localDevState: LocalDevState;
+};
+declare class UIExtensionsDevModeInterface {
+    localDevState: LocalDevState;
+    constructor(options: UIExtensionsDevModeInterfaceConstructorOptions);
+    setup(): Promise<void>;
+    start(): Promise<void>;
+    fileChange(filePath: string, event: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export default UIExtensionsDevModeInterface;

package/lib/projects/localDev/UIExtensionsDevModeInterface.js

@@ -0,0 +1,37 @@
+import { requestPorts } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { DevModeUnifiedInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
+import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
+class UIExtensionsDevModeInterface {
+    localDevState;
+    constructor(options) {
+        this.localDevState = options.localDevState;
+    }
+    async setup() {
+        return UIEDevModeInterface.setup({
+            // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
+            components: this.localDevState.projectNodes,
+            profileData: this.localDevState.projectProfileData,
+            logger,
+            urls: {
+                api: getHubSpotApiOrigin(this.localDevState.env),
+                web: getHubSpotWebsiteOrigin(this.localDevState.env),
+            },
+        });
+    }
+    async start() {
+        return UIEDevModeInterface.start({
+            accountId: this.localDevState.targetTestingAccountId,
+            // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
+            projectConfig: this.localDevState.projectConfig,
+            requestPorts,
+        });
+    }
+    async fileChange(filePath, event) {
+        return UIEDevModeInterface.fileChange(filePath, event);
+    }
+    async cleanup() {
+        return UIEDevModeInterface.cleanup();
+    }
+}
+export default UIExtensionsDevModeInterface;

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

@@ -8,7 +8,7 @@ export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount):
 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, useV3?: boolean): Promise<number>;
+export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV2?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;

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

@@ -138,7 +138,7 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
     }
 }
 // Create a developer test account and return its accountId
-export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV3 = false) {
+export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV2 = false) {
     let currentPortalCount = 0;
     let maxTestPortals = 10;
     try {
@@ -168,7 +168,7 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         });
         trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
-        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV3);
+        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
         return result;
     }
     catch (err) {

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

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

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

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

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

@@ -10,3 +10,4 @@ export declare function compareLocalProjectToDeployed(projectConfig: ProjectConf
 export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
 }, profile?: string): Promise<boolean>;
+export declare function checkAndInstallDependencies(): Promise<void>;

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

@@ -20,6 +20,7 @@ import { handleProjectUpload } from '../../upload.js';
 import { pollProjectBuildAndDeploy } from '../../pollProjectBuildAndDeploy.js';
 import { debugError, logError } from '../../../errorHandlers/index.js';
 import { ApiErrorContext } from '../../../errorHandlers/index.js';
+import { getProjectPackageJsonLocations, hasMissingPackages, installPackages, } from '../../../dependencyManagement.js';
 // Prompt the user to create a new project if one doesn't exist on their target account
 export async function createNewProjectForLocalDev(projectConfig, targetAccountId, shouldCreateWithoutConfirmation, hasPublicApps) {
     // Create the project without prompting if this is a newly created sandbox
@@ -153,9 +154,8 @@ export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountI
     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);
+        await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { hideLogs: true });
+        const deployedProjectSourceDir = path.join(tempDir, projectConfig.srcDir);
         const { intermediateNodesIndexedByUid: deployedProjectNodes } = await translate({
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,
@@ -174,3 +174,39 @@ export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountI
         }
     }
 }
+export async function checkAndInstallDependencies() {
+    SpinniesManager.init();
+    uiLogger.log('');
+    SpinniesManager.add('checkingDependencies', {
+        text: lib.localDevHelpers.project.checkAndInstallDependencies
+            .checkingDependencies,
+    });
+    try {
+        const installLocations = await getProjectPackageJsonLocations();
+        const locationsToInstall = [];
+        for (const location of installLocations) {
+            if (await hasMissingPackages(location)) {
+                locationsToInstall.push(location);
+            }
+        }
+        if (locationsToInstall.length > 0) {
+            SpinniesManager.remove('checkingDependencies');
+            await installPackages({ installLocations: locationsToInstall });
+        }
+        else {
+            SpinniesManager.succeed('checkingDependencies', {
+                text: lib.localDevHelpers.project.checkAndInstallDependencies
+                    .dependenciesUpToDate,
+            });
+        }
+        uiLogger.log('');
+    }
+    catch (e) {
+        logError(e);
+        SpinniesManager.fail('checkingDependencies', {
+            text: lib.localDevHelpers.project.checkAndInstallDependencies
+                .dependenciesFailure,
+        });
+        process.exit(EXIT_CODES.ERROR);
+    }
+}

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

@@ -2,3 +2,6 @@ import { LocalDevDeployWebsocketMessage, LocalDevWebsocketMessage } from '../../
 export declare function isUploadWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
 export declare function isDeployWebsocketMessage(message: LocalDevWebsocketMessage): message is LocalDevDeployWebsocketMessage;
 export declare function isViewedWelcomeScreenWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallSuccessWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallInitiatedWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallFailureWebsocketMessage(message: LocalDevWebsocketMessage): boolean;