@hubspot/cli 7.6.0-beta.4 → 7.6.0-beta.6

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

@@ -1,7 +1,7 @@
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
-import LocalDevState from './LocalDevState';
-import LocalDevLogger from './LocalDevLogger';
-import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevServerMessage } from '../../../types/LocalDev';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevServerMessage } from '../../../types/LocalDev.js';
 declare class LocalDevProcess {
     private state;
     private _logger;
@@ -19,11 +19,11 @@ declare class LocalDevProcess {
     private setupDevServers;
     private startDevServers;
     private cleanupDevServers;
-    private compareLocalProjectToDeployed;
     private projectConfigValidForUpload;
     private getIntermediateRepresentation;
     private updateProjectNodes;
     private updateProjectNodesAfterUpload;
+    private openLocalDevUi;
     handleFileChange(filePath: string, event: string): Promise<void>;
     handleConfigFileChange(): Promise<void>;
     start(): Promise<void>;
@@ -31,5 +31,6 @@ declare class LocalDevProcess {
     uploadProject(): Promise<boolean>;
     addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
     sendDevServerMessage(message: LocalDevServerMessage): void;
+    removeStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
 }
 export default LocalDevProcess;

package/lib/projects/localDev/LocalDevProcess.js

@@ -1,26 +1,25 @@
-"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");
+import { translateForLocalDev } from '@hubspot/project-parsing-lib';
+import { hasLocalStateFlag } from '@hubspot/local-dev-lib/config';
+import path from 'path';
+import open from 'open';
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+import DevServerManagerV2 from './DevServerManagerV2.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { getProjectConfig } from '../config.js';
+import { handleProjectUpload } from '../upload.js';
+import { pollProjectBuildAndDeploy } from '../buildAndDeploy.js';
+import { getLocalDevUiUrl } from '../urls.js';
+import { CONFIG_LOCAL_STATE_FLAGS } from '../../constants.js';
+import { isAutoOpenBrowserEnabled } from '../../configOptions.js';
 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({
+        this.state = new LocalDevState(options);
+        this._logger = new LocalDevLogger(this.state);
+        this.devServerManager = new DevServerManagerV2({
             localDevState: this.state,
             logger: this._logger,
         });
@@ -62,7 +61,7 @@ class LocalDevProcess {
         }
         catch (e) {
             this.logger.devServerStartError(e);
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     async cleanupDevServers() {
@@ -75,22 +74,8 @@ class LocalDevProcess {
             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)();
+        const { projectConfig } = await getProjectConfig();
         if (!projectConfig) {
             return false;
         }
@@ -103,8 +88,8 @@ class LocalDevProcess {
         return true;
     }
     getIntermediateRepresentation(projectNodesAtLastUpload) {
-        return (0, project_parsing_lib_1.translateForLocalDev)({
-            projectSourceDir: path_1.default.join(this.state.projectDir, this.state.projectConfig.srcDir),
+        return translateForLocalDev({
+            projectSourceDir: path.join(this.state.projectDir, this.state.projectConfig.srcDir),
             platformVersion: this.state.projectConfig.platformVersion,
             accountId: this.state.targetProjectAccountId,
         }, {
@@ -124,6 +109,10 @@ class LocalDevProcess {
         this.state.projectNodesAtLastUpload =
             intermediateRepresentation.intermediateNodesIndexedByUid;
     }
+    openLocalDevUi() {
+        const showWelcomeScreen = !hasLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
+        open(getLocalDevUiUrl(this.state.targetTestingAccountId, showWelcomeScreen));
+    }
     async handleFileChange(filePath, event) {
         await this.updateProjectNodes();
         try {
@@ -139,21 +128,16 @@ class LocalDevProcess {
     }
     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);
+            process.exit(EXIT_CODES.ERROR);
         }
         this.logger.startupMessage();
+        if (isAutoOpenBrowserEnabled()) {
+            this.openLocalDevUi();
+        }
         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) {
@@ -164,12 +148,12 @@ class LocalDevProcess {
             if (showProgress) {
                 this.logger.cleanupError();
             }
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            process.exit(EXIT_CODES.ERROR);
         }
         if (showProgress) {
             this.logger.cleanupSuccess();
         }
-        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        process.exit(EXIT_CODES.SUCCESS);
     }
     async uploadProject() {
         this.logger.uploadInitiated();
@@ -178,11 +162,11 @@ class LocalDevProcess {
             this.logger.projectConfigMismatch();
             return false;
         }
-        const { uploadError } = await (0, upload_1.handleProjectUpload)({
+        const { uploadError } = await handleProjectUpload({
             accountId: this.state.targetProjectAccountId,
             projectConfig: this.state.projectConfig,
             projectDir: this.state.projectDir,
-            callbackFunc: buildAndDeploy_1.pollProjectBuildAndDeploy,
+            callbackFunc: pollProjectBuildAndDeploy,
             sendIR: true,
             skipValidation: true,
         });
@@ -201,5 +185,8 @@ class LocalDevProcess {
     sendDevServerMessage(message) {
         this.state.devServerMessage = message;
     }
+    removeStateListener(key, listener) {
+        this.state.removeListener(key, listener);
+    }
 }
-exports.default = LocalDevProcess;
+export default LocalDevProcess;

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

@@ -1,8 +1,7 @@
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
-import { ProjectConfig } from '../../../types/Projects';
-import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev';
+import { ProjectConfig } from '../../../types/Projects.js';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev.js';
 declare class LocalDevState {
     private _targetProjectAccountId;
     private _targetTestingAccountId;
@@ -12,7 +11,6 @@ declare class LocalDevState {
     private _projectId;
     private _projectName;
     private _debug;
-    private _deployedBuild?;
     private _isGithubLinked;
     private _projectNodes;
     private _projectNodesAtLastUpload;
@@ -20,7 +18,7 @@ declare class LocalDevState {
     private _listeners;
     private _appData;
     private _devServerMessage;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, profile, env, }: LocalDevStateConstructorOptions);
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, isGithubLinked, initialProjectNodes, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
@@ -30,7 +28,6 @@ declare class LocalDevState {
     get projectId(): number;
     get projectName(): string;
     get debug(): boolean;
-    get deployedBuild(): Build | undefined;
     get isGithubLinked(): boolean;
     get projectNodes(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
@@ -51,5 +48,6 @@ declare class LocalDevState {
     get devServerMessage(): string;
     set devServerMessage(message: LocalDevServerMessage);
     addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+    removeListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
 }
 export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../../constants");
+import { LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../../constants.js';
 class LocalDevState {
     _targetProjectAccountId;
     _targetTestingAccountId;
@@ -10,7 +8,6 @@ class LocalDevState {
     _projectId;
     _projectName;
     _debug;
-    _deployedBuild;
     _isGithubLinked;
     _projectNodes;
     _projectNodesAtLastUpload;
@@ -18,7 +15,7 @@ class LocalDevState {
     _listeners;
     _appData;
     _devServerMessage;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, profile, env, }) {
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, isGithubLinked, initialProjectNodes, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._profile = profile;
@@ -27,13 +24,12 @@ class LocalDevState {
         this._projectId = projectId;
         this._projectName = projectName;
         this._debug = debug || false;
-        this._deployedBuild = deployedBuild;
         this._isGithubLinked = isGithubLinked;
         this._projectNodes = initialProjectNodes;
         this._projectNodesAtLastUpload = initialProjectNodes;
         this._env = env;
         this._appData = {};
-        this._devServerMessage = constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
+        this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
         this._listeners = {};
     }
     runListeners(key) {
@@ -65,9 +61,6 @@ class LocalDevState {
     get debug() {
         return this._debug;
     }
-    get deployedBuild() {
-        return this._deployedBuild && structuredClone(this._deployedBuild);
-    }
     get isGithubLinked() {
         return this._isGithubLinked;
     }
@@ -113,5 +106,10 @@ class LocalDevState {
             listener(this[key]);
         }
     }
+    removeListener(key, listener) {
+        if (this._listeners[key]) {
+            this._listeners[key].splice(this._listeners[key].indexOf(listener), 1);
+        }
+    }
 }
-exports.default = LocalDevState;
+export default LocalDevState;

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

@@ -1,4 +1,4 @@
-import LocalDevProcess from './LocalDevProcess';
+import LocalDevProcess from './LocalDevProcess.js';
 declare class LocalDevWatcher {
     private localDevProcess;
     private watcher;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -1,11 +1,6 @@
-"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");
+import path from 'path';
+import chokidar from 'chokidar';
+import { PROJECT_CONFIG_FILE } from '../../constants.js';
 const WATCH_EVENTS = {
     add: 'add',
     change: 'change',
@@ -26,12 +21,12 @@ class LocalDevWatcher {
         return this.localDevProcess.handleFileChange(filePath, event);
     }
     start() {
-        this.watcher = chokidar_1.default.watch(this.localDevProcess.projectDir, {
+        this.watcher = chokidar.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);
+        const projectConfigPath = path.join(this.localDevProcess.projectDir, PROJECT_CONFIG_FILE);
         configPaths.push(projectConfigPath);
         this.watcher.on('add', filePath => {
             this.handleWatchEvent(filePath, WATCH_EVENTS.add, configPaths);
@@ -50,4 +45,4 @@ class LocalDevWatcher {
         await this.watcher?.close();
     }
 }
-exports.default = LocalDevWatcher;
+export default LocalDevWatcher;

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

@@ -1,18 +1,18 @@
-import LocalDevProcess from './LocalDevProcess';
+import LocalDevProcess from './LocalDevProcess.js';
 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 setupProjectNodesListener;
+    private setupAppDataListener;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ws_1 = require("ws");
-const portManager_1 = require("@hubspot/local-dev-lib/portManager");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const constants_1 = require("../../constants");
-const en_1 = require("../../../lang/en");
+import { WebSocketServer } from 'ws';
+import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { addLocalStateFlag } from '@hubspot/local-dev-lib/config';
+import { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, } from '../../constants.js';
+import { lib } from '../../../lang/en.js';
 const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
 const LOG_PREFIX = '[LocalDevWebsocketServer]';
 class LocalDevWebsocketServer {
     server;
-    _websocket;
     debug;
     localDevProcess;
     ALLOWED_ORIGINS = [
@@ -22,62 +20,59 @@ class LocalDevWebsocketServer {
         this.localDevProcess = localDevProcess;
         this.debug = debug;
     }
-    websocket() {
-        if (!this._websocket) {
-            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.notInitialized(LOG_PREFIX));
-        }
-        return this._websocket;
-    }
     log(message) {
         if (this.debug) {
-            logger_1.logger.log(LOG_PREFIX, message);
+            logger.log(LOG_PREFIX, message);
         }
     }
     logError(message) {
         if (this.debug) {
-            logger_1.logger.error(LOG_PREFIX, message);
+            logger.error(LOG_PREFIX, message);
         }
     }
-    sendMessage(message) {
-        this.websocket().send(JSON.stringify(message));
+    sendMessage(websocket, message) {
+        websocket.send(JSON.stringify(message));
     }
-    async handleUpload() {
+    async handleUpload(websocket) {
         const uploadSuccess = await this.localDevProcess.uploadProject();
         if (uploadSuccess) {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
             });
         }
         else {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
             });
         }
     }
-    setupMessageHandlers() {
-        this.websocket().on('message', data => {
+    setupMessageHandlers(websocket) {
+        websocket.on('message', data => {
             try {
                 const message = JSON.parse(data.toString());
                 if (!message.type) {
-                    this.logError(en_1.lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
+                    this.logError(lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
                     return;
                 }
                 switch (message.type) {
-                    case constants_1.LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
-                        this.handleUpload();
+                    case LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
+                        this.handleUpload(websocket);
+                        break;
+                    case LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.VIEWED_WELCOME_SCREEN:
+                        addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
                         break;
                     default:
-                        this.logError(en_1.lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
+                        this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
                 }
             }
             catch (e) {
-                this.logError(en_1.lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
+                this.logError(lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
             }
         });
     }
-    sendProjectData() {
-        this.sendMessage({
-            type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+    sendProjectData(websocket) {
+        this.sendMessage(websocket, {
+            type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
             data: {
                 projectName: this.localDevProcess.projectName,
                 projectId: this.localDevProcess.projectId,
@@ -86,46 +81,59 @@ class LocalDevWebsocketServer {
             },
         });
     }
-    setupStateListeners() {
-        this.localDevProcess.addStateListener('projectNodes', nodes => {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+    setupProjectNodesListener(websocket) {
+        const listener = (nodes) => {
+            this.sendMessage(websocket, {
+                type: 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,
+        };
+        this.localDevProcess.addStateListener('projectNodes', listener, true);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('projectNodes', listener);
+        });
+    }
+    setupAppDataListener(websocket) {
+        const listener = (appData) => {
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
                 data: appData,
             });
-        }, true);
+        };
+        this.localDevProcess.addStateListener('appData', listener, true);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('appData', listener);
+        });
+    }
+    setupStateListeners(websocket) {
+        this.setupProjectNodesListener(websocket);
+        this.setupAppDataListener(websocket);
     }
     async start() {
-        const portManagerIsRunning = await (0, portManager_1.isPortManagerServerRunning)();
+        const portManagerIsRunning = await isPortManagerServerRunning();
         if (!portManagerIsRunning) {
-            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
+            throw new Error(lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
         }
-        const portData = await (0, portManager_1.requestPorts)([{ instanceId: SERVER_INSTANCE_ID }]);
+        const portData = await requestPorts([{ instanceId: SERVER_INSTANCE_ID }]);
         const port = portData[SERVER_INSTANCE_ID];
-        this.server = new ws_1.WebSocketServer({ port });
-        this.log(en_1.lib.LocalDevWebsocketServer.logs.startup(port));
+        this.server = 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)) {
-                ws.close(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
+                ws.close(1008, 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);
+            this.sendProjectData(ws);
+            this.setupMessageHandlers(ws);
+            this.setupStateListeners(ws);
+            this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
+        this.server.on('close', () => { });
     }
     shutdown() {
         this.server?.close();
         this.server = undefined;
-        this._websocket = undefined;
     }
 }
-exports.default = LocalDevWebsocketServer;
+export default LocalDevWebsocketServer;

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

@@ -1,20 +1,27 @@
 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 { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
 import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { ProjectConfig } from '../../../types/Projects';
-import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { ProjectConfig } from '../../../types/Projects.js';
+import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt.js';
 export declare function confirmDefaultAccountIsTarget(accountConfig: CLIAccount): Promise<void>;
 export declare function checkIfDefaultAccountIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): Promise<void>;
 export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount): void;
 export declare function checkIfAccountFlagIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): void;
 export declare function suggestRecommendedNestedAccount(accounts: CLIAccount[], accountConfig: CLIAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
-export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
+export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV3?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
 export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
 export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
 export declare function getAccountHomeUrl(accountId: number): string;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;
+export declare function compareLocalProjectToDeployed(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number | undefined, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}): Promise<void>;
+export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}): Promise<boolean>;