@hubspot/cli 7.9.0 → 7.9.1-experimental.0

package/lib/middleware/configMiddleware.d.ts

@@ -3,11 +3,16 @@ import { CLIOptions } from '@hubspot/local-dev-lib/types/CLIOptions';
 export declare function handleDeprecatedEnvVariables(argv: Arguments<{
     useEnv?: boolean;
 }>): void;
+export declare function handleCustomConfigLocationMiddleware(argv: Arguments<{
+    useEnv?: boolean;
+    config?: string;
+}>): void;
 /**
  * Auto-injects the derivedAccountId flag into all commands
  */
 export declare function injectAccountIdMiddleware(argv: Arguments<{
     account?: string;
+    config?: string;
 }>): Promise<void>;
-export declare function loadAndValidateConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
+export declare function validateConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
 export declare function validateAccountOptions(argv: Arguments): Promise<void>;

package/lib/middleware/configMiddleware.js

@@ -1,9 +1,11 @@
-import { loadConfig, getAccountId, configFileExists, getConfigPath, validateConfig, } from '@hubspot/local-dev-lib/config';
+import path from 'path';
+import { getConfigAccountIfExists, validateConfig, getConfigDefaultAccountIfExists, configFileExists, } from '@hubspot/local-dev-lib/config';
+import { getCwd } from '@hubspot/local-dev-lib/path';
 import { validateAccount } from '../validation.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { commands } from '../../lang/en.js';
 import { uiDeprecatedTag } from '../ui/index.js';
-import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from './commandTargetingUtils.js';
+import { shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from './commandTargetingUtils.js';
 import { parseStringToNumber } from '../parsing.js';
 import { uiLogger } from '../ui/logger.js';
 import { lib } from '../../lang/en.js';
@@ -17,6 +19,18 @@ export function handleDeprecatedEnvVariables(argv) {
         process.env.HUBSPOT_ACCOUNT_ID = process.env.HUBSPOT_PORTAL_ID;
     }
 }
+export function handleCustomConfigLocationMiddleware(argv) {
+    const { useEnv, config } = argv;
+    if (useEnv) {
+        process.env.USE_ENVIRONMENT_HUBSPOT_CONFIG = 'true';
+    }
+    else if (config && typeof config === 'string') {
+        const absoluteConfigPath = path.isAbsolute(config)
+            ? config
+            : path.join(getCwd(), config);
+        process.env.HUBSPOT_CONFIG_PATH = absoluteConfigPath;
+    }
+}
 /**
  * Auto-injects the derivedAccountId flag into all commands
  */
@@ -33,10 +47,23 @@ export async function injectAccountIdMiddleware(argv) {
         }
     }
     else {
-        argv.derivedAccountId = getAccountId(account);
+        // Wrap in try-catch to handle cases where config file doesn't exist yet (e.g., during hs init)
+        try {
+            let accountInConfig = account
+                ? getConfigAccountIfExists(account)
+                : undefined;
+            if (!accountInConfig) {
+                accountInConfig = getConfigDefaultAccountIfExists();
+            }
+            argv.derivedAccountId = accountInConfig?.accountId;
+        }
+        catch (err) {
+            // Config file doesn't exist yet, which is fine for commands like hs init
+            argv.derivedAccountId = undefined;
+        }
     }
 }
