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

package/lib/__tests__/buildAccount.test.js

@@ -1,7 +1,7 @@
 import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
 import { accountNameExistsInConfig, updateAccountConfig, writeConfig, getAccountId, } from '@hubspot/local-dev-lib/config';
 import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
-import { createSandbox } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
 import { cliAccountNamePrompt } from '../prompts/accountNamePrompt.js';
@@ -33,6 +33,8 @@ const mockedCreateDeveloperTestAccount = createDeveloperTestAccount;
 const mockedFetchDeveloperTestAccountGateSyncStatus = fetchDeveloperTestAccountGateSyncStatus;
 const mockedGenerateDeveloperTestAccountPersonalAccessKey = generateDeveloperTestAccountPersonalAccessKey;
 const mockedCreateSandbox = createSandbox;
+const mockedCreateV2Sandbox = createV2Sandbox;
+const mockedGetPersonalAccessKey = getSandboxPersonalAccessKey;
 describe('lib/buildAccount', () => {
     describe('saveAccountToConfig()', () => {
         const mockAccountConfig = {
@@ -166,16 +168,17 @@ describe('lib/buildAccount', () => {
     });
     describe('buildSandbox()', () => {
         const mockParentAccountConfig = {
-            name: 'Developer Test Account',
+            name: 'Prod account',
             accountId: 123456,
-            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
             env: 'prod',
         };
         const mockSandbox = {
             sandboxHubId: 56789,
             parentHubId: 123456,
             createdAt: '2025-01-01',
-            type: 'sandbox',
+            type: 'STANDARD',
+            version: 'V1',
             archived: false,
             name: 'Test Sandbox',
             domain: 'test-sandbox.hubspot.com',
@@ -221,4 +224,59 @@ describe('lib/buildAccount', () => {
             await expect(buildAccount.buildSandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, mockParentAccountConfig.env, false)).rejects.toThrow();
         });
     });
+    describe('buildV2Sandbox()', () => {
+        const mockParentAccountConfig = {
+            name: 'Prod account',
+            accountId: 123456,
+            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+            env: 'prod',
+        };
+        const mockSandbox = {
+            sandboxHubId: 56789,
+            parentHubId: 123456,
+            createdAt: '2025-01-01',
+            type: 'STANDARD',
+            archived: false,
+            version: 'V2',
+            name: 'Test v2 Sandbox',
+            domain: 'test-v2-sandbox.hubspot.com',
+            createdByUser: {
+                id: 123456,
+                email: 'test@test.com',
+                firstName: 'Test',
+                lastName: 'User',
+            },
+        };
+        beforeEach(() => {
+            vi.spyOn(buildAccount, 'saveAccountToConfig').mockResolvedValue(mockParentAccountConfig.name);
+            mockedGetAccountId.mockReturnValue(mockParentAccountConfig.accountId);
+            mockedCreateV2Sandbox.mockResolvedValue({
+                data: mockSandbox,
+            });
+            mockedGetPersonalAccessKey.mockResolvedValue({
+                data: { personalAccessKey: { encodedOAuthRefreshToken: 'test-key' } },
+            });
+        });
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should create a v2 standard sandbox successfully and fetch a personal access key', async () => {
+            const result = await buildAccount.buildV2Sandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, false, mockParentAccountConfig.env, false);
+            expect(result).toEqual({ sandbox: mockSandbox });
+            expect(mockedGetPersonalAccessKey).toHaveBeenCalledWith(mockParentAccountConfig.accountId, mockSandbox.sandboxHubId);
+        });
+        it('should create a development sandbox successfully and fetch a personal access key', async () => {
+            const result = await buildAccount.buildV2Sandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, mockParentAccountConfig.env, false);
+            expect(result).toEqual({ sandbox: mockSandbox });
+            expect(mockedGetPersonalAccessKey).toHaveBeenCalledWith(mockParentAccountConfig.accountId, mockSandbox.sandboxHubId);
+        });
+        it('should throw error if account ID is not found', async () => {
+            mockedGetAccountId.mockReturnValue(null);
+            await expect(buildAccount.buildV2Sandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, false, mockParentAccountConfig.env, false)).rejects.toThrow();
+        });
+        it('should handle API errors when creating sandbox', async () => {
+            mockedCreateV2Sandbox.mockRejectedValue(new Error('test-error'));
+            await expect(buildAccount.buildV2Sandbox(mockSandbox.name, mockParentAccountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX, false, mockParentAccountConfig.env, false)).rejects.toThrow();
+        });
+    });
 });

package/lib/buildAccount.d.ts

@@ -1,7 +1,7 @@
 import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxResponse } from '@hubspot/local-dev-lib/types/Sandbox';
