@hubspot/cli 7.8.0-experimental.0 → 7.8.2-experimental.0

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

@@ -99,7 +99,8 @@ describe('isDeployedProjectUpToDateWithLocal', () => {
         it('should clean up temp directory even when errors occur', async () => {
             // Mock downloadProject to throw an error after temp dir is created
             downloadProject.mockRejectedValue(new Error('Download Error'));
-            await expect(isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes)).rejects.toThrow('Download Error');
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(false);
             expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
         });
         it('should handle translateForLocalDev errors', async () => {
@@ -111,7 +112,8 @@ describe('isDeployedProjectUpToDateWithLocal', () => {
             extractZipArchive.mockResolvedValue(undefined);
             // Mock translate to throw an error
             translate.mockRejectedValue(new Error('Translation Error'));
-            await expect(isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes)).rejects.toThrow('Translation Error');
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(false);
             expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
         });
     });

package/lib/projects/create/__tests__/v3.test.js

@@ -1,8 +1,17 @@
 import { calculateComponentTemplateChoices } from '../v3.js';
+import { hasFeature } from '../../../hasFeature.js';
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/local-dev-lib/api/github');
+vi.mock('../../../hasFeature.js');
+const mockHasFeature = vi.mocked(hasFeature);
 describe('lib/projects/create/v3', () => {
+    beforeEach(() => {
+        mockHasFeature.mockResolvedValue(true);
+    });
     describe('calculateComponentTemplateChoices()', () => {
+        beforeEach(() => {
+            mockHasFeature.mockClear();
+        });
         const mockComponents = [
             {
                 label: 'Module Component',
@@ -30,7 +39,7 @@ describe('lib/projects/create/v3', () => {
             const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', 123, mockProjectMetadataForChoices);
             expect(choices).toHaveLength(4); // includes separator
             expect(choices[0]).toEqual({
-                name: 'Module Component',
+                name: 'Module Component [module]',
                 value: mockComponents[0],
             });
             expect(choices[2]).toEqual({
@@ -70,7 +79,7 @@ describe('lib/projects/create/v3', () => {
                 components: { module: { count: 0, maxCount: 5, hsMetaFiles: [] } },
             });
             expect(choices[0]).toEqual({
-                name: 'Unrestricted Component',
+                name: 'Unrestricted Component [module]',
                 value: componentsWithoutRestrictions[0],
             });
         });
@@ -94,7 +103,7 @@ describe('lib/projects/create/v3', () => {
             const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 213, projectMetadataWithWorkflowAction);
             expect(choices).toHaveLength(1); // no disabled components
             expect(choices[0]).toEqual({
-                name: 'Workflow Action Tool',
+                name: 'Workflow Action Tool [workflow-action-tool]',
                 value: componentWithCliSelector[0],
             });
         });
@@ -137,7 +146,7 @@ describe('lib/projects/create/v3', () => {
             const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, undefined);
             expect(choices).toHaveLength(1); // no disabled components
             expect(choices[0]).toEqual({
-                name: 'Workflow Action Tool',
+                name: 'Workflow Action Tool [workflow-action-tool]',
                 value: componentWithCliSelector[0],
             });
         });
@@ -162,5 +171,71 @@ describe('lib/projects/create/v3', () => {
             // @ts-expect-error breaking stuff on purpose
             projectMetadataWithoutComponents)).rejects.toThrow();
         });
+        it('disables gated components when hasFeature returns false', async () => {
+            mockHasFeature.mockResolvedValue(false);
+            const gatedComponent = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const choices = await calculateComponentTemplateChoices(gatedComponent, 'oauth', 'private', 123, mockProjectMetadataForChoices);
+            expect(choices).toHaveLength(3); // includes separators
+            expect(choices[1]).toEqual({
+                name: expect.stringContaining('Workflow Action Tool'),
+                value: gatedComponent[0],
+                disabled: expect.stringContaining('does not have access to this feature'),
+            });
+            expect(mockHasFeature).toHaveBeenCalledWith(123, expect.any(String));
+        });
+        it('enables gated components when hasFeature returns true', async () => {
+            mockHasFeature.mockResolvedValue(true);
+            const gatedComponent = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const projectMetadataWithWorkflowAction = {
+                hsMetaFiles: [],
+                components: {
+                    'workflow-action': { count: 0, maxCount: 3, hsMetaFiles: [] },
+                },
+            };
+            const choices = await calculateComponentTemplateChoices(gatedComponent, 'oauth', 'private', 123, projectMetadataWithWorkflowAction);
+            expect(choices).toHaveLength(1); // no disabled components
+            expect(choices[0]).toEqual({
+                name: 'Workflow Action Tool [workflow-action-tool]',
+                value: gatedComponent[0],
+            });
+            expect(mockHasFeature).toHaveBeenCalledWith(123, expect.any(String));
+        });
+        it('handles non-gated components without calling hasFeature', async () => {
+            const nonGatedComponent = [
+                {
+                    label: 'Regular Component',
+                    path: 'regular',
+                    type: 'module',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const choices = await calculateComponentTemplateChoices(nonGatedComponent, 'oauth', 'private', 123, mockProjectMetadataForChoices);
+            expect(choices).toHaveLength(1);
+            expect(choices[0]).toEqual({
+                name: 'Regular Component [module]',
+                value: nonGatedComponent[0],
+            });
+            // hasFeature should not be called for non-gated components
+            expect(mockHasFeature).not.toHaveBeenCalled();
+        });
     });
 });

package/lib/projects/create/v3.js

@@ -9,7 +9,7 @@ import { getConfigForPlatformVersion } from './legacy.js';
 import { logError } from '../../errorHandlers/index.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { hasFeature } from '../../hasFeature.js';
-import { AppEventsKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
+import { AppEventsKey, PagesKey, } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 export async function createV3App(providedAuth, providedDistribution) {
     let authType;
     if (providedAuth &&
@@ -51,6 +51,8 @@ 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 = [];
@@ -72,30 +74,31 @@ 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) {
             disabledComponents.push({
-                name: `[${chalk.yellow('DISABLED')}] ${template.label}`,
+                name: `[${chalk.yellow('DISABLED')}] ${template.label} -`,
                 value: template,
                 disabled: disabledReasons.join(' '),
             });
         }
         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;