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

package/lib/hasFeature.d.ts

@@ -1,3 +1,4 @@
 import { FEATURES } from './constants.js';
 import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
 export declare function hasFeature(accountId: number, feature: ValueOf<typeof FEATURES>): Promise<boolean>;
+export declare function hasUnfiedAppsAccess(accountId: number): Promise<boolean>;

package/lib/hasFeature.js

@@ -1,5 +1,12 @@
+import { http } from '@hubspot/local-dev-lib/http';
 import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
 export async function hasFeature(accountId, feature) {
     const { data: { enabledFeatures }, } = await fetchEnabledFeatures(accountId);
     return Boolean(enabledFeatures[feature]);
 }
+export async function hasUnfiedAppsAccess(accountId) {
+    const response = await http.get(accountId, {
+        url: 'developer-tooling/external/developer-portal/has-unified-dev-platform-access',
+    });
+    return Boolean(response.data);
+}

package/lib/importData.d.ts

@@ -0,0 +1,3 @@
+import { ImportRequest } from '@hubspot/local-dev-lib/types/Crm';
+export declare function handleImportData(targetAccountId: number, dataFileNames: string[], importRequest: ImportRequest): Promise<void>;
+export declare function handleTargetTestAccountSelectionFlow(derivedAccountId: number, userProvidedAccount: string | number | undefined): Promise<number>;

package/lib/importData.js

@@ -0,0 +1,50 @@
+import { getAccountConfig, getAccountId, getEnv, } from '@hubspot/local-dev-lib/config';
+import { createImport } from '@hubspot/local-dev-lib/api/crm';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { importDataTestAccountSelectPrompt } from './prompts/importDataTestAccountSelectPrompt.js';
+import { lib } from '../lang/en.js';
+import { isAppDeveloperAccount, isDeveloperTestAccount, isStandardAccount, } from './accountTypes.js';
+import { uiLogger } from './ui/logger.js';
+export async function handleImportData(targetAccountId, dataFileNames, importRequest) {
+    try {
+        const baseUrl = getHubSpotWebsiteOrigin(getEnv());
+        const response = await createImport(targetAccountId, importRequest, dataFileNames);
+        const importId = response.data.id;
+        uiLogger.success(lib.importData.viewImportLink(baseUrl, targetAccountId, importId));
+    }
+    catch (error) {
+        uiLogger.error(lib.importData.errors.failedToImportData);
+        throw error;
+    }
+}
+export async function handleTargetTestAccountSelectionFlow(derivedAccountId, userProvidedAccount) {
+    let targetAccountId = null;
+    if (userProvidedAccount) {
+        targetAccountId = getAccountId(userProvidedAccount);
+    }
+    // Only allow users to pass in test accounts
+    if (targetAccountId) {
+        const testAccount = getAccountConfig(targetAccountId);
+        if (!testAccount || !isDeveloperTestAccount(testAccount)) {
+            throw new Error(lib.importData.errors.notDeveloperTestAccount);
+        }
+    }
+    else {
+        const targetProjectAccountConfig = getAccountConfig(derivedAccountId);
+        if (!targetProjectAccountConfig) {
+            throw new Error(lib.importData.errors.noAccountConfig(derivedAccountId));
+        }
+        if (isDeveloperTestAccount(targetProjectAccountConfig)) {
+            targetAccountId = derivedAccountId;
+        }
+        else if (!isStandardAccount(targetProjectAccountConfig) &&
+            !isAppDeveloperAccount(targetProjectAccountConfig)) {
+            throw new Error(lib.importData.errors.incorrectAccountType(derivedAccountId));
+        }
+        else {
+            const { selectedAccountId } = await importDataTestAccountSelectPrompt(derivedAccountId);
+            targetAccountId = selectedAccountId;
+        }
+    }
+    return targetAccountId;
+}

package/lib/mcp/setup.d.ts

@@ -15,8 +15,6 @@ interface McpCommand {
     command: string;
     args: string[];
 }
-export declare function addMintlifyMcpServer(installTargets: string[]): Promise<void>;
-export declare function setupMintlify(derivedTargets?: string[]): Promise<boolean>;
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;

package/lib/mcp/setup.js

@@ -4,7 +4,6 @@ import { promptUser } from '../prompts/promptUtils.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError } from '../errorHandlers/index.js';
 import { execAsync } from '../../mcp-server/utils/command.js';
-import { spawn } from 'node:child_process';
 import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
@@ -14,7 +13,6 @@ const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
 const vscode = 'vscode';