+import { SandboxResponse, V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
 import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare function saveAccountToConfig(accountId: number | undefined, accountName: string, env: Environment, personalAccessKey?: string, force?: boolean): Promise<string>;
 export declare function createDeveloperTestAccountV3(parentAccountId: number, testAccountConfig: DeveloperTestAccountConfig): Promise<{
@@ -14,4 +14,7 @@ type SandboxAccount = SandboxResponse & {
     name: string;
 };
 export declare function buildSandbox(sandboxName: string, parentAccountConfig: CLIAccount, sandboxType: SandboxAccountType, env: Environment, force?: boolean): Promise<SandboxAccount>;
+export declare function buildV2Sandbox(sandboxName: string, parentAccountConfig: CLIAccount, sandboxType: SandboxAccountType, syncObjectRecords: boolean, env: Environment, force?: boolean): Promise<{
+    sandbox: V2Sandbox;
+}>;
 export {};

package/lib/buildAccount.js

@@ -4,14 +4,14 @@ import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountId
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { createSandbox } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
 import { createDeveloperTestAccountConfigPrompt } from './prompts/createDeveloperTestAccountConfigPrompt.js';
 import { i18n } from './lang.js';
 import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { debugError, logError } from './errorHandlers/index.js';
-import { SANDBOX_API_TYPE_MAP, handleSandboxCreateError } from './sandboxes.js';
+import { SANDBOX_API_TYPE_MAP, SANDBOX_TYPE_MAP_V2, handleSandboxCreateError, } from './sandboxes.js';
 import { handleDeveloperTestAccountCreateError } from './developerTestAccounts.js';
 import { lib } from '../lang/en.js';
 import { poll } from './polling.js';
@@ -199,3 +199,58 @@ export async function buildSandbox(sandboxName, parentAccountConfig, sandboxType
     }
     return sandbox;
 }
+export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxType, syncObjectRecords, env, force = false) {
+    let i18nKey;
+    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
+        i18nKey = 'lib.sandbox.create.loading.standard';
+    }
+    else {
+        i18nKey = 'lib.sandbox.create.loading.developer';
+    }
+    const id = getAccountIdentifier(parentAccountConfig);
+    const parentAccountId = getAccountId(id);
+    if (!parentAccountId) {
+        throw new Error(i18n(`${i18nKey}.fail`));
+    }
+    SpinniesManager.init({
+        succeedColor: 'white',
+    });
+    logger.log('');
+    SpinniesManager.add('buildV2Sandbox', {
+        text: i18n(`${i18nKey}.add`, {
+            accountName: sandboxName,
+        }),
+    });
+    let sandbox;
+    let pak;
+    try {
+        const sandboxTypeV2 = SANDBOX_TYPE_MAP_V2[sandboxType];
+        const { data } = await createV2Sandbox(parentAccountId, sandboxName, sandboxTypeV2, syncObjectRecords);
+        sandbox = { ...data };
+        const { data: { personalAccessKey }, } = await getSandboxPersonalAccessKey(parentAccountId, sandbox.sandboxHubId);
+        pak = personalAccessKey.encodedOAuthRefreshToken;
+        SpinniesManager.succeed('buildV2Sandbox', {
+            text: i18n(`${i18nKey}.succeed`, {
+                accountName: sandboxName,
+                accountId: sandbox.sandboxHubId,
+            }),
+        });
+    }
+    catch (e) {
+        debugError(e);
+        SpinniesManager.fail('buildV2Sandbox', {
+            text: i18n(`${i18nKey}.fail`, {
+                accountName: sandboxName,
+            }),
+        });
+        handleSandboxCreateError(e, env, sandboxName, parentAccountId);
+    }
+    try {
+        await saveAccountToConfig(sandbox.sandboxHubId, sandboxName, env, pak, force);
+    }
+    catch (err) {
+        logError(err);
+        throw err;
+    }
+    return { sandbox };
+}

package/lib/commonOpts.js

@@ -7,6 +7,7 @@ import { debugError } from './errorHandlers/index.js';
 import { EXIT_CODES } from './enums/exitCodes.js';
 import { uiCommandReference } from './ui/index.js';
 import { i18n } from './lang.js';
