@hubspot/cli 7.7.22-experimental.0 → 7.7.24-experimental.0

package/lib/projects/__tests__/LocalDevWebsocketServer.test.js

@@ -1,7 +1,7 @@
 import { WebSocketServer } from 'ws';
 import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
 import { logger } from '@hubspot/local-dev-lib/logger';
-import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
+import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
 import LocalDevWebsocketServer from '../localDev/LocalDevWebsocketServer.js';
 import { lib } from '../../../lang/en.js';
 vi.mock('ws');
@@ -29,6 +29,7 @@ describe('LocalDevWebsocketServer', () => {
         // Setup mock LocalDevProcess
         mockLocalDevProcess = {
             addStateListener: vi.fn(),
+            removeStateListener: vi.fn(),
             uploadProject: vi.fn(),
             sendDevServerMessage: vi.fn(),
         };
@@ -167,4 +168,172 @@ describe('LocalDevWebsocketServer', () => {
             expect(mockWebSocketServer.close).toHaveBeenCalled();
         });
     });
+    describe('multiple connections', () => {
+        let mockWebSocket1;
+        let mockWebSocket2;
+        let mockWebSocket3;
+        let connectionCallback;
+        beforeEach(async () => {
+            // Setup multiple mock WebSockets
+            mockWebSocket1 = {
+                on: vi.fn(),
+                send: vi.fn(),
+                close: vi.fn(),
+            };
+            mockWebSocket2 = {
+                on: vi.fn(),
+                send: vi.fn(),
+                close: vi.fn(),
+            };
+            mockWebSocket3 = {
+                on: vi.fn(),
+                send: vi.fn(),
+                close: vi.fn(),
+            };
+            // Start the server
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                'local-dev-ui-websocket-server': 1234,
+            });
+            await server.start();
+            // Get the connection callback
+            connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+        });
+        it('should handle multiple valid connections simultaneously', () => {
+            // Establish three connections from valid origins
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            connectionCallback(mockWebSocket3, {
+                headers: { origin: 'https://local.hubspot.com' },
+            });
+            // All connections should be established with proper setup
+            expect(mockWebSocket1.on).toHaveBeenCalledWith('message', expect.any(Function));
+            expect(mockWebSocket2.on).toHaveBeenCalledWith('message', expect.any(Function));
+            expect(mockWebSocket3.on).toHaveBeenCalledWith('message', expect.any(Function));
+            // Each connection should trigger state listener setup
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(6); // 2 listeners per connection * 3 connections
+            // Each connection should trigger dev server message
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledTimes(3);
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+            // No connections should be closed
+            expect(mockWebSocket1.close).not.toHaveBeenCalled();
+            expect(mockWebSocket2.close).not.toHaveBeenCalled();
+            expect(mockWebSocket3.close).not.toHaveBeenCalled();
+        });
+        it('should send project data to each connection independently', () => {
+            // Setup mock project data properties as getters
+            Object.defineProperty(mockLocalDevProcess, 'projectName', {
+                get: () => 'test-project',
+                configurable: true,
+            });
+            Object.defineProperty(mockLocalDevProcess, 'projectId', {
+                get: () => 123,
+                configurable: true,
+            });
+            Object.defineProperty(mockLocalDevProcess, 'targetProjectAccountId', {
+                get: () => 456,
+                configurable: true,
+            });
+            Object.defineProperty(mockLocalDevProcess, 'targetTestingAccountId', {
+                get: () => 789,
+                configurable: true,
+            });
+            // Establish multiple connections
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            // Each websocket should receive project data
+            expect(mockWebSocket1.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+                data: {
+                    projectName: 'test-project',
+                    projectId: 123,
+                    targetProjectAccountId: 456,
+                    targetTestingAccountId: 789,
+                },
+            }));
+            expect(mockWebSocket2.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+                data: {
+                    projectName: 'test-project',
+                    projectId: 123,
+                    targetProjectAccountId: 456,
+                    targetTestingAccountId: 789,
+                },
+            }));
+        });
+        it('should properly cleanup listeners when connections close', () => {
+            // Establish connections
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            // Get all the close callbacks for both connections (there should be 2 per connection)
+            const closeCallbacks1 = mockWebSocket1.on.mock.calls
+                .filter(call => call[0] === 'close')
+                .map(call => call[1]);
+            const closeCallbacks2 = mockWebSocket2.on.mock.calls
+                .filter(call => call[0] === 'close')
+                .map(call => call[1]);
+            expect(closeCallbacks1).toHaveLength(2); // projectNodes and appData listeners
+            expect(closeCallbacks2).toHaveLength(2); // projectNodes and appData listeners
+            // Simulate first connection closing (call all close callbacks)
+            closeCallbacks1.forEach(callback => callback());
+            // Should have removed listeners for first connection (2 listeners: projectNodes and appData)
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(2);
+            // Simulate second connection closing
+            closeCallbacks2.forEach(callback => callback());
+            // Should have removed listeners for second connection as well
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(4);
+        });
+        it('should broadcast state changes to all connected clients', () => {
+            // Establish connections
+            connectionCallback(mockWebSocket1, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            connectionCallback(mockWebSocket2, {
+                headers: { origin: 'https://app.hubspotqa.com' },
+            });
+            // Get the projectNodes listeners that were registered
+            const projectNodesListeners = mockLocalDevProcess.addStateListener.mock.calls
+                .filter(call => call[0] === 'projectNodes')
+                .map(call => call[1]);
+            expect(projectNodesListeners).toHaveLength(2);
+            // Simulate a project nodes update by calling the listeners
+            const mockProjectNodes = {
+                component1: {
+                    uid: 'component1',
+                    componentType: 'APP',
+                    localDev: {
+                        componentRoot: '/test/path',
+                        componentConfigPath: '/test/path/config.json',
+                        configUpdatedSinceLastUpload: false,
+                    },
+                    componentDeps: {},
+                    metaFilePath: '/test/path',
+                    config: {},
+                    files: [],
+                },
+            };
+            projectNodesListeners.forEach(listener => listener(mockProjectNodes));
+            // Both websockets should receive the update
+            expect(mockWebSocket1.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+                data: mockProjectNodes,
+            }));
+            expect(mockWebSocket2.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+                data: mockProjectNodes,
+            }));
+        });
+    });
 });

