@hubspot/cli 7.7.27-experimental.1 → 7.7.28-experimental.0

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

@@ -0,0 +1,118 @@
+import fs from 'fs-extra';
+import os from 'os';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
+import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
+import { isDeepEqual } from '@hubspot/local-dev-lib/isDeepEqual';
+import { translate } from '@hubspot/project-parsing-lib';
+import { isDeployedProjectUpToDateWithLocal } from '../localDev/helpers/project.js';
+// Mock all external dependencies
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/archive');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/local-dev-lib/isDeepEqual');
+vi.mock('fs-extra');
+vi.mock('os');
+vi.mock('../../utils/isDeepEqual.js');
+describe('isDeployedProjectUpToDateWithLocal', () => {
+    const mockProjectName = 'test-project';
+    const mockAccountId = 123456;
+    const mockBuildId = 789;
+    const mockProjectConfig = {
+        name: mockProjectName,
+        srcDir: 'src',
+        platformVersion: '1.0.0',
+    };
+    const mockLocalNode = {
+        uid: 'component1',
+        componentType: 'APP',
+        localDev: {
+            componentRoot: '/local/path',
+            componentConfigPath: '/local/path/config.json',
+            configUpdatedSinceLastUpload: false,
+        },
+        componentDeps: {},
+        metaFilePath: '/local/path',
+        config: { name: 'Component 1' },
+        files: [],
+    };
+    const mockLocalProjectNodes = {
+        component1: mockLocalNode,
+    };
+    const mockTempDir = '/tmp/test-temp-dir';
+    const mockZippedProject = Buffer.from('fake-zip-data');
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock fs.mkdtemp
+        fs.mkdtemp.mockResolvedValue(mockTempDir);
+        // Mock fs.pathExists
+        fs.pathExists.mockResolvedValue(true);
+        // Mock fs.remove
+        fs.remove.mockResolvedValue(undefined);
+        // Mock os.tmpdir
+        os.tmpdir.mockReturnValue('/tmp');
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('when projects are identical', () => {
+        it('should return true for identical projects', async () => {
+            // Mock downloadProject
+            downloadProject.mockResolvedValue({
+                data: mockZippedProject,
+            });
+            // Mock extractZipArchive
+            extractZipArchive.mockResolvedValue(undefined);
+            // Mock translate to return identical nodes
+            translate.mockResolvedValue({
+                intermediateNodesIndexedByUid: mockLocalProjectNodes,
+            });
+            // Mock isDeepEqual to return true for identical projects
+            isDeepEqual.mockReturnValue(true);
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(true);
+            expect(isDeepEqual).toHaveBeenCalledWith(mockLocalProjectNodes, mockLocalProjectNodes, ['localDev']);
+            expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
+        });
+    });
+    describe('when projects are different', () => {
+        it('should return false for different projects', async () => {
+            // Mock downloadProject
+            downloadProject.mockResolvedValue({
+                data: mockZippedProject,
+            });
+            // Mock extractZipArchive
+            extractZipArchive.mockResolvedValue(undefined);
+            // Mock translate to return different nodes
+            const differentDeployedNodes = {};
+            translate.mockResolvedValue({
+                intermediateNodesIndexedByUid: differentDeployedNodes,
+            });
+            // Mock isDeepEqual to return false for different projects
+            isDeepEqual.mockReturnValue(false);
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(false);
+            expect(isDeepEqual).toHaveBeenCalledWith(mockLocalProjectNodes, differentDeployedNodes, ['localDev']);
+        });
+    });
+    describe('error handling', () => {
+        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');
+            expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
+        });
+        it('should handle translateForLocalDev errors', async () => {
+            // Mock downloadProject
+            downloadProject.mockResolvedValue({
+                data: mockZippedProject,
+            });
+            // Mock extractZipArchive
+            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');
+            expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
+        });
+    });
+});

package/lib/projects/add/v3AddComponent.js

@@ -6,7 +6,7 @@ import path from 'path';
 import fs from 'fs';
 import { projectAddPromptV3 } from '../../prompts/projectAddPrompt.js';
 import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../constants.js';
-import { handleComponentCollision } from '../components.js';
+import { updateHsMetaFilesWithAutoGeneratedFields, handleComponentCollision, } from '../components.js';
 import { getProjectMetadata, } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