-export async function loadAndValidateConfigMiddleware(argv) {
+export async function validateConfigMiddleware(argv) {
     // Skip this when no command is provided
     if (!argv._.length || argv.help) {
         return;
@@ -45,23 +72,17 @@ export async function loadAndValidateConfigMiddleware(argv) {
     if (!shouldLoadConfigForCommand(argv._)) {
         return;
     }
-    // If the config file exists and the --config flag is used, exit with an error
-    if (configFileExists(true) &&
-        argv.config &&
-        !isTargetedCommand(argv._, { config: { migrate: true } })) {
-        uiLogger.error(commands.generalErrors.loadConfigMiddleware.configFileExists(getConfigPath()));
-        process.exit(EXIT_CODES.ERROR);
-    }
-    const config = loadConfig(argv.config, argv);
     // We don't run validation for auth because users should be able to run it when
     // no accounts are configured, but we still want to exit if the config file is not found
-    if (isTargetedCommand(argv._, { auth: true }) && !config) {
+    if (!process.env.USE_ENVIRONMENT_HUBSPOT_CONFIG && !configFileExists()) {
+        console.error('Config file not found, run hs account auth to configure your account');
         process.exit(EXIT_CODES.ERROR);
     }
     // Only validate the config if the command requires it
     if (shouldRunConfigValidationForCommand(argv._)) {
-        const configIsValid = validateConfig();
-        if (!configIsValid) {
+        const { isValid, errors } = validateConfig();
+        if (!isValid) {
+            uiLogger.error(commands.generalErrors.validateConfigMiddleware.configValidationFailed(errors));
             process.exit(EXIT_CODES.ERROR);
         }
     }

package/lib/middleware/gitMiddleware.js

@@ -1,15 +1,19 @@
-import { getConfigPath, configFileExists } from '@hubspot/local-dev-lib/config';
+import { getConfigFilePath, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
 import { checkAndWarnGitInclusion } from '../ui/git.js';
+import { debugError } from '../errorHandlers/index.js';
 export function checkAndWarnGitInclusionMiddleware(argv) {
     // Skip this when no command is provided
     if (argv._.length) {
         // Skip if using global config
-        if (configFileExists(true)) {
+        if (globalConfigFileExists()) {
             return;
         }
-        const configPath = getConfigPath();
-        if (configPath) {
+        try {
+            const configPath = getConfigFilePath();
             checkAndWarnGitInclusion(configPath);
         }
+        catch (error) {
+            debugError(error);
+        }
     }
 }

package/lib/npm.d.ts

@@ -7,3 +7,6 @@ export declare function getLatestCliVersion(): Promise<{
 export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
     cwd?: string;
 }): Promise<void>;
+export declare function executeUpdate(packages?: string[], flags?: string | null, options?: {
+    cwd?: string;
+}): Promise<void>;

package/lib/npm.js

@@ -25,3 +25,9 @@ export async function executeInstall(packages = [], flags, options) {
     const exec = util.promisify(execAsync);
     await exec(installCommand, options);
 }
+export async function executeUpdate(packages = [], flags, options) {
+    const updateCommand = `${DEFAULT_PACKAGE_MANAGER} update${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
+    uiLogger.debug('Running', updateCommand);
+    const exec = util.promisify(execAsync);
+    await exec(updateCommand, options);
+}

package/lib/oauth.d.ts

@@ -1,2 +1,2 @@
-import { OAuth2ManagerAccountConfig } from '@hubspot/local-dev-lib/types/Accounts';
-export declare function authenticateWithOauth(accountConfig: OAuth2ManagerAccountConfig): Promise<void>;
+import { OAuthConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function authenticateWithOauth(accountConfig: OAuthConfigAccount): Promise<void>;

package/lib/oauth.js

@@ -1,8 +1,7 @@
 import express from 'express';
 import open from 'open';
 import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { uiLogger } from './ui/logger.js';
@@ -14,15 +13,15 @@ import { EXIT_CODES } from './enums/exitCodes.js';
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
 function buildAuthUrl(oauthManager) {
-    const { env: accountEnv, clientId, scopes: accountScopes, } = oauthManager.account;
+    const { env: accountEnv, auth } = oauthManager.account;
     const env = accountEnv || ENVIRONMENTS.PROD;
-    const scopes = accountScopes || DEFAULT_OAUTH_SCOPES;
-    if (!clientId) {
+    const scopes = auth.scopes.length > 0 ? auth.scopes : DEFAULT_OAUTH_SCOPES;
+    if (!auth.clientId) {
         uiLogger.error(lib.oauth.missingClientId);
         process.exit(EXIT_CODES.ERROR);
     }
     return (`${getHubSpotWebsiteOrigin(env)}/oauth/${oauthManager.account.accountId}/authorize` +
-        `?client_id=${encodeURIComponent(clientId)}` + // app's client ID
+        `?client_id=${encodeURIComponent(auth.clientId)}` + // app's client ID
         `&scope=${encodeURIComponent(scopes.join(' '))}` + // scopes being requested by the app
         `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
     );
@@ -45,8 +44,8 @@ async function authorize(oauthManager) {
             if (req.query.code) {
                 const authCodeProof = {
                     grant_type: 'authorization_code',
-                    client_id: oauthManager.account.clientId,
-                    client_secret: oauthManager.account.clientSecret,
+                    client_id: oauthManager.account.auth.clientId,
+                    client_secret: oauthManager.account.auth.clientSecret,
                     redirect_uri: redirectUri,
                     code: req.query.code,
                 };
@@ -82,8 +81,7 @@ async function authorize(oauthManager) {
     });
 }
 function setupOauth(accountConfig) {
-    const accountId = getAccountIdentifier(accountConfig);
-    const config = getAccountConfig(accountId);
+    const config = getConfigAccountById(accountConfig.accountId);
     return new OAuth2Manager({
         ...accountConfig,
         env: accountConfig.env || config?.env || ENVIRONMENTS.PROD,

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

@@ -12,7 +12,7 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => {
 });
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { fetchAppMetadataByUid, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import AppDevModeInterface from '../localDev/AppDevModeInterface.js';
 import LocalDevState from '../localDev/LocalDevState.js';
 import LocalDevLogger from '../localDev/LocalDevLogger.js';
@@ -121,7 +121,7 @@ describe('AppDevModeInterface', () => {
                 previouslyAuthorizedScopeGroups: [],
             },
         });
-        getAccountConfig.mockReturnValue({
+        getConfigAccountById.mockReturnValue({
             parentAccountId: 12345,
         });
         isDeveloperTestAccount.mockReturnValue(true);
@@ -290,13 +290,14 @@ describe('AppDevModeInterface', () => {
         });
         it('should handle app reinstallation', async () => {
             // Set up conditions for non-automatic installation
-            getAccountConfig.mockReturnValue(null);
             fetchAppInstallationData.mockResolvedValue({
                 data: {
                     isInstalledWithScopeGroups: false,
                     previouslyAuthorizedScopeGroups: ['old-scope'],
                 },
             });
+            // Make it not automatically installable by making it not a test account
+            isDeveloperTestAccount.mockReturnValue(false);
             await appDevModeInterface.setup();
             expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
         });
@@ -308,7 +309,7 @@ describe('AppDevModeInterface', () => {
         });
         it('should exit if user declines auto-install', async () => {
             // Set up conditions for automatic installation
-            getAccountConfig.mockReturnValue({
+            getConfigAccountById.mockReturnValue({
                 parentAccountId: 12345, // matches targetProjectAccountId
             });
             isDeveloperTestAccount.mockReturnValue(true);
@@ -375,6 +376,15 @@ describe('AppDevModeInterface', () => {
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
+            getConfigAccountById.mockReturnValue({
+                parentAccountId: 12345,
+            });
+            isDeveloperTestAccount.mockReturnValue(true);
+            isSandbox.mockReturnValue(false);
+            installAppAutoPrompt.mockResolvedValue(true);
+            confirmPrompt.mockResolvedValue(true);
+            installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
+            isServerRunningAtUrl.mockResolvedValue(true);
             installAppBrowserPrompt.mockImplementation(async () => {
                 const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
                 if (addListenerCall) {
@@ -387,8 +397,8 @@ describe('AppDevModeInterface', () => {
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
             mockLocalDevState.addListener = vi.fn();
-            // Target account config is missing
-            getAccountConfig.mockReturnValue(null);
+            // Target account config is missing - make it not a test account so isAutomaticallyInstallable returns false
+            isDeveloperTestAccount.mockReturnValue(false);
             // App is not installed
             fetchAppInstallationData.mockResolvedValue({
                 data: {
@@ -401,6 +411,7 @@ describe('AppDevModeInterface', () => {
                 localDevState: mockLocalDevState,
                 localDevLogger: mockLocalDevLogger,
             });
+            // Remove the spy to see if that's causing the timeout
             await newAppDevModeInterface.setup();
             expect(installAppBrowserPrompt).toHaveBeenCalled();
         });

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

@@ -28,6 +28,7 @@ vi.mock('@hubspot/local-dev-lib/config', () => ({
     getAccountId: vi.fn().mockReturnValue(123),
     hasLocalStateFlag: vi.fn().mockReturnValue(false),
     getConfigDefaultAccount: vi.fn().mockReturnValue({ accountId: 123 }),
+    globalConfigFileExists: vi.fn().mockReturnValue(true),
 }));
 vi.mock('@hubspot/local-dev-lib/urls', () => ({
     getHubSpotApiOrigin: vi.fn().mockReturnValue('https://api.hubspot.com'),

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

@@ -26,6 +26,7 @@ vi.mock('../deploy');
 vi.mock('../config');
 vi.mock('@hubspot/local-dev-lib/api/projects');
 vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../localDev/LocalDevLogger');
 vi.mock('../localDev/DevServerManager');
 // Tests for LocalDevProcess and LocalDevState

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

@@ -2,8 +2,10 @@ import fs from 'fs';
 import { handleComponentCollision, updateHsMetaFilesWithAutoGeneratedFields, } from '../components.js';
 import { uiLogger } from '../../ui/logger.js';
 import { coerceToValidUid } from '@hubspot/project-parsing-lib';
+import { fileExists } from '../../validation.js';
 vi.mock('fs');
 vi.mock('../../ui/logger.js');
+vi.mock('../../validation.js');
 vi.mock('@hubspot/project-parsing-lib', () => ({
     coerceToValidUid: vi.fn(),
     metafileExtension: '.module.meta.json',
@@ -19,11 +21,15 @@ vi.mock('../../../lang/en.js', () => ({
                 applicationLog: (type, uid, name) => `Updated ${type} component with uid: ${uid} and name: ${name}`,
                 componentLog: (type, uid) => `Updated ${type} component with uid: ${uid}`,
             },
+            generateSafeFilenameDifferentiator: {
+                failedToCheckFiles: 'Failed to check files for filename differentiator. Falling back to timestamp.',
+            },
         },
     },
 }));
 const mockedFs = vi.mocked(fs);
 const mockCoerceToValidUid = vi.mocked(coerceToValidUid);
+const mockedFileExists = vi.mocked(fileExists);
 describe('lib/projects/components', () => {
     describe('handleComponentCollision()', () => {
         const mockCollision = {
@@ -33,13 +39,13 @@ describe('lib/projects/components', () => {
         };
         beforeEach(() => {
             vi.resetAllMocks();
-            // Mock Date.now to return consistent values for testing
-            vi.spyOn(Date, 'now').mockReturnValue(1234567890);
+            // Default: fileExists returns false (file doesn't exist)
+            mockedFileExists.mockReturnValue(false);
         });
         afterEach(() => {
             vi.restoreAllMocks();
         });
-        it('handles source file collisions by renaming them with timestamps', () => {
+        it('handles source file collisions by renaming them with sequential numbers', () => {
             const collision = {
                 ...mockCollision,
                 collisions: ['component.js', 'utils.ts'],
@@ -47,8 +53,8 @@ describe('lib/projects/components', () => {
             mockedFs.copyFileSync.mockImplementation(() => { });
             handleComponentCollision(collision);
             expect(mockedFs.copyFileSync).toHaveBeenCalledTimes(2);
-            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-1234567890.js');
-            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-1234567890.ts');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-2.js');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-2.ts');
         });
         it('handles metafile collisions by renaming and updating references', () => {
             const collision = {
@@ -69,8 +75,8 @@ describe('lib/projects/components', () => {
             });
             handleComponentCollision(collision);
             expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/component.module.meta.json', 'utf-8');
-            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-1234567890.module.meta.json', expect.stringContaining('source-1234567890.js'));
-            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/source.js', '/dest/path/source-1234567890.js');
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-2.module.meta.json', expect.stringContaining('source-2.js'));
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/source.js', '/dest/path/source-2.js');
         });
         it('handles package.json collisions by merging dependencies', () => {
             const collision = {
@@ -150,10 +156,10 @@ describe('lib/projects/components', () => {
             const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
             handleComponentCollision(collision);
             // Verify source files are copied with new names
-            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-1234567890.js');
-            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-1234567890.ts');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-2.js');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-2.ts');
             // Verify metafile is updated and written with new name
-            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-1234567890.module.meta.json', expect.stringContaining('component-1234567890.js'));
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-2.module.meta.json', expect.stringContaining('component-2.js'));
             // Verify package.json is merged
             expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/package.json', expect.stringContaining('"dependencies"'));
             consoleSpy.mockRestore();
@@ -198,6 +204,47 @@ describe('lib/projects/components', () => {
             expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/package.json', 'utf-8');
             consoleSpy.mockRestore();
         });
+        it('falls back to timestamp when maxAttempts is exhausted', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['component.js'],
+            };
+            // Mock Date.now to return a consistent timestamp
+            const mockTimestamp = 1234567890;
+            vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+            // Mock fileExists to return true 10 times (exhausting maxAttempts)
+            // The function starts with differentiator = 1, then increments to 2, 3, etc.
+            // It will try 10 times (differentiators 2-11), and if all return true,
+            // maxAttempts will be 0 and it will fall back to timestamp
+            mockedFileExists.mockReturnValue(true);
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            handleComponentCollision(collision);
+            // Should use timestamp as differentiator
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', `/dest/path/component-${mockTimestamp}.js`);
+            vi.restoreAllMocks();
+        });
+        it('falls back to timestamp when fileExists throws an error', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['component.js'],
+            };
+            // Mock Date.now to return a consistent timestamp
+            const mockTimestamp = 9876543210;
+            vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+            // Mock fileExists to throw an error
+            const mockError = new Error('File system error');
+            mockedFileExists.mockImplementation(() => {
+                throw mockError;
+            });
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            const mockUiLogger = vi.mocked(uiLogger);
+            handleComponentCollision(collision);
+            // Should log debug message about the error
+            expect(mockUiLogger.debug).toHaveBeenCalledWith('Failed to check files for filename differentiator. Falling back to timestamp.');
+            // Should use timestamp as differentiator
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', `/dest/path/component-${mockTimestamp}.js`);
+            vi.restoreAllMocks();
+        });
     });
     describe('updateHsMetaFilesWithAutoGeneratedFields()', () => {
         const mockUiLogger = vi.mocked(uiLogger);
@@ -233,20 +280,22 @@ describe('lib/projects/components', () => {
                 .mockReturnValueOnce('card-my-project')
                 .mockReturnValueOnce('function-my-project');
             updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-project_card');
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-project_function');
             expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component1.meta.json', JSON.stringify({
                 type: 'card',
-                uid: 'card-my-project',
+                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',
+                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');
+            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';
@@ -263,32 +312,36 @@ describe('lib/projects/components', () => {
             mockedFs.writeFileSync.mockImplementation(() => { });
             mockCoerceToValidUid.mockReturnValue('app-test-app');
             updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('test-app_app');
             expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/app.meta.json', JSON.stringify({
                 type: 'app',
-                uid: 'app-test-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');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app_test_app and name: test-app-Application');
         });
-        it('handles UID collisions by using timestamps', () => {
+        it('handles UID collisions by using differentiators', () => {
             const projectName = 'collision-project';
             const hsMetaFilePaths = ['/path/to/component1.meta.json'];
-            const existingUids = ['card-collision-project'];
+            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);
+            // First call for getBaseUid() check, second call when adding differentiator
             mockCoerceToValidUid
                 .mockReturnValueOnce('card-collision-project')
-                .mockReturnValueOnce('card-1234567890-collision-project');
+                .mockReturnValueOnce('card-collision-project');
             updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths, existingUids);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('collision-project_card');
+            // getBaseUid() is called twice - once for initial check, once when adding differentiator
+            expect(mockCoerceToValidUid).toHaveBeenCalledTimes(2);
+            // The differentiator is appended with a hyphen, so the final UID has a hyphen before the number
             expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component1.meta.json', JSON.stringify({
                 type: 'card',
-                uid: 'card-1234567890-collision-project',
+                uid: 'card_collision_project_2',
             }, null, 2));
         });
         it('falls back to original uid when coerceToValidUid returns null', () => {
@@ -328,11 +381,82 @@ describe('lib/projects/components', () => {
             mockedFs.writeFileSync.mockImplementation(() => { });
             mockCoerceToValidUid.mockReturnValue('app-no-config-project');
             updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('no-config-project_app');
             expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/app.meta.json', JSON.stringify({
                 type: 'app',
-                uid: 'app-no-config-project',
+                uid: 'app_no_config_project',
+            }, null, 2));
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app_no_config_project');
+        });
+        it('replaces hyphens with underscores in coerced UIDs', () => {
+            const projectName = 'my-project';
+            const hsMetaFilePaths = ['/path/to/component.meta.json'];
+            const component = {
+                type: 'card',
+                uid: 'old-uid',
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            // coerceToValidUid returns a value with hyphens that should be converted to underscores
+            mockCoerceToValidUid.mockReturnValue('my-project-card-with-hyphens');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-project_card');
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'my_project_card_with_hyphens',
+            }, null, 2));
+        });
+        it('handles UIDs with multiple hyphens correctly', () => {
+            const projectName = 'test-project';
+            const hsMetaFilePaths = ['/path/to/component.meta.json'];
+            const component = {
+                type: 'custom-object',
+                uid: 'old-uid',
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue('test-project-custom-object-type');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('test-project_custom-object');
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component.meta.json', JSON.stringify({
+                type: 'custom-object',
+                uid: 'test_project_custom_object_type',
+            }, null, 2));
+        });
+        it('preserves UIDs without hyphens unchanged', () => {
+            const projectName = 'simpleproject';
+            const hsMetaFilePaths = ['/path/to/component.meta.json'];
+            const component = {
+                type: 'card',
+                uid: 'old-uid',
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            // coerceToValidUid returns a value without hyphens
+            mockCoerceToValidUid.mockReturnValue('simpleprojectcard');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('simpleproject_card');
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'simpleprojectcard',
+            }, null, 2));
+        });
+        it('handles project names with hyphens in UID generation', () => {
+            const projectName = 'my-super-project';
+            const hsMetaFilePaths = ['/path/to/component.meta.json'];
+            const component = {
+                type: 'function',
+                uid: 'old-uid',
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue('my-super-project-function');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-super-project_function');
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component.meta.json', JSON.stringify({
+                type: 'function',
+                uid: 'my_super_project_function',
             }, null, 2));
-            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app-no-config-project');
         });
     });
 });

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

@@ -8,6 +8,7 @@ import { pollDeployStatus } from '../pollProjectBuildAndDeploy.js';
 // Mock external dependencies
 vi.mock('../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../pollProjectBuildAndDeploy.js');
 const mockUiLogger = vi.mocked(uiLogger);
 const mockDeployProject = vi.mocked(deployProject);

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

@@ -8,10 +8,14 @@ describe('platformVersion', () => {
             expect(isV2Project('2025.2')).toBe(true);
         });
         it('returns true if platform version is greater than the minimum', () => {
-            expect(isV2Project('2026.2')).toBe(true);
+            expect(isV2Project('2025.3')).toBe(true);
+            expect(isV2Project('2026.03')).toBe(true);
+            expect(isV2Project('2026.03-beta')).toBe(true);
         });
         it('returns false if platform version is less than the minimum', () => {
             expect(isV2Project('2025.0')).toBe(false);
+            expect(isV2Project('2025.01')).toBe(false);
+            expect(isV2Project('2025.01-beta')).toBe(false);
         });
         it('returns false if platform version is invalid', () => {
             expect(isV2Project(null)).toBe(false);