package/lib/projects/add/legacyAddComponent.js

@@ -5,7 +5,7 @@ import { commands } from '../../../lang/en.js';
 import { getProjectComponentListFromRepo } from '../create/legacy.js';
 import { projectAddPrompt } from '../../prompts/projectAddPrompt.js';
 import path from 'path';
-import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH } from '../../constants.js';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../constants.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { uiLogger } from '../../ui/logger.js';
 export async function legacyAddComponent(args, projectDir, projectConfig) {

package/lib/projects/add/v3AddComponent.js

@@ -1,10 +1,11 @@
 import { commands, lib } from '../../../lang/en.js';
 import { getConfigForPlatformVersion } from '../create/legacy.js';
-import { calculateComponentTemplateChoices, createV3App, PROJECT_WITH_APP, } from '../create/v3.js';
+import { calculateComponentTemplateChoices, createV3App, } from '../create/v3.js';
+import { PROJECT_WITH_APP } from '../../constants.js';
 import path from 'path';
 import fs from 'fs';
 import { projectAddPromptV3 } from '../../prompts/projectAddPrompt.js';
-import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH } from '../../constants.js';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../constants.js';
 import { handleComponentCollision } from '../components.js';
 import { getProjectMetadata, } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';

package/lib/projects/create/index.js

@@ -1,8 +1,8 @@
 import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
 import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
-import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } from '../../constants.js';
+import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
 import { useV3Api } from '../buildAndDeploy.js';
