@hubspot/cli 7.6.0-beta.13 → 7.6.0-beta.14

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/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,12 @@ 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,
+            loop: false,
+            pageSize: components.length,
         },
     ]);
     if (!result.componentTemplate) {

package/lib/prompts/promptUtils.js

@@ -133,6 +133,9 @@ function handleCheckboxPrompt(config) {
         validate: config.validate,
         loop: config.loop,
         theme: PROMPT_THEME,
+        shortcuts: {
+            invert: null,
+        },
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleConfirmPrompt(config) {

package/lib/prompts/selectProjectTemplatePrompt.js

@@ -51,6 +51,8 @@ export async function selectProjectTemplatePrompt(promptOptions, projectTemplate
                 selectedComponents.length === 0,
             type: 'checkbox',
             choices: componentTemplates,
+            loop: false,
+            pageSize: componentTemplates?.length,
         },
     ]);
     if (!result.componentTemplates) {

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.6.0-beta.13",
+    "version": "7.6.0-beta.14",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "type": "module",
     "dependencies": {
-        "@hubspot/local-dev-lib": "3.18.0",
-        "@hubspot/project-parsing-lib": "0.8.3",
+        "@hubspot/local-dev-lib": "3.19.0",
+        "@hubspot/project-parsing-lib": "0.8.5",
         "@hubspot/serverless-dev-runtime": "7.0.6",
         "@hubspot/theme-preview-dev-server": "0.0.10",
-        "@hubspot/ui-extensions-dev-server": "0.9.8",
+        "@hubspot/ui-extensions-dev-server": "0.10.0",
         "archiver": "7.0.1",
         "boxen": "8.0.1",
         "chalk": "5.4.1",

package/types/LocalDev.d.ts

@@ -1,17 +1,17 @@
 import { HSProfileVariables, IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { ProjectConfig } from './Projects.js';
 import LocalDevState from '../lib/projects/localDev/LocalDevState.js';
-import { APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../lib/constants.js';
+import { APP_INSTALLATION_STATES, LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../lib/constants.js';
 export type LocalDevStateConstructorOptions = {
     targetProjectAccountId: number;
     targetTestingAccountId: number;
     profile?: string;
     projectConfig: ProjectConfig;
     projectDir: string;
-    projectId: number;
-    projectName: string;
+    projectData: Project;
     debug?: boolean;
     initialProjectNodes: {
         [key: string]: IntermediateRepresentationNodeLocalDev;
@@ -23,6 +23,12 @@ export type LocalDevWebsocketMessage = {
     type: string;
     data?: unknown;
 };
+export type LocalDevDeployWebsocketMessage = {
+    type: typeof LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.DEPLOY;
+    data: {
+        force: boolean;
+    };
+};
 export type LocalDevStateListener<K extends keyof LocalDevState> = (value: LocalDevState[K]) => void;
 export type AppLocalDevData = {
     id: number;
@@ -32,3 +38,13 @@ export type AppLocalDevData = {
     scopeGroupIds: number[];
 };
 export type LocalDevServerMessage = ValueOf<typeof LOCAL_DEV_SERVER_MESSAGE_TYPES>;
+export type LocalDevProjectUploadResult = {
+    uploadSuccess: boolean;
+    buildSuccess: boolean;
+    deploySuccess?: boolean;
+    deployId?: number;
+};
+export type LocalDevProjectDeployResult = {
+    success: boolean;
+    deployId?: number;
+};

package/ui/index.js

@@ -1,5 +1,5 @@
 import { render } from 'ink';
-// Ink components will be enabled by setting the ENABLE_INK environment variable
+// Ink components will be enabled by setting the HUBSPOT_ENABLE_INK environment variable
 export async function renderInline(component) {
     const { unmount } = render(component, { patchConsole: false });
     unmount();