@hubspot/cli 7.7.27-experimental.2 → 7.7.29-experimental.0

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

@@ -1,7 +1,29 @@
 import fs from 'fs';
-import { handleComponentCollision } from '../components.js';
+import { handleComponentCollision, updateHsMetaFilesWithAutoGeneratedFields, } from '../components.js';
+import { uiLogger } from '../../ui/logger.js';
+import { coerceToValidUid } from '@hubspot/project-parsing-lib';
 vi.mock('fs');
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/project-parsing-lib', () => ({
+    coerceToValidUid: vi.fn(),
+    metafileExtension: '.module.meta.json',
+}));
+vi.mock('@hubspot/project-parsing-lib/src/lib/constants.js', () => ({
+    AppKey: 'app',
+}));
+vi.mock('../../../lang/en.js', () => ({
+    lib: {
+        projects: {
+            updateHsMetaFilesWithAutoGeneratedFields: {
+                header: 'Updating component metadata files...',
+                applicationLog: (type, uid, name) => `Updated ${type} component with uid: ${uid} and name: ${name}`,
+                componentLog: (type, uid) => `Updated ${type} component with uid: ${uid}`,
+            },
+        },
+    },
+}));
 const mockedFs = vi.mocked(fs);
+const mockCoerceToValidUid = vi.mocked(coerceToValidUid);
 describe('lib/projects/components', () => {
     describe('handleComponentCollision()', () => {
         const mockCollision = {
@@ -152,10 +174,9 @@ describe('lib/projects/components', () => {
                 collisions: [
                     'regular.js',
                     'nested/path/file.ts',
-                    'component.module.meta.json',
+                    'component.meta.json',
                     'another.meta.json',
                     'package.json',
-                    'nested/package.json',
                 ],
             };
             // Mock metafileExtension
@@ -166,16 +187,152 @@ describe('lib/projects/components', () => {
             const mockMetaContent = '{}';
             mockedFs.readFileSync.mockReturnValue(mockMetaContent);
             mockedFs.writeFileSync.mockImplementation(() => { });
+            // Track what files are being copied to debug the issue
             mockedFs.copyFileSync.mockImplementation(() => { });
             // Mock console.log for package.json handling
             const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
             handleComponentCollision(collision);
-            // Should copy 2 source files
-            expect(mockedFs.copyFileSync).toHaveBeenCalledTimes(2);
+            expect(mockedFs.readFileSync).toHaveBeenCalledTimes(2);
             // Should handle 2 metafiles
-            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/component.module.meta.json', 'utf-8');
-            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/another.meta.json', 'utf-8');
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/dest/path/package.json', 'utf-8');
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/package.json', 'utf-8');
             consoleSpy.mockRestore();
         });
     });
+    describe('updateHsMetaFilesWithAutoGeneratedFields()', () => {
+        const mockUiLogger = vi.mocked(uiLogger);
+        beforeEach(() => {
+            vi.resetAllMocks();
+            mockCoerceToValidUid.mockImplementation((input) => input);
+        });
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it('updates component metadata files with project-specific UIDs', () => {
+            const projectName = 'my-project';
+            const hsMetaFilePaths = [
+                '/path/to/component1.meta.json',
+                '/path/to/component2.meta.json',
+            ];
+            const component1 = {
+                type: 'card',
+                uid: 'old-uid-1',
+                config: {
+                    name: 'Old Name',
+                },
+            };
+            const component2 = {
+                type: 'function',
+                uid: 'old-uid-2',
+            };
+            mockedFs.readFileSync
+                .mockReturnValueOnce(JSON.stringify(component1))
+                .mockReturnValueOnce(JSON.stringify(component2));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid
+                .mockReturnValueOnce('card-my-project')
+                .mockReturnValueOnce('function-my-project');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component1.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'card-my-project',
+                config: {
+                    name: 'Old Name',
+                },
+            }, null, 2));
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component2.meta.json', JSON.stringify({
+                type: 'function',
+                uid: 'function-my-project',
+            }, null, 2));
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updating component metadata files...');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated card component with uid: card-my-project');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated function component with uid: function-my-project');
+        });
+        it('handles app components by updating both uid and config.name', () => {
+            const projectName = 'test-app';
+            const hsMetaFilePaths = ['/path/to/app.meta.json'];
+            const appComponent = {
+                type: 'app',
+                uid: 'old-app-uid',
+                config: {
+                    name: 'Old App Name',
+                    other: 'property',
+                },
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(appComponent));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue('app-test-app');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/app.meta.json', JSON.stringify({
+                type: 'app',
+                uid: 'app-test-app',
+                config: {
+                    name: 'test-app-Application',
+                    other: 'property',
+                },
+            }, null, 2));
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app-test-app and name: test-app-Application');
+        });
+        it('handles UID collisions by using timestamps', () => {
+            const projectName = 'collision-project';
+            const hsMetaFilePaths = ['/path/to/component1.meta.json'];
+            const existingUids = ['card-collision-project'];
+            const component1 = { type: 'card', uid: 'old-uid-1' };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component1));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            // Mock Date.now to return consistent value for testing
+            vi.spyOn(Date, 'now').mockReturnValue(1234567890);
+            mockCoerceToValidUid
+                .mockReturnValueOnce('card-collision-project')
+                .mockReturnValueOnce('card-1234567890-collision-project');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths, existingUids);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component1.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'card-1234567890-collision-project',
+            }, null, 2));
+        });
+        it('falls back to original uid when coerceToValidUid returns null', () => {
+            const projectName = 'fallback-project';
+            const hsMetaFilePaths = ['/path/to/component.meta.json'];
+            const component = {
+                type: 'card',
+                uid: 'original-uid',
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue(undefined);
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'original-uid',
+            }, null, 2));
+        });
+        it('handles empty hsMetaFilePaths array', () => {
+            const projectName = 'empty-project';
+            const hsMetaFilePaths = [];
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.readFileSync).not.toHaveBeenCalled();
+            expect(mockedFs.writeFileSync).not.toHaveBeenCalled();
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updating component metadata files...');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('');
+        });
+        it('handles components without config property for app type', () => {
+            const projectName = 'no-config-project';
+            const hsMetaFilePaths = ['/path/to/app.meta.json'];
+            const appComponent = {
+                type: 'app',
+                uid: 'app-uid',
+                // No config property
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(appComponent));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue('app-no-config-project');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/app.meta.json', JSON.stringify({
+                type: 'app',
+                uid: 'app-no-config-project',
+            }, null, 2));
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app-no-config-project');
+        });
+    });
 });

package/lib/projects/__tests__/localDevProjectHelpers.test.d.ts

@@ -0,0 +1 @@
+export {};

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;