-import { EMPTY_PROJECT, v3ComponentFlow } from './v3.js';
+import { v3ComponentFlow } from './v3.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
 import { uiLogger } from '../../ui/logger.js';
 import { commands } from '../../../lang/en.js';
@@ -23,7 +23,7 @@ export async function handleProjectCreationFlow(args) {
             projectNameAndDestPromptResponse,
         };
     }
-    const projectTemplates = await getProjectTemplateListFromRepo(repo, 'main');
+    const projectTemplates = await getProjectTemplateListFromRepo(repo, DEFAULT_PROJECT_TEMPLATE_BRANCH);
     if (!projectTemplates.length) {
         uiLogger.error(commands.project.create.errors.failedToFetchProjectList);
         process.exit(EXIT_CODES.ERROR);

package/lib/projects/create/legacy.js

@@ -1,5 +1,5 @@
 import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
-import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
+import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { debugError } from '../../errorHandlers/index.js';
 import { uiLogger } from '../../ui/logger.js';
@@ -12,7 +12,7 @@ export async function getConfigForPlatformVersion(platformVersion) {
     if (useV3Api(platformVersion)) {
         path = `${platformVersion}/`;
     }
-    const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, 'main');
+    const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, DEFAULT_PROJECT_TEMPLATE_BRANCH);
     return data;
 }
 export async function getProjectComponentListFromRepo(platformVersion) {

package/lib/projects/create/v3.d.ts

@@ -2,8 +2,6 @@ import { Separator } from '@inquirer/prompts';
 import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
 import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
-export declare const EMPTY_PROJECT = "empty";
-export declare const PROJECT_WITH_APP = "app";
 export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
     authType: string;
     distribution: string;

package/lib/projects/create/v3.js

@@ -1,5 +1,5 @@
 import { Separator } from '@inquirer/prompts';
-import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, } from '../../constants.js';
+import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../constants.js';
 import { commands, lib } from '../../../lang/en.js';
 import { listPrompt } from '../../prompts/promptUtils.js';
 import chalk from 'chalk';
@@ -8,8 +8,6 @@ import path from 'path';
 import { getConfigForPlatformVersion } from './legacy.js';
 import { logError } from '../../errorHandlers/index.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-export const EMPTY_PROJECT = 'empty';