@@ -20,10 +20,10 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
         throw new Error(commands.project.add.error.failedToFetchComponentList);
     }
     const projectSrcDirectory = path.join(projectDir, projectConfig.srcDir);
-    const projectMetadata = await getProjectMetadata(projectSrcDirectory);
+    const currentProjectMetadata = await getProjectMetadata(projectSrcDirectory);
     let derivedAuthType;
     let derivedDistribution;
-    const appsMetadata = projectMetadata.components[AppKey];
+    const appsMetadata = currentProjectMetadata.components[AppKey];
     const shouldCreateApp = appsMetadata.count === 0;
     if (shouldCreateApp) {
         const { authType, distribution } = await createV3App(args.auth, args.distribution);
@@ -45,7 +45,7 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
         derivedDistribution = apps[0].config?.distribution;
         derivedAuthType = apps[0].config?.auth?.type;
     }
-    const componentTemplateChoices = calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, projectMetadata);
+    const componentTemplateChoices = calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, currentProjectMetadata);
     const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
     try {
         const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
@@ -71,6 +71,18 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
             branch: DEFAULT_PROJECT_TEMPLATE_BRANCH,
             handleCollision: handleComponentCollision,
         });
+        const updatedProjectMetadata = await getProjectMetadata(projectSrcDirectory);
+        const newHsMetaFiles = updatedProjectMetadata.hsMetaFiles.filter(hsMetaFile => !currentProjectMetadata.hsMetaFiles.includes(hsMetaFile));
+        const existingUids = currentProjectMetadata.hsMetaFiles.map(hsMetaFile => {
+            try {
+                const { uid } = JSON.parse(fs.readFileSync(hsMetaFile, 'utf8'));
+                return uid;
+            }
+            catch (err) {
+                return '';
+            }
+        });
+        updateHsMetaFilesWithAutoGeneratedFields(projectConfig.name, newHsMetaFiles, existingUids);
         uiLogger.success(commands.project.add.success(projectAddPromptResponse.componentTemplate
             .map(template => `'${template.label}'`)
             .join(', '), projectAddPromptResponse.componentTemplate.length > 1));

package/lib/projects/components.d.ts

@@ -1,2 +1,3 @@
 import { Collision } from '@hubspot/local-dev-lib/types/Archive';
 export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;
+export declare function updateHsMetaFilesWithAutoGeneratedFields(projectName: string, hsMetaFilePaths: string[], existingUids?: string[]): void;

package/lib/projects/components.js

@@ -1,6 +1,9 @@
 import path from 'path';
 import fs from 'fs';
-import { metafileExtension } from '@hubspot/project-parsing-lib';
+import { coerceToValidUid, metafileExtension, } from '@hubspot/project-parsing-lib';
+import { uiLogger } from '../ui/logger.js';
+import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
+import { lib } from '../../lang/en.js';
 // Handles a collision between component source files
 export function handleComponentCollision({ dest, src, collisions }) {
     const hsMetaFiles = [];
@@ -74,3 +77,26 @@ function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
         fs.writeFileSync(path.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
     });
 }
+export function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths, existingUids = []) {
+    uiLogger.log('');
+    uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.header);
+    for (const hsMetaFile of hsMetaFilePaths) {
+        const component = JSON.parse(fs.readFileSync(hsMetaFile).toString());
+        let uid = coerceToValidUid(`${component.type}-${projectName}`) || component.uid;
+        if (existingUids.includes(uid)) {
+            uid =
+                coerceToValidUid(`${component.type}-${Date.now()}-${projectName}`) ||
+                    component.uid;
+        }
+        component.uid = uid;
+        if (component.type === AppKey && component.config) {
+            component.config.name = `${projectName}-Application`;
+            uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.applicationLog(component.type, component.uid, component.config.name));
+        }
+        else {
+            uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.componentLog(component.type, component.uid));
+        }
+        fs.writeFileSync(hsMetaFile, JSON.stringify(component, null, 2));
+    }
+    uiLogger.log('');
+}

package/lib/projects/localDev/AppDevModeInterface.js