-const supportedMintlifyClients = [windsurf, cursor];
 export const supportedTools = [
     { name: commands.mcp.setup.claudeCode, value: claudeCode },
     { name: commands.mcp.setup.cursor, value: cursor },
@@ -25,28 +23,6 @@ const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
 };
-export async function addMintlifyMcpServer(installTargets) {
-    await runSetupFunction(() => setupMintlify(installTargets));
-}
-export async function setupMintlify(derivedTargets = supportedMintlifyClients) {
-    uiLogger.info(commands.mcp.setup.installingDocSearch);
-    uiLogger.log('');
-    return new Promise(resolve => {
-        const subcommands = ['mint-mcp', 'add', 'hubspot-migration'];
-        const docsSearchClients = derivedTargets.filter(target => supportedMintlifyClients.includes(target));
-        const childProcess = spawn(`npx`, docsSearchClients && docsSearchClients.length
-            ? [...subcommands, '--client', ...docsSearchClients]
-            : subcommands, {
-            stdio: 'inherit',
-        });
-        childProcess.on('exit', code => {
-            if (code !== 0) {
-                resolve(false);
-            }
-            resolve(true);
-        });
-    });
-}
 export async function addMcpServerToConfig(targets) {
     try {
         let derivedTargets = [];

package/lib/process.js

@@ -1,29 +1,40 @@
 import readline from 'readline';
 import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
 import { i18n } from './lang.js';
+import { logError } from './errorHandlers/index.js';
+const SIGHUP = 'SIGHUP';
+const uncaughtException = 'uncaughtException';
 export const TERMINATION_SIGNALS = [
     'beforeExit',
     'SIGINT', // Terminal trying to interrupt (Ctrl + C)
     'SIGUSR1', // Start Debugger User-defined signal 1
     'SIGUSR2', // User-defined signal 2
-    'uncaughtException',
+    uncaughtException,
     'SIGTERM', // Represents a graceful termination
-    'SIGHUP', // Parent terminal has been closed
+    SIGHUP, // Parent terminal has been closed
 ];
 export function handleExit(callback) {
     let exitInProgress = false;
     TERMINATION_SIGNALS.forEach(signal => {
         process.removeAllListeners(signal);
-        process.on(signal, async () => {
+        process.on(signal, async (...args) => {
             // Prevent duplicate exit handling
             if (!exitInProgress) {
                 exitInProgress = true;
-                const isSIGHUP = signal === 'SIGHUP';
+                const isSIGHUP = signal === SIGHUP;
                 // Prevent logs when terminal closes
                 if (isSIGHUP) {
                     setLogLevel(LOG_LEVEL.NONE);
                 }
                 logger.debug(i18n(`lib.process.exitDebug`, { signal }));
+                if (signal === uncaughtException && args && args.length > 0) {
+                    try {
+                        logError(args[0]);
+                    }
+                    catch (e) {
+                        logger.error(args[0]);
+                    }
+                }
                 await callback({ isSIGHUP });
             }
         });

package/lib/projectProfiles.d.ts

@@ -4,4 +4,4 @@ export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
 export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
 export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined, useEnv?: boolean): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -38,7 +38,12 @@ export function loadProfile(projectConfig, projectDir, profileName) {
             uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
             return;
         }
-        return profile;
+        return {
+            ...profile,
+            accountId: process.env.HUBSPOT_ACCOUNT_ID
+                ? Number(process.env.HUBSPOT_ACCOUNT_ID)
+                : profile.accountId,
+        };
     }
     catch (e) {
         uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
@@ -54,7 +59,7 @@ export async function exitIfUsingProfiles(projectConfig, projectDir) {
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
+export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile, useEnv = false) {
     if (argsProfile) {
         logProfileHeader(argsProfile);
         const profile = loadProfile(projectConfig, projectDir, argsProfile);
@@ -63,6 +68,9 @@ export async function loadAndValidateProfile(projectConfig, projectDir, argsProf
             process.exit(EXIT_CODES.ERROR);
         }
         logProfileFooter(profile, true);
+        if (useEnv) {
+            return Number(process.env.HUBSPOT_ACCOUNT_ID);
+        }
         return profile.accountId;
     }
     else {

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

@@ -37,6 +37,7 @@ vi.mock('../../ui/logger');
 vi.mock('../../errorHandlers/index');
 vi.mock('../localDev/LocalDevState');
 vi.mock('../localDev/LocalDevLogger');
+vi.mock('../../ui/SpinniesManager');
 describe('AppDevModeInterface', () => {
     let appDevModeInterface;
     let mockLocalDevState;
@@ -98,10 +99,9 @@ describe('AppDevModeInterface', () => {
             getAppDataByUid: vi.fn(),
             setAppDataForUid: vi.fn(),
             addListener: vi.fn(),
-        };
-        mockLocalDevLogger = {
             addUploadWarning: vi.fn(),
         };
+        mockLocalDevLogger = {};
         // Mock constructors
         LocalDevState.mockImplementation(() => mockLocalDevState);
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
@@ -211,7 +211,7 @@ describe('AppDevModeInterface', () => {
             };
             await appDevModeInterface.setup({});
             expect(confirmPrompt).toHaveBeenCalled();
-            expect(mockLocalDevLogger.addUploadWarning).toHaveBeenCalled();
+            expect(mockLocalDevState.addUploadWarning).toHaveBeenCalled();
         });
         it('should exit if user declines marketplace warning', async () => {
             const marketplaceAppNode = {

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

@@ -32,51 +32,14 @@ describe('LocalDevProcess', () => {
         srcDir: 'src',
         platformVersion: '1.0.0',
     };
-    const mockSubbuildStatus = {
-        buildName: 'component1',
-        buildType: 'APP',
-        errorMessage: '',
-        finishedAt: new Date().toISOString(),
-        rootPath: '/test/path',
-        startedAt: new Date().toISOString(),
-        status: 'SUCCESS',
-        id: '123',
-        standardError: null,
-        visible: true,
-    };
-    const mockBuild = {
-        activitySource: { type: 'HUBSPOT' },
-        projectName: 'test-project',
-        uploadMessage: 'test-upload-message',
-        autoDeployId: 123,
-        buildId: 123,
-        createdAt: new Date().toISOString(),
-        deployableState: 'DEPLOYED',
-        finishedAt: new Date().toISOString(),
-        startedAt: new Date().toISOString(),
-        status: 'SUCCESS',
-        subbuildStatuses: [
-            { ...mockSubbuildStatus, buildName: 'component1' },
-            { ...mockSubbuildStatus, buildName: 'component2' },
-        ],
-        deployStatusTaskLocator: {
-            id: '123',
-            links: [],
-        },
-        enqueuedAt: new Date().toISOString(),
-        isAutoDeployEnabled: false,
-        portalId: 123,
-    };
     const mockOptions = {
         projectDir: '/test/project',
         projectConfig: mockProjectConfig,
         targetProjectAccountId: 123,
         targetTestingAccountId: 456,
         projectId: 789,
-        isGithubLinked: false,
         initialProjectNodes: {},
         env: ENVIRONMENTS.PROD,
-        deployedBuild: mockBuild,
         projectName: 'test-project',
     };
     beforeEach(() => {
@@ -87,7 +50,6 @@ describe('LocalDevProcess', () => {
             devServerStartError: vi.fn(),
             devServerCleanupError: vi.fn(),
             missingComponentsWarning: vi.fn(),
-            noDeployedBuild: vi.fn(),
             startupMessage: vi.fn(),
             monitorConsoleOutput: vi.fn(),
             cleanupStart: vi.fn(),
@@ -97,7 +59,6 @@ describe('LocalDevProcess', () => {
             projectConfigMismatch: vi.fn(),
             uploadError: vi.fn(),
             uploadSuccess: vi.fn(),
-            clearUploadWarnings: vi.fn(),
             fileChangeError: vi.fn(),
             uploadWarning: vi.fn(),
         };
@@ -118,14 +79,6 @@ describe('LocalDevProcess', () => {
         });
     });
     describe('start()', () => {
-        it('should exit if no deployed build exists', async () => {
-            const processWithoutBuild = new LocalDevProcess({
-                ...mockOptions,
-                deployedBuild: undefined,
-            });
-            await expect(processWithoutBuild.start()).rejects.toThrow('Process.exit called with code 0');
-            expect(mockLocalDevLogger.noDeployedBuild).toHaveBeenCalled();
-        });
         it('should exit if dev server setup fails', async () => {
             mockDevServerManager.setup.mockRejectedValue(new Error('Setup failed'));
             await expect(process.start()).rejects.toThrow('Process.exit called with code 1');
@@ -138,31 +91,6 @@ describe('LocalDevProcess', () => {
             expect(mockLocalDevLogger.monitorConsoleOutput).toHaveBeenCalled();
             expect(mockLocalDevLogger.missingComponentsWarning).not.toHaveBeenCalled();
         });
-        it('should warn about missing components', async () => {
-            const mockNode = {
-                uid: 'component3',
-                componentType: 'APP',
-                localDev: {
-                    componentRoot: '/test/path',
-                    componentConfigPath: '/test/path/config.json',
-                    configUpdatedSinceLastUpload: false,
-                },
-                componentDeps: {},
-                metaFilePath: '/test/path',
-                config: {},
-                files: [],
-            };
-            const processWithNode = new LocalDevProcess({
-                ...mockOptions,
-                initialProjectNodes: {
-                    component3: mockNode,
-                },
-            });
-            await processWithNode.start();
-            expect(mockLocalDevLogger.missingComponentsWarning).toHaveBeenCalledWith([
-                '[App] component3',
-            ]);
-        });
     });
     describe('stop()', () => {
         it('should exit with error if cleanup fails', async () => {
@@ -226,7 +154,8 @@ describe('LocalDevProcess', () => {
             });
             const success = await process.uploadProject();
             expect(mockLocalDevLogger.uploadSuccess).toHaveBeenCalled();
-            expect(mockLocalDevLogger.clearUploadWarnings).toHaveBeenCalled();
+            // @ts-expect-error accessing private property for testing
+            expect(process.state.uploadWarnings.size).toBe(0);
             expect(success).toBe(true);
         });
         it('should reset projectNodesAtLastUpload', async () => {
@@ -300,10 +229,10 @@ describe('LocalDevProcess', () => {
             process.state.projectNodes = {};
             expect(listener).toHaveBeenCalled();
         });
-        it('should call listener immediately when callOnInit is true', () => {
+        it('should call listener immediately', () => {
             const listener = vi.fn();
             const key = 'projectNodes';
-            process.addStateListener(key, listener, true);
+            process.addStateListener(key, listener);
             expect(listener).toHaveBeenCalledWith(process.projectNodes);
         });
     });
@@ -313,32 +242,13 @@ describe('LocalDevProcess', () => {
             const key = 'projectNodes';
             // Add the listener first
             process.addStateListener(key, listener);
-            // Trigger state change to verify listener is called
-            // @ts-expect-error
-            process.state.projectNodes = {};
             expect(listener).toHaveBeenCalledTimes(1);
             // Remove the listener
             process.removeStateListener(key, listener);
             // Trigger state change again to verify listener is no longer called
             // @ts-expect-error
             process.state.projectNodes = { newNode: { uid: 'newNode' } };
-            expect(listener).toHaveBeenCalledTimes(1); // Should still be 1, not 2
-        });
-        it('should not affect other listeners when removing one', () => {
-            const listener1 = vi.fn();
-            const listener2 = vi.fn();
-            const key = 'projectNodes';
-            // Add two listeners
-            process.addStateListener(key, listener1);
-            process.addStateListener(key, listener2);
-            // Remove only the first listener
-            process.removeStateListener(key, listener1);
-            // Trigger state change
-            // @ts-expect-error
-            process.state.projectNodes = {};
-            // Only listener2 should be called
-            expect(listener1).not.toHaveBeenCalled();
-            expect(listener2).toHaveBeenCalled();
+            expect(listener).toHaveBeenCalledTimes(1);
         });
     });
 });

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

@@ -66,7 +66,7 @@ describe('LocalDevWebsocketServer', () => {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function), true);
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
             expect(mockWebSocket.close).not.toHaveBeenCalled();
         });
         it('should reject connection from invalid origin', async () => {
@@ -215,7 +215,7 @@ describe('LocalDevWebsocketServer', () => {
             expect(mockWebSocket2.on).toHaveBeenCalledWith('message', expect.any(Function));
             expect(mockWebSocket3.on).toHaveBeenCalledWith('message', expect.any(Function));
             // Each connection should trigger state listener setup
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(6); // 2 listeners per connection * 3 connections
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(9); // 3 listeners per connection * 3 connections
             // Each connection should trigger dev server message
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledTimes(3);
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
@@ -284,16 +284,16 @@ describe('LocalDevWebsocketServer', () => {
             const closeCallbacks2 = mockWebSocket2.on.mock.calls
                 .filter(call => call[0] === 'close')
                 .map(call => call[1]);
-            expect(closeCallbacks1).toHaveLength(2); // projectNodes and appData listeners
-            expect(closeCallbacks2).toHaveLength(2); // projectNodes and appData listeners
+            expect(closeCallbacks1).toHaveLength(3); // projectNodes and appData listeners
+            expect(closeCallbacks2).toHaveLength(3); // projectNodes and appData listeners
             // Simulate first connection closing (call all close callbacks)
             closeCallbacks1.forEach(callback => callback());
             // Should have removed listeners for first connection (2 listeners: projectNodes and appData)
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(2);
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(3);
             // Simulate second connection closing
             closeCallbacks2.forEach(callback => callback());
             // Should have removed listeners for second connection as well
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(4);
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(6);
         });
         it('should broadcast state changes to all connected clients', () => {
             // Establish connections

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 {};