+import { getTerminalUISupport, UI_COLORS } from './ui/index.js';
 export function addGlobalOptions(yargs) {
     yargs.version(false);
     yargs.option('debug', {
@@ -76,8 +77,32 @@ export function addJSONOutputOptions(yargs) {
         hidden: true,
     });
 }
+// Remove this once we've upgraded to yargs 18.0.0
+function uiBetaTagWithColor(message) {
+    const terminalUISupport = getTerminalUISupport();
+    const tag = i18n(`lib.ui.betaTagWithStyle`);
+    const result = `${terminalUISupport.color ? chalk.hex(UI_COLORS.SORBET)(tag) : tag} ${message}`;
+    return result;
+}
+// Remove this once we've upgraded to yargs 18.0.0
+function uiDeprecatedTagWithColor(message) {
+    const terminalUISupport = getTerminalUISupport();
+    const tag = i18n(`lib.ui.deprecatedTagWithStyle`);
+    const result = `${terminalUISupport.color ? chalk.yellow(tag) : tag} ${message}`;
+    return result;
+}
 export async function addCustomHelpOutput(yargs, command, describe) {
     try {
+        // Remove this once we've upgraded to yargs 18.0.0
+        if (describe && describe.includes(i18n(`lib.ui.betaTag`))) {
+            describe = describe.replace(i18n(`lib.ui.betaTag`) + ' ', '');
+            describe = uiBetaTagWithColor(describe);
+        }
+        // Remove this once we've upgraded to yargs 18.0.0
+        if (describe && describe.includes(i18n(`lib.ui.deprecatedTag`))) {
+            describe = describe.replace(i18n(`lib.ui.deprecatedTag`) + ' ', '');
+            describe = uiDeprecatedTagWithColor(describe);
+        }
         const parsedArgv = yargsParser(process.argv.slice(2));
         if (parsedArgv && parsedArgv.help) {
             const commandBase = `hs ${parsedArgv._.slice(0, -1).join(' ')}`;

package/lib/constants.d.ts

@@ -78,6 +78,8 @@ export declare const APP_AUTH_TYPES: {
 export declare const FEATURES: {
     readonly UNIFIED_THEME_PREVIEW: "cms:react:unifiedThemePreview";
     readonly UNIFIED_APPS: "Developers:UnifiedApps:PrivateBeta";
+    readonly SANDBOXES_V2: "sandboxes:v2:enabled";
+    readonly SANDBOXES_V2_CLI: "sandboxes:v2:cliEnabled";
 };
 export declare const LOCAL_DEV_UI_MESSAGE_SEND_TYPES: {
     UPLOAD_SUCCESS: string;
@@ -111,3 +113,5 @@ export declare const LOCAL_DEV_SERVER_MESSAGE_TYPES: {
 export declare const CONFIG_LOCAL_STATE_FLAGS: {
     readonly LOCAL_DEV_UI_WELCOME: "LOCAL_DEV_UI_WELCOME";
 };
+export declare const EMPTY_PROJECT = "empty";
+export declare const PROJECT_WITH_APP = "app";

package/lib/constants.js

@@ -70,6 +70,8 @@ export const APP_AUTH_TYPES = {
 export const FEATURES = {
     UNIFIED_THEME_PREVIEW: 'cms:react:unifiedThemePreview',
     UNIFIED_APPS: 'Developers:UnifiedApps:PrivateBeta',
+    SANDBOXES_V2: 'sandboxes:v2:enabled',
+    SANDBOXES_V2_CLI: 'sandboxes:v2:cliEnabled',
 };
 export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPLOAD_SUCCESS: 'server:uploadSuccess',
@@ -103,3 +105,5 @@ export const LOCAL_DEV_SERVER_MESSAGE_TYPES = {
 export const CONFIG_LOCAL_STATE_FLAGS = {
     LOCAL_DEV_UI_WELCOME: 'LOCAL_DEV_UI_WELCOME',
 };
+export const EMPTY_PROJECT = 'empty';
+export const PROJECT_WITH_APP = 'app';

package/lib/errorHandlers/index.js

@@ -5,6 +5,7 @@ import { shouldSuppressError } from './suppressError.js';
 import { i18n } from '../lang.js';
 import util from 'util';
 import { uiCommandReference } from '../ui/index.js';
+import { isProjectValidationError } from '../errors/ProjectValidationError.js';
 export function logError(error, context) {
     debugError(error, context);
     if (isProjectValidationError(error)) {
@@ -84,9 +85,6 @@ export class ApiErrorContext {
         this.projectName = props.projectName || '';
     }
 }
-function isProjectValidationError(error) {
-    return error instanceof Error && error.name === 'ProjectValidationError';
-}
 function isErrorWithMessageOrReason(error) {
     return (typeof error === 'object' &&
         error !== null &&

package/lib/errors/ProjectValidationError.d.ts

@@ -0,0 +1,4 @@
+export default class ProjectValidationError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare function isProjectValidationError(err: unknown): err is ProjectValidationError;

package/lib/errors/ProjectValidationError.js

@@ -0,0 +1,9 @@
+export default class ProjectValidationError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'ProjectValidationError';
+    }
+}
+export function isProjectValidationError(err) {
+    return err instanceof ProjectValidationError;
+}

package/lib/mcp/setup.d.ts

@@ -7,6 +7,9 @@ export declare const supportedTools: ({
 } | {
     name: "Windsurf";
     value: string;
+} | {
+    name: "VSCode";
+    value: string;
 })[];
 interface McpCommand {
     command: string;
@@ -15,6 +18,7 @@ interface McpCommand {
 export declare function addMintlifyMcpServer(installTargets: string[]): Promise<void>;
 export declare function setupMintlify(derivedTargets?: string[]): Promise<boolean>;
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
+export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupCursor(mcpCommand?: McpCommand): boolean;
 export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;

package/lib/mcp/setup.js

@@ -13,11 +13,13 @@ const mcpServerName = 'hubspot-cli-mcp';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
+const vscode = 'vscode';
 const supportedMintlifyClients = [windsurf, cursor];
 export const supportedTools = [
     { name: commands.mcp.setup.claudeCode, value: claudeCode },
     { name: commands.mcp.setup.cursor, value: cursor },
     { name: commands.mcp.setup.windsurf, value: windsurf },
+    { name: commands.mcp.setup.vsCode, value: vscode },
 ];
 const defaultMcpCommand = {
     command: 'hs',
@@ -75,6 +77,9 @@ export async function addMcpServerToConfig(targets) {
         if (derivedTargets.includes(windsurf)) {
             await runSetupFunction(setupWindsurf);
         }
+        if (derivedTargets.includes(vscode)) {
+            await runSetupFunction(setupVsCode);
+        }
         uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
     }
@@ -150,6 +155,37 @@ function setupMcpConfigFile(config) {
         return false;
     }
 }
+export async function setupVsCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('vsCode', {
+            text: commands.mcp.setup.spinners.configuringVsCode,
+        });
+        const mcpConfig = JSON.stringify({
+            name: mcpServerName,
+            ...buildCommandWithAgentString(mcpCommand, vscode),
+        });
+        await execAsync(`code --add-mcp '${mcpConfig}'`);
+        SpinniesManager.succeed('vsCode', {
+            text: commands.mcp.setup.spinners.configuredVsCode,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.includes('code: command not found')) {
+            SpinniesManager.fail('vsCode', {
+                text: commands.mcp.setup.spinners.vsCodeNotFound,
+            });
+        }
+        else {
+            SpinniesManager.fail('vsCode', {
+                text: commands.mcp.setup.spinners.failedToConfigureVsCode,
+            });
+            logError(error);
+        }
+        return false;
+    }
+}
 export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     try {
         SpinniesManager.add('claudeCode', {

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

@@ -16,6 +16,7 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => ({
         cleanup: vi.fn().mockResolvedValue(undefined),
     },
 }));
+vi.mock('open');
 vi.mock('@hubspot/project-parsing-lib');
 vi.mock('../upload');
 vi.mock('../config');
@@ -306,4 +307,38 @@ describe('LocalDevProcess', () => {
             expect(listener).toHaveBeenCalledWith(process.projectNodes);
         });
     });
+    describe('removeStateListener()', () => {
+        it('should remove state listener', () => {
+            const listener = vi.fn();
+            const key = 'projectNodes';
+            // Add the listener first
+            process.addStateListener(key, listener);
+            // Trigger state change to verify listener is called
+            // @ts-expect-error
+            process.state.projectNodes = {};
+            expect(listener).toHaveBeenCalledTimes(1);
+            // Remove the listener
+            process.removeStateListener(key, listener);
+            // Trigger state change again to verify listener is no longer called
+            // @ts-expect-error
+            process.state.projectNodes = { newNode: { uid: 'newNode' } };
+            expect(listener).toHaveBeenCalledTimes(1); // Should still be 1, not 2
+        });
+        it('should not affect other listeners when removing one', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            const key = 'projectNodes';
+            // Add two listeners
+            process.addStateListener(key, listener1);
+            process.addStateListener(key, listener2);
+            // Remove only the first listener
+            process.removeStateListener(key, listener1);
+            // Trigger state change
+            // @ts-expect-error
+            process.state.projectNodes = {};
+            // Only listener2 should be called
+            expect(listener1).not.toHaveBeenCalled();
+            expect(listener2).toHaveBeenCalled();
+        });
+    });
 });

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/v3AddComponent.js

@@ -1,6 +1,7 @@
 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';

package/lib/projects/create/index.js

@@ -1,8 +1,8 @@
 import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
 import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
-import { DEFAULT_PROJECT_TEMPLATE_BRANCH, 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';

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;