@hubspot/cli 7.8.1-experimental.0 → 7.8.3-experimental.0

package/lib/projects/create/v3.js

@@ -52,6 +52,7 @@ export async function createV3App(providedAuth, providedDistribution) {
 const componentTypeToGateMap = {
     [AppEventsKey]: FEATURES.APP_EVENTS,
     [PagesKey]: FEATURES.APPS_HOME,
+    'workflow-action-tool': FEATURES.AGENT_TOOLS,
 };
 export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
     const enabledComponents = [];
@@ -73,18 +74,19 @@ export async function calculateComponentTemplateChoices(components, authType, di
         }
         if (Array.isArray(supportedAuthTypes) &&
             authType &&
-            !supportedAuthTypes.includes(authType)) {
+            !supportedAuthTypes.includes(authType.toLowerCase())) {
             disabledReasons.push(commands.project.add.error.authTypeNotAllowed(authType));
         }
         if (Array.isArray(supportedDistributions) &&
             distribution &&
-            !supportedDistributions.includes(distribution)) {
+            !supportedDistributions.includes(distribution.toLowerCase())) {
             disabledReasons.push(commands.project.add.error.distributionNotAllowed(distribution));
         }
-        if (componentTypeToGateMap[template.type]) {
-            const isUngated = await hasFeature(accountId, componentTypeToGateMap[template.type]);
+        const templateGate = componentTypeToGateMap[template.cliSelector || template.type];
+        if (templateGate) {
+            const isUngated = await hasFeature(accountId, templateGate);
             if (!isUngated) {
-                disabledReasons.push(commands.project.add.error.portalDoesNotHaveAccessToThisFeature(accountId));
+                disabledReasons.unshift(commands.project.add.error.portalDoesNotHaveAccessToThisFeature(accountId));
             }
         }
         if (disabledReasons.length > 0) {
@@ -96,7 +98,7 @@ export async function calculateComponentTemplateChoices(components, authType, di
         }
         else {
             enabledComponents.push({
-                name: template.label,
+                name: `${template.label} [${template.cliSelector || template.type}]`,
                 value: template,
             });
         }

package/lib/projects/localDev/AppDevModeInterface.js

@@ -75,7 +75,7 @@ class AppDevModeInterface {
     //   );
     // }
     async getAppInstallUrl() {
-        if (this.appNode?.config.auth.type === APP_AUTH_TYPES.OAUTH) {
+        if (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH) {
             return getOauthAppInstallUrl({
                 targetAccountId: this.localDevState.targetTestingAccountId,
                 env: this.localDevState.env,
@@ -216,12 +216,12 @@ class AppDevModeInterface {
         const newDistribution = newAppNode?.config.distribution;
         const oldAuthType = this.appNode?.config.auth.type;
         const newAuthType = newAppNode?.config.auth.type;
-        if (newDistribution === APP_DISTRIBUTION_TYPES.MARKETPLACE &&
-            oldDistribution !== APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+        if (newDistribution?.toLowerCase() === APP_DISTRIBUTION_TYPES.MARKETPLACE &&
+            oldDistribution?.toLowerCase() !== APP_DISTRIBUTION_TYPES.MARKETPLACE) {
             this.localDevState.addUploadWarning(lib.AppDevModeInterface.distributionChanged);
         }
-        else if (newAuthType === APP_AUTH_TYPES.OAUTH &&
-            oldAuthType !== APP_AUTH_TYPES.OAUTH) {
+        else if (newAuthType?.toLowerCase() === APP_AUTH_TYPES.OAUTH &&
+            oldAuthType?.toLowerCase() !== APP_AUTH_TYPES.OAUTH) {
             this.localDevState.addUploadWarning(lib.AppDevModeInterface.authTypeChanged);
         }
     };

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

@@ -18,9 +18,13 @@ declare class LocalDevLogger {
     cleanupError(): void;
     cleanupSuccess(): void;
     uploadInitiated(): void;
+    deployInitiated(): void;
     projectConfigMismatch(): void;
     uploadError(error: unknown): void;
     uploadSuccess(): void;
+    uploadSuccessAutoDeployDisabled(): void;
+    deployError(error?: unknown): void;
+    deploySuccess(): void;
     monitorConsoleOutput(): void;
 }
 export default LocalDevLogger;

package/lib/projects/localDev/LocalDevLogger.js

@@ -112,6 +112,9 @@ class LocalDevLogger {
     uploadInitiated() {
         uiLogger.log(lib.LocalDevProcess.uploadInitiated);
     }
+    deployInitiated() {
+        uiLogger.log(lib.LocalDevProcess.deployInitiated);
+    }
     projectConfigMismatch() {
         uiLogger.log(lib.LocalDevProcess.projectConfigMismatch);
     }
@@ -127,6 +130,25 @@ class LocalDevLogger {
         uiLine();
         logger.log('');
     }
+    uploadSuccessAutoDeployDisabled() {
+        uiLogger.warn(lib.LocalDevProcess.uploadSuccessAutoDeployDisabled);
+        uiLine();
+        logger.log('');
+    }
+    deployError(error) {
+        logger.log('');
+        if (error) {
+            logError(error);
+        }
+        uiLogger.log(lib.LocalDevProcess.deployFailed);
+        logger.log('');
+    }
+    deploySuccess() {
+        logger.log('');
+        uiLogger.log(lib.LocalDevProcess.deploySuccess);
+        uiLine();
+        logger.log('');
+    }
     monitorConsoleOutput() {
         const originalStdoutWrite = process.stdout.write.bind(process.stdout);
         function customStdoutWrite(chunk, encoding, callback) {

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

@@ -1,15 +1,15 @@
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
 import LocalDevState from './LocalDevState.js';
 import LocalDevLogger from './LocalDevLogger.js';
-import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevServerMessage } from '../../../types/LocalDev.js';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevServerMessage, LocalDevProjectUploadResult, LocalDevProjectDeployResult } from '../../../types/LocalDev.js';
 declare class LocalDevProcess {
     private state;
     private _logger;
     private devServerManager;
     constructor(options: LocalDevStateConstructorOptions);
     get projectDir(): string;
-    get projectId(): number;
-    get projectName(): string;
+    get projectData(): Project;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
     get projectNodes(): {
@@ -22,13 +22,15 @@ declare class LocalDevProcess {
     private projectConfigValidForUpload;
     private getIntermediateRepresentation;
     private updateProjectNodes;
-    private updateProjectNodesAfterUpload;
+    private updateProjectNodesAfterDeploy;
     private openLocalDevUi;
+    private updateProjectData;
     handleFileChange(filePath: string, event: string): Promise<void>;
     handleConfigFileChange(): Promise<void>;
     start(): Promise<void>;
     stop(showProgress?: boolean): Promise<void>;
-    uploadProject(): Promise<boolean>;
+    uploadProject(): Promise<LocalDevProjectUploadResult>;
+    deployLatestBuild(force?: boolean): Promise<LocalDevProjectDeployResult>;
     addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
     sendDevServerMessage(message: LocalDevServerMessage): void;
     removeStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;

package/lib/projects/localDev/LocalDevProcess.js

@@ -1,5 +1,6 @@
 import { translateForLocalDev } from '@hubspot/project-parsing-lib';
 import { hasLocalStateFlag } from '@hubspot/local-dev-lib/config';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
 import path from 'path';
 import open from 'open';
 import LocalDevState from './LocalDevState.js';
@@ -8,10 +9,13 @@ import DevServerManagerV2 from './DevServerManagerV2.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { getProjectConfig } from '../config.js';
 import { handleProjectUpload } from '../upload.js';
+import { handleProjectDeploy } from '../deploy.js';
 import { pollProjectBuildAndDeploy } from '../pollProjectBuildAndDeploy.js';
 import { getLocalDevUiUrl } from '../urls.js';
-import { CONFIG_LOCAL_STATE_FLAGS } from '../../constants.js';
+import { CONFIG_LOCAL_STATE_FLAGS, PROJECT_DEPLOY_STATES, } from '../../constants.js';
 import { isAutoOpenBrowserEnabled } from '../../configOptions.js';
+import { lib } from '../../../lang/en.js';
+import { debugError } from '../../errorHandlers/index.js';
 class LocalDevProcess {
     state;
     _logger;
@@ -27,11 +31,8 @@ class LocalDevProcess {
     get projectDir() {
         return this.state.projectDir;
     }
-    get projectId() {
-        return this.state.projectId;
-    }
-    get projectName() {
-        return this.state.projectName;
+    get projectData() {
+        return this.state.projectData;
     }
     get targetProjectAccountId() {
         return this.state.targetProjectAccountId;
@@ -87,34 +88,43 @@ class LocalDevProcess {
         });
         return true;
     }
-    getIntermediateRepresentation(projectNodesAtLastUpload) {
+    getIntermediateRepresentation(projectNodesAtLastDeploy) {
         return translateForLocalDev({
             projectSourceDir: path.join(this.state.projectDir, this.state.projectConfig.srcDir),
             platformVersion: this.state.projectConfig.platformVersion,
             accountId: this.state.targetProjectAccountId,
         }, {
-            projectNodesAtLastUpload,
+            projectNodesAtLastUpload: projectNodesAtLastDeploy,
             profile: this.state.profile,
         });
     }
     async updateProjectNodes() {
-        const intermediateRepresentation = await this.getIntermediateRepresentation(this.state.projectNodesAtLastUpload);
+        const intermediateRepresentation = await this.getIntermediateRepresentation(this.state.projectNodesAtLastDeploy);
         this.state.projectNodes =
             intermediateRepresentation.intermediateNodesIndexedByUid;
         this.state.projectProfileData = intermediateRepresentation.profileData;
     }
-    async updateProjectNodesAfterUpload() {
+    async updateProjectNodesAfterDeploy() {
         const intermediateRepresentation = await this.getIntermediateRepresentation();
         this.state.projectNodes =
             intermediateRepresentation.intermediateNodesIndexedByUid;
         this.state.projectProfileData = intermediateRepresentation.profileData;
-        this.state.projectNodesAtLastUpload =
+        this.state.projectNodesAtLastDeploy =
             intermediateRepresentation.intermediateNodesIndexedByUid;
     }
     openLocalDevUi() {
         const showWelcomeScreen = !hasLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
         open(getLocalDevUiUrl(this.state.targetTestingAccountId, showWelcomeScreen));
     }
+    async updateProjectData() {
+        try {
+            const { data: projectData } = await fetchProject(this.state.targetProjectAccountId, this.state.projectConfig.name);
+            this.state.projectData = projectData;
+        }
+        catch (e) {
+            debugError(e);
+        }
+    }
     async handleFileChange(filePath, event) {
         await this.updateProjectNodes();
         try {
@@ -162,24 +172,85 @@ class LocalDevProcess {
         const isUploadable = await this.projectConfigValidForUpload();
         if (!isUploadable) {
             this.logger.projectConfigMismatch();
-            return false;
+            return {
+                uploadSuccess: false,
+                buildSuccess: false,
+                deploySuccess: false,
+            };
         }
-        const { uploadError } = await handleProjectUpload({
+        const { uploadError, result } = await handleProjectUpload({
             accountId: this.state.targetProjectAccountId,
             projectConfig: this.state.projectConfig,
             projectDir: this.state.projectDir,
             callbackFunc: pollProjectBuildAndDeploy,
             sendIR: true,
-            skipValidation: true,
         });
+        const deploy = result?.deployResult;
         if (uploadError) {
             this.logger.uploadError(uploadError);
-            return false;
+            return {
+                uploadSuccess: false,
+                buildSuccess: false,
+                deploySuccess: false,
+                deployId: deploy?.deployId,
+            };
         }
-        await this.updateProjectNodesAfterUpload();
-        this.logger.uploadSuccess();
-        this.state.clearUploadWarnings();
-        return true;
+        await this.updateProjectData();
+        if (deploy && deploy.status === PROJECT_DEPLOY_STATES.FAILURE) {
+            return {
+                uploadSuccess: false,
+                buildSuccess: true,
+                deploySuccess: false,
+                deployId: deploy.deployId,
+            };
+        }
+        else if (!deploy) {
+            this.logger.uploadSuccessAutoDeployDisabled();
+        }
+        else {
+            await this.updateProjectNodesAfterDeploy();
+            this.state.clearUploadWarnings();
+            this.logger.uploadSuccess();
+        }
+        return {
+            uploadSuccess: true,
+            buildSuccess: true,
+            deploySuccess: Boolean(deploy),
+            deployId: deploy?.deployId,
+        };
+    }
+    async deployLatestBuild(force = false) {
+        this.logger.deployInitiated();
+        if (!this.state.projectData.latestBuild) {
+            this.logger.deployError(lib.LocalDevProcess.noBuildToDeploy);
+            return {
+                success: false,
+            };
+        }
+        let deploy;
+        try {
+            deploy = await handleProjectDeploy(this.state.targetProjectAccountId, this.state.projectConfig.name, this.state.projectData.latestBuild.buildId, true, force);
+        }
+        catch (error) {
+            this.logger.deployError(error);
+            return {
+                success: false,
+            };
+        }
+        const success = deploy?.status === PROJECT_DEPLOY_STATES.SUCCESS;
+        if (success) {
+            await this.updateProjectData();
+            this.logger.deploySuccess();
+            await this.updateProjectNodesAfterDeploy();
+            this.state.clearUploadWarnings();
+        }
+        else {
+            this.logger.deployError();
+        }
+        return {
+            success,
+            deployId: deploy?.deployId,
+        };
     }
     addStateListener(key, listener) {
         this.state.addListener(key, listener);

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

@@ -1,5 +1,6 @@
 import { IntermediateRepresentationNodeLocalDev, HSProfileVariables } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { ProjectConfig } from '../../../types/Projects.js';
 import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev.js';
 declare class LocalDevState {
@@ -8,26 +9,23 @@ declare class LocalDevState {
     private _profile?;
     private _projectConfig;
     private _projectDir;
-    private _projectId;
-    private _projectName;
+    private _projectData;
     private _debug;
     private _projectNodes;
     private _projectProfileData;
-    private _projectNodesAtLastUpload;
+    private _projectNodesAtLastDeploy;
     private _env;
     private _listeners;
     private _appData;
     private _devServerMessage;
     private _uploadWarnings;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
     get profile(): string | undefined;
     get projectConfig(): ProjectConfig;
     get projectDir(): string;
-    get projectId(): number;
-    get projectName(): string;
     get debug(): boolean;
     get projectNodes(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
@@ -37,12 +35,15 @@ declare class LocalDevState {
     });
     get projectProfileData(): HSProfileVariables;
     set projectProfileData(profileData: HSProfileVariables);
-    get projectNodesAtLastUpload(): {
+    get projectNodesAtLastDeploy(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
-    set projectNodesAtLastUpload(nodes: {
+    set projectNodesAtLastDeploy(nodes: {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     });
+    get projectData(): Project;
+    get projectId(): number;
+    set projectData(projectData: Project);
     get env(): Environment;
     get appData(): Record<string, AppLocalDevData>;
     getAppDataByUid(uid: string): AppLocalDevData | undefined;

package/lib/projects/localDev/LocalDevState.js

@@ -5,28 +5,26 @@ class LocalDevState {
     _profile;
     _projectConfig;
     _projectDir;
-    _projectId;
-    _projectName;
+    _projectData;
     _debug;
     _projectNodes;
     _projectProfileData;
-    _projectNodesAtLastUpload;
+    _projectNodesAtLastDeploy;
     _env;
     _listeners;
     _appData;
     _devServerMessage;
     _uploadWarnings;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._profile = profile;
         this._projectConfig = projectConfig;
         this._projectDir = projectDir;
-        this._projectId = projectId;
-        this._projectName = projectName;
+        this._projectData = projectData;
         this._debug = debug || false;
         this._projectNodes = initialProjectNodes;
-        this._projectNodesAtLastUpload = initialProjectNodes;
+        this._projectNodesAtLastDeploy = initialProjectNodes;
         this._projectProfileData = initialProjectProfileData;
         this._env = env;
         this._appData = {};
@@ -54,12 +52,6 @@ class LocalDevState {
     get projectDir() {
         return this._projectDir;
     }
-    get projectId() {
-        return this._projectId;
-    }
-    get projectName() {
-        return this._projectName;
-    }
     get debug() {
         return this._debug;
     }
@@ -76,11 +68,20 @@ class LocalDevState {
     set projectProfileData(profileData) {
         this._projectProfileData = profileData;
     }
-    get projectNodesAtLastUpload() {
-        return structuredClone(this._projectNodesAtLastUpload);
+    get projectNodesAtLastDeploy() {
+        return structuredClone(this._projectNodesAtLastDeploy);
+    }
+    set projectNodesAtLastDeploy(nodes) {
+        this._projectNodesAtLastDeploy = nodes;
+    }
+    get projectData() {
+        return structuredClone(this._projectData);
+    }
+    get projectId() {
+        return this.projectData.id;
     }
-    set projectNodesAtLastUpload(nodes) {
-        this._projectNodesAtLastUpload = nodes;
+    set projectData(projectData) {
+        this._projectData = projectData;
     }
     get env() {
         return this._env;

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

@@ -9,7 +9,9 @@ declare class LocalDevWebsocketServer {
     private logError;
     private sendMessage;
     private handleUpload;
+    private handleDeploy;
     private setupMessageHandlers;
+    private sendCliMetadata;
     private sendProjectData;
     private setupProjectNodesListener;
     private setupAppDataListener;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -2,10 +2,13 @@ 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 { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, } from '../../constants.js';
 import { lib } from '../../../lang/en.js';
 import { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
+import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, } 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 LOG_PREFIX = '[LocalDevWebsocketServer]';
 class LocalDevWebsocketServer {
     server;
@@ -35,17 +38,32 @@ class LocalDevWebsocketServer {
         websocket.send(JSON.stringify(message));
     }
     async handleUpload(websocket) {
-        const uploadSuccess = await this.localDevProcess.uploadProject();
-        if (uploadSuccess) {
-            this.sendMessage(websocket, {
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
-            });
-        }
-        else {
-            this.sendMessage(websocket, {
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
-            });
-        }
+        const { uploadSuccess, buildSuccess, deploySuccess, deployId } = await this.localDevProcess.uploadProject();
+        this.sendMessage(websocket, {
+            type: uploadSuccess
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                buildSuccess,
+                deploySuccess,
+                deployId,
+            },
+        });
+    }
+    async handleDeploy(websocket, force) {
+        const { success, deployId } = await this.localDevProcess.deployLatestBuild(force);
+        this.sendMessage(websocket, {
+            type: success
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                latestDeployId: deployId,
+            },
+        });
     }
     setupMessageHandlers(websocket) {
         websocket.on('message', data => {
@@ -55,15 +73,17 @@ class LocalDevWebsocketServer {
                     this.logError(lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
                     return;
                 }
-                switch (message.type) {
-                    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(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
+                if (isUploadWebsocketMessage(message)) {
+                    this.handleUpload(websocket);
+                }
+                else if (isDeployWebsocketMessage(message)) {
+                    this.handleDeploy(websocket, message.data.force);
+                }
+                else if (isViewedWelcomeScreenWebsocketMessage(message)) {
+                    addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
+                }
+                else {
+                    this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
                 }
             }
             catch (e) {
@@ -71,12 +91,23 @@ class LocalDevWebsocketServer {
             }
         });
     }
+    sendCliMetadata(websocket) {
+        this.sendMessage(websocket, {
+            type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.CLI_METADATA,
+            data: {
+                cliVersion: pkg.version,
+                localDevWebsocketServerVersion: LOCAL_DEV_WEBSOCKET_SERVER_VERSION,
+            },
+        });
+    }
     sendProjectData(websocket) {
         this.sendMessage(websocket, {
             type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
             data: {
-                projectName: this.localDevProcess.projectName,
-                projectId: this.localDevProcess.projectId,
+                projectName: this.localDevProcess.projectData.name,
+                projectId: this.localDevProcess.projectData.id,
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
                 targetProjectAccountId: this.localDevProcess.targetProjectAccountId,
                 targetTestingAccountId: this.localDevProcess.targetTestingAccountId,
             },
@@ -139,6 +170,7 @@ class LocalDevWebsocketServer {
                 ws.close(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
                 return;
             }
+            this.sendCliMetadata(ws);
             this.sendProjectData(ws);
             this.setupMessageHandlers(ws);
             this.setupStateListeners(ws);

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

@@ -18,7 +18,7 @@ import SpinniesManager from '../../../ui/SpinniesManager.js';
 import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { handleProjectUpload } from '../../upload.js';
 import { pollProjectBuildAndDeploy } from '../../pollProjectBuildAndDeploy.js';
-import { logError } from '../../../errorHandlers/index.js';
+import { debugError, logError } from '../../../errorHandlers/index.js';
 import { ApiErrorContext } from '../../../errorHandlers/index.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) {
@@ -163,6 +163,10 @@ export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountI
         }, { profile });
         return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
     }
+    catch (err) {
+        debugError(err);
+        return false;
+    }
     finally {
         // Clean up temporary directory
         if (tempDir && (await fs.pathExists(tempDir))) {

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

@@ -0,0 +1,4 @@
+import { LocalDevDeployWebsocketMessage, LocalDevWebsocketMessage } from '../../../types/LocalDev.js';
+export declare function isUploadWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isDeployWebsocketMessage(message: LocalDevWebsocketMessage): message is LocalDevDeployWebsocketMessage;
+export declare function isViewedWelcomeScreenWebsocketMessage(message: LocalDevWebsocketMessage): boolean;

package/lib/projects/localDev/localDevWebsocketServerUtils.js

@@ -0,0 +1,10 @@
+import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES } from '../../constants.js';
+export function isUploadWebsocketMessage(message) {
+    return message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD;
+}
+export function isDeployWebsocketMessage(message) {
+    return message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.DEPLOY;
+}
+export function isViewedWelcomeScreenWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.VIEWED_WELCOME_SCREEN);
+}

package/lib/projects/pollProjectBuildAndDeploy.js

@@ -278,10 +278,10 @@ export async function displayWarnLogs(accountId, projectName, taskId, isDeploy =
         }
     }
     if (result && result.logs) {
-        const logLength = result.logs.length;
-        result.logs.forEach((log, i) => {
-            uiLogger.warn(log.message);
-            if (i < logLength - 1) {
+        const dedupedLogs = result.logs.reduce((acc, log) => acc.add(log.message), new Set());
+        Array.from(dedupedLogs).forEach((log, i) => {
+            uiLogger.warn(log);
+            if (i < dedupedLogs.size - 1) {
                 uiLogger.log('');
             }
         });

package/lib/prompts/projectAddPrompt.js

@@ -62,10 +62,11 @@ export async function projectAddPromptV3(components, selectedFeatures) {
     const result = await promptUser([
         {
             name: 'componentTemplate',
-            message: lib.prompts.projectAddPrompt.selectType,
+            message: lib.prompts.projectAddPrompt.selectFeatures,
             when: !selectedFeatures && selectedComponents.length === 0,
             type: 'checkbox',
             choices: components,
+            pageSize: components.length,
         },
     ]);
     if (!result.componentTemplate) {