@@ -14,6 +14,7 @@ import { lib } from '../../../lang/en.js';
 import { uiLogger } from '../../ui/logger.js';
 import { getOauthAppInstallUrl, getStaticAuthAppInstallUrl, } from '../../app/urls.js';
 import { isDeveloperTestAccount, isSandbox } from '../../accountTypes.js';
+import SpinniesManager from '../../ui/SpinniesManager.js';
 class AppDevModeInterface {
     localDevState;
     localDevLogger;
@@ -86,7 +87,21 @@ class AppDevModeInterface {
         });
     }
     async fetchAppData() {
-        const { data: { results: portalApps }, } = await fetchPublicAppsForPortal(this.localDevState.targetProjectAccountId);
+        SpinniesManager.add('fetchAppData', {
+            text: lib.AppDevModeInterface.fetchAppData.checking(this.appNode?.config.name || ''),
+        });
+        let portalApps = [];
+        try {
+            const { data: { results }, } = await fetchPublicAppsForPortal(this.localDevState.targetProjectAccountId);
+            portalApps = results;
+        }
+        catch (e) {
+            SpinniesManager.fail('fetchAppData', {
+                text: lib.AppDevModeInterface.fetchAppData.error,
+            });
+            logError(e);
+            process.exit(EXIT_CODES.ERROR);
+        }
         const appData = portalApps.find(({ sourceId }) => sourceId === this.appNode?.uid);
         if (!appData) {
             return;
@@ -105,15 +120,18 @@ class AppDevModeInterface {
         if (!this.appData || !this.marketplaceAppInstalls) {
             return;
         }
+        SpinniesManager.fail('fetchAppData', {
+            text: lib.AppDevModeInterface.fetchAppData.activeInstallations(this.appNode?.config.name || '', this.marketplaceAppInstalls),
+            failColor: 'yellow',
+        });
         uiLine();
-        uiLogger.warn(lib.LocalDevManager.activeInstallWarning.installCount(this.appData.name, this.marketplaceAppInstalls));
         uiLogger.log(lib.LocalDevManager.activeInstallWarning.explanation);
         uiLine();
         const proceed = await confirmPrompt(lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
         if (!proceed) {
             process.exit(EXIT_CODES.SUCCESS);
         }
-        this.localDevLogger.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
+        this.localDevState.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
     }
     async autoInstallStaticAuthApp() {
         const shouldInstall = await installAppAutoPrompt();
@@ -177,8 +195,22 @@ class AppDevModeInterface {
             }
             const { needsInstall, isReinstall } = await this.checkTestAccountAppInstallation();
             if (needsInstall) {
+                if (SpinniesManager.pick('fetchAppData')) {
+                    SpinniesManager.fail('fetchAppData', {
+                        text: lib.AppDevModeInterface.fetchAppData.notInstalled(this.appNode.config.name, this.localDevState.targetTestingAccountId),
+                        failColor: 'white',
+                    });
+                }
                 await this.installAppOrOpenInstallUrl(isReinstall || false);
             }
+            else {
+                if (SpinniesManager.pick('fetchAppData')) {
+                    SpinniesManager.succeed('fetchAppData', {
+                        text: lib.AppDevModeInterface.fetchAppData.success(this.appNode.config.name, this.localDevState.targetTestingAccountId),
+                    });
+                }
+                uiLogger.log('');
+            }
         }
         catch (e) {
             logError(e);

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

@@ -2,20 +2,16 @@ import LocalDevState from './LocalDevState.js';
 declare class LocalDevLogger {
     private state;
     private mostRecentUploadWarning;
-    private uploadWarnings;
     constructor(state: LocalDevState);
     private logUploadInstructions;
     private handleError;
     getUploadCommand(): string;
     uploadWarning(): void;
-    addUploadWarning(warning: string): void;
-    clearUploadWarnings(): void;
     missingComponentsWarning(components: string[]): void;
     fileChangeError(e: unknown): void;
     devServerSetupError(e: unknown): void;
     devServerStartError(e: unknown): void;
     devServerCleanupError(e: unknown): void;
-    noDeployedBuild(): void;
     resetSpinnies(): void;
     startupMessage(): void;
     cleanupStart(): void;

package/lib/projects/localDev/LocalDevLogger.js

@@ -11,11 +11,9 @@ import { CONFIG_LOCAL_STATE_FLAGS } from '../../constants.js';
 class LocalDevLogger {
     state;
     mostRecentUploadWarning;
-    uploadWarnings;
     constructor(state) {
         this.state = state;
         this.mostRecentUploadWarning = null;
-        this.uploadWarnings = new Set();
     }
     logUploadInstructions(warning) {
         uiLogger.log('');
@@ -23,12 +21,7 @@ class LocalDevLogger {
         uiLogger.log('');
         uiLogger.log(lib.LocalDevManager.uploadWarning.instructionsHeader);
         uiLogger.log(lib.LocalDevManager.uploadWarning.stopDev);
-        if (this.state.isGithubLinked) {
-            uiLogger.log(lib.LocalDevManager.uploadWarning.pushToGithub);
-        }
-        else {
-            uiLogger.log(lib.LocalDevManager.uploadWarning.runUpload(this.getUploadCommand()));
-        }
+        uiLogger.log(lib.LocalDevManager.uploadWarning.runUpload(this.getUploadCommand()));
         uiLogger.log(lib.LocalDevManager.uploadWarning.restartDev);
     }
     handleError(e, langFunction) {
@@ -47,7 +40,7 @@ class LocalDevLogger {
     uploadWarning() {
         // At the moment, there is only one additional warning. We may need to do this in a
         // more robust way in the future
-        const additionalWarnings = Array.from(this.uploadWarnings).join('\n\n');
+        const additionalWarnings = Array.from(this.state.uploadWarnings).join('\n\n');
         const warning = `${lib.LocalDevManager.uploadWarning.defaultWarning} ${additionalWarnings}`;
         // Avoid logging the warning to the console if it is currently the most
         // recently logged warning. We do not want to spam the console with the same message.
@@ -56,12 +49,6 @@ class LocalDevLogger {
             this.mostRecentUploadWarning = warning;
         }
     }
-    addUploadWarning(warning) {
-        this.uploadWarnings.add(warning);
-    }
-    clearUploadWarnings() {
-        this.uploadWarnings.clear();
-    }
     missingComponentsWarning(components) {
         const warning = lib.LocalDevManager.uploadWarning.missingComponents(components.join(', '));
         if (warning !== this.mostRecentUploadWarning) {
@@ -81,10 +68,6 @@ class LocalDevLogger {
     devServerCleanupError(e) {
         this.handleError(e, lib.LocalDevManager.devServer.cleanupError);
     }
-    noDeployedBuild() {
-        uiLogger.error(lib.LocalDevManager.noDeployedBuild(this.state.projectConfig.name, uiAccountDescription(this.state.targetProjectAccountId), this.getUploadCommand()));
-        uiLogger.log('');
-    }
     resetSpinnies() {
         SpinniesManager.stopAll();
         SpinniesManager.init();

package/lib/projects/localDev/LocalDevManager.js

@@ -9,7 +9,7 @@ import { PROJECT_CONFIG_FILE } from '../../constants.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
 import DevServerManager from './DevServerManager.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { getAccountHomeUrl } from './helpers.js';
+import { getAccountHomeUrl } from '../urls.js';
 import { componentIsApp, componentIsPublicApp, CONFIG_FILES, getAppCardConfigs, getComponentUid, } from '../../projects/structure.js';
 import { ComponentTypes, } from '../../../types/Projects.js';
 import { UI_COLORS, uiCommandReference, uiAccountDescription, uiBetaTag, uiLink, uiLine, } from '../../ui/index.js';

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

@@ -19,7 +19,6 @@ declare class LocalDevProcess {
     private setupDevServers;
     private startDevServers;
     private cleanupDevServers;
-    private compareLocalProjectToDeployed;
     private projectConfigValidForUpload;
     private getIntermediateRepresentation;
     private updateProjectNodes;
@@ -30,7 +29,7 @@ declare class LocalDevProcess {
     start(): Promise<void>;
     stop(showProgress?: boolean): Promise<void>;
     uploadProject(): Promise<boolean>;
-    addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+    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

@@ -6,7 +6,6 @@ import LocalDevState from './LocalDevState.js';
 import LocalDevLogger from './LocalDevLogger.js';
 import DevServerManagerV2 from './DevServerManagerV2.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { mapToUserFriendlyName } from '@hubspot/project-parsing-lib/src/lib/transform.js';
 import { getProjectConfig } from '../config.js';
 import { handleProjectUpload } from '../upload.js';
 import { pollProjectBuildAndDeploy } from '../buildAndDeploy.js';
@@ -75,20 +74,6 @@ class LocalDevProcess {
             return false;
         }
     }
-    compareLocalProjectToDeployed() {
-        const deployedComponentNames = this.state.deployedBuild.subbuildStatuses.map(subbuildStatus => subbuildStatus.buildName);
-        const missingProjectNodes = [];
-        Object.values(this.projectNodes).forEach(node => {
-            if (!deployedComponentNames.includes(node.uid)) {
-                const userFriendlyName = mapToUserFriendlyName(node.componentType);
-                const label = userFriendlyName ? `[${userFriendlyName}] ` : '';
-                missingProjectNodes.push(`${label}${node.uid}`);
-            }
-        });
-        if (missingProjectNodes.length) {
-            this.logger.missingComponentsWarning(missingProjectNodes);
-        }
-    }
     async projectConfigValidForUpload() {
         const { projectConfig } = await getProjectConfig();
         if (!projectConfig) {
@@ -143,11 +128,6 @@ class LocalDevProcess {
     }
     async start() {
         this.logger.resetSpinnies();
-        // Local dev currently relies on the existence of a deployed build in the target account
-        if (!this.state.deployedBuild) {
-            this.logger.noDeployedBuild();
-            process.exit(EXIT_CODES.SUCCESS);
-        }
         const setupSucceeded = await this.setupDevServers();
         if (!setupSucceeded) {
             process.exit(EXIT_CODES.ERROR);
@@ -158,9 +138,6 @@ class LocalDevProcess {
         }
         await this.startDevServers();
         this.logger.monitorConsoleOutput();
-        // Verify that there are no mismatches between components in the local project
-        // and components in the deployed build of the project.
-        this.compareLocalProjectToDeployed();
     }
     async stop(showProgress = true) {
         if (showProgress) {
@@ -199,11 +176,11 @@ class LocalDevProcess {
         }
         await this.updateProjectNodesAfterUpload();
         this.logger.uploadSuccess();
-        this.logger.clearUploadWarnings();
+        this.state.clearUploadWarnings();
         return true;
     }
-    addStateListener(key, listener, callOnInit = false) {
-        this.state.addListener(key, listener, callOnInit);
+    addStateListener(key, listener) {
+        this.state.addListener(key, listener);
     }
     sendDevServerMessage(message) {
         this.state.devServerMessage = message;

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

@@ -1,4 +1,3 @@
-import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ProjectConfig } from '../../../types/Projects.js';
@@ -12,15 +11,14 @@ declare class LocalDevState {
     private _projectId;
     private _projectName;
     private _debug;
-    private _deployedBuild?;
-    private _isGithubLinked;
     private _projectNodes;
     private _projectNodesAtLastUpload;
     private _env;
     private _listeners;
     private _appData;
     private _devServerMessage;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, profile, env, }: LocalDevStateConstructorOptions);
+    private _uploadWarnings;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
@@ -30,8 +28,6 @@ declare class LocalDevState {
     get projectId(): number;
     get projectName(): string;
     get debug(): boolean;
-    get deployedBuild(): Build | undefined;
-    get isGithubLinked(): boolean;
     get projectNodes(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
@@ -50,7 +46,10 @@ declare class LocalDevState {
     setAppDataForUid(uid: string, appData: AppLocalDevData): void;
     get devServerMessage(): string;
     set devServerMessage(message: LocalDevServerMessage);
-    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+    get uploadWarnings(): Set<string>;
+    addUploadWarning(warning: string): void;
+    clearUploadWarnings(): void;
+    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
     removeListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
 }
 export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -8,15 +8,14 @@ class LocalDevState {
     _projectId;
     _projectName;
     _debug;
-    _deployedBuild;
-    _isGithubLinked;
     _projectNodes;
     _projectNodesAtLastUpload;
     _env;
     _listeners;
     _appData;
     _devServerMessage;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, profile, env, }) {
+    _uploadWarnings;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._profile = profile;
@@ -25,13 +24,12 @@ class LocalDevState {
         this._projectId = projectId;
         this._projectName = projectName;
         this._debug = debug || false;
-        this._deployedBuild = deployedBuild;
-        this._isGithubLinked = isGithubLinked;
         this._projectNodes = initialProjectNodes;
         this._projectNodesAtLastUpload = initialProjectNodes;
         this._env = env;
         this._appData = {};
         this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
+        this._uploadWarnings = new Set();
         this._listeners = {};
     }
     runListeners(key) {
@@ -63,12 +61,6 @@ class LocalDevState {
     get debug() {
         return this._debug;
     }
-    get deployedBuild() {
-        return this._deployedBuild && structuredClone(this._deployedBuild);
-    }
-    get isGithubLinked() {
-        return this._isGithubLinked;
-    }
     get projectNodes() {
         return structuredClone(this._projectNodes);
     }
@@ -102,14 +94,23 @@ class LocalDevState {
         this._devServerMessage = message;
         this.runListeners('devServerMessage');
     }
-    addListener(key, listener, callOnInit = false) {
+    get uploadWarnings() {
+        return this._uploadWarnings;
+    }
+    addUploadWarning(warning) {
+        this.uploadWarnings.add(warning);
+        this.runListeners('uploadWarnings');
+    }
+    clearUploadWarnings() {
+        this.uploadWarnings.clear();
+        this.runListeners('uploadWarnings');
+    }
+    addListener(key, listener) {
         if (!this._listeners[key]) {
             this._listeners[key] = [];
         }
         this._listeners[key].push(listener);
-        if (callOnInit) {
-            listener(this[key]);
-        }
+        listener(this[key]);
     }
     removeListener(key, listener) {
         if (this._listeners[key]) {

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

@@ -13,6 +13,7 @@ declare class LocalDevWebsocketServer {
     private sendProjectData;
     private setupProjectNodesListener;
     private setupAppDataListener;
+    private setupUploadWarningsListener;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -4,6 +4,7 @@ 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 { lib } from '../../../lang/en.js';
+import { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
 const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
 const LOG_PREFIX = '[LocalDevWebsocketServer]';
 class LocalDevWebsocketServer {
@@ -88,7 +89,7 @@ class LocalDevWebsocketServer {
                 data: nodes,
             });
         };
-        this.localDevProcess.addStateListener('projectNodes', listener, true);
+        this.localDevProcess.addStateListener('projectNodes', listener);
         websocket.on('close', () => {
             this.localDevProcess.removeStateListener('projectNodes', listener);
         });
@@ -100,14 +101,28 @@ class LocalDevWebsocketServer {
                 data: appData,
             });
         };
-        this.localDevProcess.addStateListener('appData', listener, true);
+        this.localDevProcess.addStateListener('appData', listener);
         websocket.on('close', () => {
             this.localDevProcess.removeStateListener('appData', listener);
         });
     }
+    setupUploadWarningsListener(websocket) {
+        const listener = (uploadWarnings) => {
+            const formattedUploadWarnings = Array.from(uploadWarnings).map(removeAnsiCodes);
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_UPLOAD_WARNINGS,
+                data: { uploadWarnings: formattedUploadWarnings },
+            });
+        };
+        this.localDevProcess.addStateListener('uploadWarnings', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('uploadWarnings', listener);
+        });
+    }
     setupStateListeners(websocket) {
         this.setupProjectNodesListener(websocket);
         this.setupAppDataListener(websocket);
+        this.setupUploadWarningsListener(websocket);
     }
     async start() {
         const portManagerIsRunning = await isPortManagerServerRunning();

package/lib/projects/localDev/{helpers.d.ts → helpers/account.d.ts}

@@ -1,10 +1,7 @@
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
-import { Project } from '@hubspot/local-dev-lib/types/Project';
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { ProjectConfig } from '../../../types/Projects.js';
-import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt.js';
+import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
 export declare function confirmDefaultAccountIsTarget(accountConfig: CLIAccount): Promise<void>;
 export declare function checkIfDefaultAccountIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): Promise<void>;
 export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount): void;
@@ -13,8 +10,5 @@ export declare function suggestRecommendedNestedAccount(accounts: CLIAccount[],
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
 export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV3?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
-export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
-export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
-export declare function getAccountHomeUrl(accountId: number): string;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;