-export const PROJECT_WITH_APP = 'app';
 export async function createV3App(providedAuth, providedDistribution) {
     let authType;
     if (providedAuth &&

package/lib/projects/localDev/LocalDevLogger.js

@@ -1,4 +1,4 @@
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+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';
@@ -6,6 +6,8 @@ import { uiBetaTag, uiLine, uiAccountDescription, uiCommandReference, } from '..
 import { lib } from '../../../lang/en.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
 import { logError } from '../../errorHandlers/index.js';
+import { isAutoOpenBrowserEnabled } from '../../configOptions.js';
+import { CONFIG_LOCAL_STATE_FLAGS } from '../../constants.js';
 class LocalDevLogger {
     state;
     mostRecentUploadWarning;
@@ -96,7 +98,14 @@ class LocalDevLogger {
         uiLogger.log('');
         uiLogger.log(lib.LocalDevManager.running(this.state.projectConfig.name, uiAccountDescription(this.state.targetProjectAccountId)));
         uiLogger.log(lib.LocalDevManager.viewProjectLink(this.state.projectConfig.name, this.state.targetProjectAccountId));
-        uiLogger.log(lib.LocalDevManager.viewLocalDevUILink(this.state.targetTestingAccountId));
+        const showWelcomeScreen = !hasLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
+        if (!isAutoOpenBrowserEnabled()) {
+            uiLogger.log(lib.LocalDevManager.viewLocalDevUILink(this.state.targetTestingAccountId, showWelcomeScreen));
+        }
+        else {
+            uiLogger.log('');
+            uiLogger.log(lib.LocalDevManager.localDevUIAutoMessage(this.state.targetTestingAccountId, showWelcomeScreen));
+        }
         uiLogger.log('');
         uiLogger.log(lib.LocalDevManager.quitHelper);
         uiLine();

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

@@ -24,6 +24,7 @@ declare class LocalDevProcess {
     private getIntermediateRepresentation;
     private updateProjectNodes;
     private updateProjectNodesAfterUpload;
+    private openLocalDevUi;
     handleFileChange(filePath: string, event: string): Promise<void>;
     handleConfigFileChange(): Promise<void>;
     start(): Promise<void>;
@@ -31,5 +32,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,5 +1,7 @@
 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';
@@ -8,6 +10,9 @@ import { mapToUserFriendlyName } from '@hubspot/project-parsing-lib/src/lib/tran
 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;
@@ -119,6 +124,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 {
@@ -144,6 +153,9 @@ class LocalDevProcess {
             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
@@ -196,5 +208,8 @@ class LocalDevProcess {
     sendDevServerMessage(message) {
         this.state.devServerMessage = message;
     }
+    removeStateListener(key, listener) {
+        this.state.removeListener(key, listener);
+    }
 }
 export default LocalDevProcess;

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

@@ -51,5 +51,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

@@ -111,5 +111,10 @@ class LocalDevState {
             listener(this[key]);
         }
     }
+    removeListener(key, listener) {
+        if (this._listeners[key]) {
+            this._listeners[key].splice(this._listeners[key].indexOf(listener), 1);
+        }
+    }
 }
 export default LocalDevState;

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

@@ -1,18 +1,18 @@
 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,13 +1,13 @@
 import { WebSocketServer } from 'ws';
 import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
 import { logger } from '@hubspot/local-dev-lib/logger';
-import { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
+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 = [
@@ -20,12 +20,6 @@ class LocalDevWebsocketServer {
         this.localDevProcess = localDevProcess;
         this.debug = debug;
     }
-    websocket() {
-        if (!this._websocket) {
-            throw new Error(lib.LocalDevWebsocketServer.errors.notInitialized(LOG_PREFIX));
-        }
-        return this._websocket;
-    }
     log(message) {
         if (this.debug) {
             logger.log(LOG_PREFIX, message);
@@ -36,24 +30,24 @@ class LocalDevWebsocketServer {
             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({
+            this.sendMessage(websocket, {
                 type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
             });
         }
         else {
-            this.sendMessage({
+            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) {
@@ -62,7 +56,10 @@ class LocalDevWebsocketServer {
                 }
                 switch (message.type) {
                     case LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
-                        this.handleUpload();
+                        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(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
@@ -73,8 +70,8 @@ class LocalDevWebsocketServer {
             }
         });
     }
-    sendProjectData() {
-        this.sendMessage({
+    sendProjectData(websocket) {
+        this.sendMessage(websocket, {
             type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
             data: {
                 projectName: this.localDevProcess.projectName,
@@ -84,19 +81,33 @@ class LocalDevWebsocketServer {
             },
         });
     }
-    setupStateListeners() {
-        this.localDevProcess.addStateListener('projectNodes', nodes => {
-            this.sendMessage({
+    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({
+        };
+        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 isPortManagerServerRunning();
@@ -113,17 +124,16 @@ class LocalDevWebsocketServer {
                 ws.close(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
                 return;
             }
-            this._websocket = ws;
-            this.sendProjectData();
-            this.setupMessageHandlers();
-            this.setupStateListeners();
+            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;
     }
 }
 export default LocalDevWebsocketServer;

package/lib/projects/upload.js

@@ -14,6 +14,7 @@ import { ensureProjectExists } from './ensureProjectExists.js';
 import { uiLogger } from '../ui/logger.js';
 import { useV3Api } from './buildAndDeploy.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
+import ProjectValidationError from '../errors/ProjectValidationError.js';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     SpinniesManager.init({});
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
@@ -107,17 +108,13 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
 export function validateSourceDirectory(srcDir, projectConfig) {
     const filenames = fs.readdirSync(srcDir);
     if (!filenames || filenames.length === 0) {
-        const validationError = new Error(lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
-        validationError.name = 'ProjectValidationError';
-        throw validationError;
+        throw new ProjectValidationError(lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
     }
 }
 export async function validateNoHSMetaMismatch(srcDir, projectConfig) {
     const hasHsMetaFiles = await projectContainsHsMetaFiles(srcDir);
     if (!useV3Api(projectConfig.platformVersion) && hasHsMetaFiles) {
-        const validationError = new Error(lib.projectUpload.wrongPlatformVersionMetaFiles);
-        validationError.name = 'ProjectValidationError';
-        throw validationError;
+        throw new ProjectValidationError(lib.projectUpload.wrongPlatformVersionMetaFiles);
     }
 }
 export async function handleTranslate(projectDir, projectConfig, accountId, skipValidation, profile) {
@@ -132,12 +129,8 @@ export async function handleTranslate(projectDir, projectConfig, accountId, skip
     }
     catch (e) {
         if (isTranslationError(e)) {
-            const validationError = new Error(e.toString());
-            validationError.name = 'ProjectValidationError';
-            throw validationError;
-        }
-        else {
-            logError(e);
+            throw new ProjectValidationError(e.toString(), { cause: e });
         }
+        throw e;
     }
 }

package/lib/projects/urls.d.ts

@@ -5,4 +5,4 @@ export declare function getProjectSettingsUrl(projectName: string, accountId: nu
 export declare function getProjectActivityUrl(projectName: string, accountId: number): string;
 export declare function getProjectBuildDetailUrl(projectName: string, buildId: number, accountId: number): string;
 export declare function getProjectDeployDetailUrl(projectName: string, deployId: number, accountId: number): string;
-export declare function getLocalDevUiUrl(accountId: number): string;
+export declare function getLocalDevUiUrl(accountId: number, showWelcomeScreen?: boolean): string;

package/lib/projects/urls.js

@@ -34,6 +34,6 @@ export function getProjectBuildDetailUrl(projectName, buildId, accountId) {
 export function getProjectDeployDetailUrl(projectName, deployId, accountId) {
     return `${getProjectActivityUrl(projectName, accountId)}/deploy/${deployId}`;
 }
-export function getLocalDevUiUrl(accountId) {
-    return `${getBaseUrl(accountId)}/developer-projects-local-dev/${accountId}`;
+export function getLocalDevUiUrl(accountId, showWelcomeScreen) {
+    return `${getBaseUrl(accountId)}/developer-projects-local-dev/${accountId}${showWelcomeScreen ? '?welcome' : ''}`;
 }

package/lib/sandboxes.d.ts

@@ -11,6 +11,10 @@ export declare const SANDBOX_API_TYPE_MAP: {
     readonly STANDARD_SANDBOX: 1;
     readonly DEVELOPMENT_SANDBOX: 2;
 };
+export declare const SANDBOX_TYPE_MAP_V2: {
+    readonly STANDARD_SANDBOX: "STANDARD";
+    readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
+};
 export declare function getSandboxTypeAsString(accountType?: AccountType): string;
 export declare function getHasSandboxesByType(parentAccountConfig: CLIAccount, type: AccountType): boolean;
 export declare function getAvailableSyncTypes(parentAccountConfig: CLIAccount, config: CLIAccount): Promise<Array<SandboxSyncTask>>;

package/lib/sandboxes.js

@@ -22,6 +22,10 @@ export const SANDBOX_API_TYPE_MAP = {
     [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
     [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
 };
+export const SANDBOX_TYPE_MAP_V2 = {
+    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
+    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
+};
 export function getSandboxTypeAsString(accountType) {
     if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
         return 'development'; // Only place we're using this specific name