@hubspot/cli 7.10.0 → 7.10.1-experimental.0

package/lib/__tests__/usageTracking.test.js

@@ -1,5 +1,5 @@
 import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { isTrackingAllowed, getAccountConfig, } from '@hubspot/local-dev-lib/config';
+import { getConfig, getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
 import { uiLogger } from '../ui/logger.js';
 import { trackCommandUsage, trackHelpUsage, trackConvertFieldsUsage, trackAuthAction, trackCommandMetadataUsage, } from '../usageTracking.js';
@@ -9,14 +9,14 @@ vi.mock('@hubspot/local-dev-lib/trackUsage');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../ui/logger.js');
 const mockedTrackUsage = trackUsage;
-const mockedIsTrackingAllowed = isTrackingAllowed;
-const mockedGetAccountConfig = getAccountConfig;
+const mockedGetConfig = getConfig;
+const mockedGetConfigAccountById = getConfigAccountById;
 const mockedUiLogger = uiLogger;
 describe('lib/usageTracking', () => {
     const mockPlatform = 'darwin';
     const mockNodeVersion = 'v16.14.0';
     beforeEach(() => {
-        mockedIsTrackingAllowed.mockReturnValue(true);
+        mockedGetConfig.mockReturnValue({ allowUsageTracking: true });
         Object.defineProperty(process, 'platform', { value: mockPlatform });
         Object.defineProperty(process, 'version', { value: mockNodeVersion });
     });
@@ -24,7 +24,7 @@ describe('lib/usageTracking', () => {
         const mockCommand = 'test-command';
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackCommandUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -41,7 +41,7 @@ describe('lib/usageTracking', () => {
             }), mockAccountId);
         });
         it('should track command usage with custom auth type', async () => {
-            mockedGetAccountConfig.mockReturnValue({ authType: 'oauth2' });
+            mockedGetConfigAccountById.mockReturnValue({ authType: 'oauth2' });
             await trackCommandUsage(mockCommand, {}, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 authType: 'oauth2',
@@ -59,7 +59,7 @@ describe('lib/usageTracking', () => {
     describe('trackHelpUsage()', () => {
         const mockCommand = 'help-command';
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackHelpUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -82,7 +82,7 @@ describe('lib/usageTracking', () => {
     describe('trackConvertFieldsUsage()', () => {
         const mockCommand = 'convert-fields-command';
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackConvertFieldsUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -104,7 +104,7 @@ describe('lib/usageTracking', () => {
         const mockStep = 'init';
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
@@ -127,7 +127,7 @@ describe('lib/usageTracking', () => {
         const mockMeta = { assetType: 'test-asset' };
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
-            mockedIsTrackingAllowed.mockReturnValue(false);
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
             await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });

package/lib/__tests__/validation.test.js

@@ -1,4 +1,4 @@
-import { getAccountId, getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { getOauthManager } from '@hubspot/local-dev-lib/oauth';
 import { accessTokenForPersonalAccessKey } from '@hubspot/local-dev-lib/personalAccessKey';
 import { validateAccount } from '../validation.js';
@@ -14,47 +14,47 @@ const yargsOption = (option) => ({
     ...option,
 });
 describe('lib/validation', () => {
-    const getAccountIdMock = getAccountId;
-    const getAccountConfigMock = getAccountConfig;
+    const getConfigAccountIfExistsMock = getConfigAccountIfExists;
+    const getConfigAccountByIdMock = getConfigAccountById;
     const getOauthManagerMock = getOauthManager;
     const accessTokenForPersonalAccessKeyMock = accessTokenForPersonalAccessKey;
     describe('validateAccount', () => {
         it('returns false if an account is missing', async () => {
-            getAccountIdMock.mockReturnValueOnce(null);
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+            getConfigAccountIfExistsMock.mockReturnValueOnce(null);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
         });
         it('returns false if an account config is missing', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
-            getAccountConfigMock.mockReturnValueOnce(undefined);
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce(undefined);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
         });
         it('returns false for oauth2 authType if auth is missing', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'oauth2',
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
         });
         it('returns false if OAuth is missing configuration', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'oauth2',
                 auth: {
                     clientId: 'foo',
                 },
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
         });
         it('returns false if an access token was not retrieved', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
             getOauthManagerMock.mockReturnValueOnce({
                 accessToken() {
                     return null;
                 },
             });
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'oauth2',
                 auth: {
@@ -65,16 +65,16 @@ describe('lib/validation', () => {
                     },
                 },
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
         });
         it('returns false if an getting an access token throws', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
             getOauthManagerMock.mockReturnValueOnce({
                 accessToken() {
                     throw new Error('It failed');
                 },
             });
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'oauth2',
                 auth: {
@@ -85,16 +85,16 @@ describe('lib/validation', () => {
                     },
                 },
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
         });
         it('returns true if OAuth is configured and an access token is received', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
             getOauthManagerMock.mockReturnValueOnce({
                 accessToken() {
                     return 'yep';
                 },
             });
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'oauth2',
                 auth: {
@@ -105,40 +105,40 @@ describe('lib/validation', () => {
                     },
                 },
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
         });
         it('returns false if "personalaccesskey" configured and getting an access token throws', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
             accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
                 throw new Error('It failed');
             });
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'personalaccesskey',
                 personalAccessKey: 'foo',
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
         });
         it('returns true if "personalaccesskey" configured and an access token is received', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
             accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
                 return 'secret-stuff';
             });
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'personalaccesskey',
                 personalAccessKey: 'foo',
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
         });
         it('returns true if apiKey is configured and present', async () => {
-            getAccountIdMock.mockReturnValueOnce('123');
-            getAccountConfigMock.mockReturnValueOnce({
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce({
                 accountId: '123',
                 authType: 'apikey',
                 apiKey: 'my-secret-key',
             });
-            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
         });
     });
 });

package/lib/accountTypes.d.ts

@@ -1,9 +1,9 @@
-import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
-export declare function isStandardAccount(accountConfig: CLIAccount): boolean;
-export declare function isSandbox(accountConfig: CLIAccount): boolean;
-export declare function isStandardSandbox(accountConfig: CLIAccount): boolean;
-export declare function isDevelopmentSandbox(accountConfig: CLIAccount): boolean;
-export declare function isDeveloperTestAccount(accountConfig: CLIAccount): boolean;
-export declare function isAppDeveloperAccount(accountConfig: CLIAccount): boolean;
-export declare function isTestAccountOrSandbox(accountConfig: CLIAccount): boolean;
-export declare function isUnifiedAccount(account: CLIAccount): Promise<boolean>;
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function isStandardAccount(accountConfig: HubSpotConfigAccount): boolean;
+export declare function isSandbox(accountConfig: HubSpotConfigAccount): boolean;
+export declare function isStandardSandbox(accountConfig: HubSpotConfigAccount): boolean;
+export declare function isDevelopmentSandbox(accountConfig: HubSpotConfigAccount): boolean;
+export declare function isDeveloperTestAccount(accountConfig: HubSpotConfigAccount): boolean;
+export declare function isAppDeveloperAccount(accountConfig: HubSpotConfigAccount): boolean;
+export declare function isTestAccountOrSandbox(accountConfig: HubSpotConfigAccount): boolean;
+export declare function isUnifiedAccount(account: HubSpotConfigAccount): Promise<boolean>;

package/lib/accountTypes.js

@@ -1,6 +1,5 @@
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { hasUnfiedAppsAccess } from './hasFeature.js';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 function isAccountType(accountConfig, accountType) {
     return Boolean(accountConfig.accountType && accountType.includes(accountConfig.accountType));
 }
@@ -35,9 +34,8 @@ export function isTestAccountOrSandbox(accountConfig) {
     ]);
 }
 export async function isUnifiedAccount(account) {
-    const accountId = getAccountIdentifier(account);
-    if (!accountId) {
+    if (!account.accountId) {
         return false;
     }
-    return hasUnfiedAppsAccess(accountId);
+    return hasUnfiedAppsAccess(account.accountId);
 }

package/lib/app/__tests__/migrate.test.js

@@ -1,6 +1,7 @@
 import { uiLogger } from '../../ui/logger.js';
 import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
 import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { validateUid } from '@hubspot/project-parsing-lib';
 import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
 import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
@@ -26,6 +27,7 @@ vi.mock('../../ui/SpinniesManager');
 vi.mock('../../polling');
 vi.mock('../../../api/migrate');
 vi.mock('../../hasFeature');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../projects/urls');
 vi.mock('fs');
 const mockedUiLogger = uiLogger;
@@ -34,6 +36,7 @@ const mockedSanitizeFileName = sanitizeFileName;
 const mockedExtractZipArchive = extractZipArchive;
 const mockedValidateUid = validateUid;
 const mockedDownloadProject = downloadProject;
+const mockedGetConfigAccountById = getConfigAccountById;
 const mockedConfirmPrompt = confirmPrompt;
 const mockedInputPrompt = inputPrompt;
 const mockedListPrompt = listPrompt;
@@ -83,6 +86,18 @@ describe('lib/app/migrate', () => {
         mockedValidateUid.mockReturnValue(undefined);
         mockedHasUnfiedAppsAccess.mockResolvedValue(true);
         mockedFs.renameSync.mockImplementation(() => { });
+        // Mock account config for the test account ID
+        mockedGetConfigAccountById.mockReturnValue({
+            accountId: ACCOUNT_ID,
+            name: 'Test Account',
+            authType: 'personalaccesskey',
+            auth: {
+                tokenInfo: {
+                    accessToken: 'test-token',
+                },
+            },
+            env: 'prod',
+        });
     });
     describe('getUnmigratableReason', () => {
         const testCases = [

package/lib/app/__tests__/migrate_legacy.test.js

@@ -9,6 +9,7 @@ import { projectNameAndDestPrompt as _projectNameAndDestPrompt } from '../../pro
 import { ensureProjectExists as _ensureProjectExists } from '../../projects/ensureProjectExists.js';
 import { poll as _poll } from '../../polling.js';
 import { migrateApp2023_2 } from '../migrate_legacy.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 // Mock all external dependencies
 vi.mock('@hubspot/local-dev-lib/api/appsDev');
 vi.mock('../../ui/logger.js');
@@ -26,6 +27,7 @@ vi.mock('../../usageTracking');
 vi.mock('../../ui/SpinniesManager');
 vi.mock('../../process');
 vi.mock('../../polling');
+vi.mock('@hubspot/local-dev-lib/config');
 const isAppDeveloperAccount = _isAppDeveloperAccount;
 const isUnifiedAccount = _isUnifiedAccount;
 const selectPublicAppForMigrationPrompt = _selectPublicAppForMigrationPrompt;
@@ -57,6 +59,13 @@ describe('migrateApp2023_2', () => {
     beforeEach(() => {
         // @ts-expect-error function mismatch
         vi.spyOn(process, 'exit').mockImplementation(() => { });
+        getConfigAccountById.mockReturnValue({
+            accountId: mockDerivedAccountId,
+            name: 'Test Account',
+            authType: 'personalaccesskey',
+            personalAccessKey: 'test-key',
+            env: 'prod',
+        });
         selectPublicAppForMigrationPrompt.mockResolvedValue({
             appId,
         });

package/lib/app/migrate_legacy.d.ts

@@ -1,4 +1,4 @@
-import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { ArgumentsCamelCase } from 'yargs';
 import { MigrateAppArgs } from './migrate.js';
-export declare function migrateApp2023_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateAppArgs>, accountConfig: CLIAccount): Promise<void>;
+export declare function migrateApp2023_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateAppArgs>, accountConfig: HubSpotConfigAccount): Promise<void>;

package/lib/buildAccount.d.ts

@@ -1,6 +1,6 @@
 import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
-import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { SandboxResponse, V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
 import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare function saveAccountToConfig(accountId: number | undefined, accountName: string, env: Environment, personalAccessKey?: string, force?: boolean): Promise<string>;
@@ -9,12 +9,12 @@ export declare function createDeveloperTestAccountV2(parentAccountId: number, te
     accountId?: number;
     personalAccessKey?: string;
 }>;
-export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: CLIAccount, env: Environment, portalLimit: number, useV2?: boolean): Promise<number>;
+export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: HubSpotConfigAccount, env: Environment, portalLimit: number, useV2?: boolean): Promise<number>;
 type SandboxAccount = SandboxResponse & {
     name: string;
 };
-export declare function buildSandbox(sandboxName: string, parentAccountConfig: CLIAccount, sandboxType: SandboxAccountType, env: Environment, force?: boolean): Promise<SandboxAccount>;
-export declare function buildV2Sandbox(sandboxName: string, parentAccountConfig: CLIAccount, sandboxType: SandboxAccountType, syncObjectRecords: boolean, env: Environment, force?: boolean): Promise<{
+export declare function buildSandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, env: Environment, force?: boolean): Promise<SandboxAccount>;
+export declare function buildV2Sandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, syncObjectRecords: boolean, env: Environment, force?: boolean): Promise<{
     sandbox: V2Sandbox;
 }>;
 export {};

package/lib/buildAccount.js

@@ -1,6 +1,5 @@
 import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
-import { accountNameExistsInConfig, updateAccountConfig, writeConfig, getAccountId, } from '@hubspot/local-dev-lib/config';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { getConfigAccountIfExists, updateConfigAccount, } from '@hubspot/local-dev-lib/config';
 import { uiLogger } from './ui/logger.js';
 import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
@@ -28,8 +27,8 @@ export async function saveAccountToConfig(accountId, accountName, env, personalA
     if (!updatedConfig?.name) {
         const nameForConfig = accountName.toLowerCase().split(' ').join('-');
         validName = nameForConfig;
-        const invalidAccountName = accountNameExistsInConfig(nameForConfig);
-        if (invalidAccountName) {
+        const existingAccount = getConfigAccountIfExists(nameForConfig);
+        if (existingAccount) {
             if (!force) {
                 uiLogger.log('');
                 uiLogger.warn(lib.prompts.accountNamePrompt.errors.accountNameExists(nameForConfig));
@@ -42,13 +41,10 @@ export async function saveAccountToConfig(accountId, accountName, env, personalA
             }
         }
     }
-    updateAccountConfig({
+    updateConfigAccount({
         ...updatedConfig,
-        env: updatedConfig?.env,
-        tokenInfo: updatedConfig?.auth?.tokenInfo,
         name: validName,
     });
-    writeConfig();
     uiLogger.log('');
     return validName;
 }
@@ -83,8 +79,7 @@ export async function createDeveloperTestAccountV2(parentAccountId, testAccountC
     return result;
 }
 export async function buildDeveloperTestAccount(testAccountName, parentAccountConfig, env, portalLimit, useV2 = false) {
-    const id = getAccountIdentifier(parentAccountConfig);
-    const parentAccountId = getAccountId(id);
+    const parentAccountId = parentAccountConfig.accountId;
     let testAccountConfig = {
         accountName: testAccountName,
     };
@@ -141,8 +136,7 @@ export async function buildSandbox(sandboxName, parentAccountConfig, sandboxType
     const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
         ? 'standard'
         : 'developer';
-    const id = getAccountIdentifier(parentAccountConfig);
-    const parentAccountId = getAccountId(id);
+    const parentAccountId = parentAccountConfig.accountId;
     if (!parentAccountId) {
         throw new Error(lib.sandbox.create[sandboxTypeKey].loading.fail(''));
     }
@@ -182,8 +176,7 @@ export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxTy
     const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
         ? 'standard'
         : 'developer';
-    const id = getAccountIdentifier(parentAccountConfig);
-    const parentAccountId = getAccountId(id);
+    const parentAccountId = parentAccountConfig.accountId;
     if (!parentAccountId) {
         throw new Error(lib.sandbox.create[sandboxTypeKey].loading.fail(''));
     }

package/lib/commonOpts.js

@@ -3,7 +3,7 @@ import yargsParser from 'yargs-parser';
 import { LOG_LEVEL, setLogLevel } from '@hubspot/local-dev-lib/logger';
 import { uiLogger } from './ui/logger.js';
 import { DEFAULT_CMS_PUBLISH_MODE, CMS_PUBLISH_MODE, } from '@hubspot/local-dev-lib/constants/files';
-import { getAccountConfig, getAndLoadConfigIfNeeded, } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, getConfig } from '@hubspot/local-dev-lib/config';
 import { debugError } from './errorHandlers/index.js';
 import { EXIT_CODES } from './enums/exitCodes.js';
 import { uiCommandReference } from './ui/index.js';
@@ -168,14 +168,14 @@ export function getCmsPublishMode(options) {
     }
     // 2. config[account].defaultCmsPublishMode
     if (options.derivedAccountId) {
-        const accountConfig = getAccountConfig(options.derivedAccountId);
+        const accountConfig = getConfigAccountById(options.derivedAccountId);
         if (accountConfig && accountConfig.defaultCmsPublishMode) {
             return accountConfig.defaultCmsPublishMode;
         }
     }
     // 3. config.defaultCmsPublishMode
     // 4. DEFAULT_CMS_PUBLISH_MODE
-    const config = getAndLoadConfigIfNeeded();
+    const config = getConfig();
     return ((config && config.defaultCmsPublishMode) ||
         DEFAULT_CMS_PUBLISH_MODE);
 }

package/lib/configMigrate.d.ts

@@ -1,2 +1,2 @@
-export declare function handleMigration(deprecatedConfigPath?: string, hideWarning?: boolean): Promise<boolean>;
-export declare function handleMerge(deprecatedConfigPath?: string, force?: boolean, hideWarning?: boolean): Promise<boolean>;
+export declare function handleMigration(hideWarning?: boolean): Promise<boolean>;
+export declare function handleMerge(force?: boolean, hideWarning?: boolean): Promise<boolean>;

package/lib/configMigrate.js

@@ -1,8 +1,10 @@
-import { getDeprecatedConfig, getGlobalConfig, getConfigPath, migrateConfig, mergeConfigProperties, mergeExistingConfigs, } from '@hubspot/local-dev-lib/config/migrate';
+import { getConfigAtPath, migrateConfigAtPath, mergeConfigProperties, mergeConfigAccounts, archiveConfigAtPath, } from '@hubspot/local-dev-lib/config/migrate';
 import { ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME } from '@hubspot/local-dev-lib/constants/config';
 import { promptUser } from './prompts/promptUtils.js';
 import { lib } from '../lang/en.js';
 import { uiLogger } from './ui/logger.js';
+import { getConfig, getLocalConfigFilePathIfExists, } from '@hubspot/local-dev-lib/config';
+import { debugError } from './errorHandlers/index.js';
 async function promptRenameOrOmitAccount(accountName, accountId) {
     const { shouldRename } = await promptUser({
         name: 'shouldRename',
@@ -24,7 +26,7 @@ async function promptNewAccountName(account, globalConfig, renamedAccounts) {
             if (value === account.name) {
                 return lib.configMigrate.handleAccountNameConflicts.errors.sameName;
             }
-            const existingAccount = globalConfig.accounts?.some(acc => acc.name === value);
+            const existingAccount = globalConfig.accounts.some((acc) => acc.name === value);
             const renamedAccount = renamedAccounts.some(acc => acc.name === value);
             if (existingAccount || renamedAccount) {
                 return lib.configMigrate.handleAccountNameConflicts.errors.nameAlreadyInConfig(value);
@@ -34,9 +36,10 @@ async function promptNewAccountName(account, globalConfig, renamedAccounts) {
     });
     return newAccountName;
 }
-export async function handleMigration(deprecatedConfigPath, hideWarning) {
+export async function handleMigration(hideWarning) {
+    const deprecatedConfigPath = process.env.HUBSPOT_CONFIG_PATH || getLocalConfigFilePathIfExists();
     if (!hideWarning) {
-        uiLogger.warn(lib.configMigrate.deprecatedConfigWarning(deprecatedConfigPath || getConfigPath(undefined, false)));
+        uiLogger.warn(lib.configMigrate.deprecatedConfigWarning(deprecatedConfigPath || ''));
         uiLogger.log('');
     }
     uiLogger.log(lib.configMigrate.handleMigration.description(ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME));
@@ -49,13 +52,20 @@ export async function handleMigration(deprecatedConfigPath, hideWarning) {
     if (!shouldMigrateConfig) {
         return false;
     }
-    const deprecatedConfig = getDeprecatedConfig(deprecatedConfigPath);
-    migrateConfig(deprecatedConfig);
+    migrateConfigAtPath(deprecatedConfigPath || '');
+    try {
+        archiveConfigAtPath(deprecatedConfigPath);
+    }
+    catch (error) {
+        debugError(error);
+        uiLogger.error(lib.configMigrate.errors.archive(deprecatedConfigPath));
+        return true;
+    }
     uiLogger.success(lib.configMigrate.handleMigration.success);
     return true;
 }
 async function handleMergeConfigProperties(globalConfig, deprecatedConfig, force) {
-    const { initialConfig, conflicts, } = mergeConfigProperties(globalConfig, deprecatedConfig, force);
+    const { configWithMergedProperties, conflicts, } = mergeConfigProperties(globalConfig, deprecatedConfig, force);
     if (conflicts.length > 0) {
         const properties = conflicts.map(c => c.property);
         const propertyList = properties.length <= 2
@@ -68,15 +78,15 @@ async function handleMergeConfigProperties(globalConfig, deprecatedConfig, force
             const { shouldOverwrite } = await promptUser({
                 name: 'shouldOverwrite',
                 type: 'confirm',
-                message: lib.configMigrate.handleMergeConfigProperties.mergeConfigConflictPrompt(property, newValue.toString(), oldValue.toString()),
+                message: lib.configMigrate.handleMergeConfigProperties.mergeConfigConflictPrompt(property, newValue.toString(), oldValue?.toString() || ''),
             });
             if (shouldOverwrite) {
                 // @ts-expect-error Cannot reconcile CLIConfig_NEW and CLIConfig_DEPRECATED
-                initialConfig[property] = oldValue;
+                configWithMergedProperties[property] = oldValue;
             }
         }
     }
-    return initialConfig;
+    return configWithMergedProperties;
 }
 async function handleAccountNameConflicts(globalConfig, deprecatedConfig, force) {
     if (!deprecatedConfig.portals?.length || !globalConfig.accounts?.length) {
@@ -84,7 +94,7 @@ async function handleAccountNameConflicts(globalConfig, deprecatedConfig, force)
     }
     const accountsWithConflictsToRemove = new Set();
     const renamedAccounts = [];
-    const accountsNotYetInGlobal = deprecatedConfig.portals.filter(portal => portal.portalId &&
+    const accountsNotYetInGlobal = (deprecatedConfig.portals || []).filter(portal => portal.portalId &&
         !globalConfig.accounts?.some(acc => acc.accountId === portal.portalId));
     const accountsWithConflicts = accountsNotYetInGlobal.filter(localAccount => globalConfig.accounts?.some(globalAccount => globalAccount.name === localAccount.name));
     if (accountsWithConflicts.length > 0) {
@@ -120,12 +130,13 @@ async function handleAccountNameConflicts(globalConfig, deprecatedConfig, force)
         }
         deprecatedConfig.portals.push(...renamedAccounts);
     }
-    const cleanedPortals = deprecatedConfig.portals.filter(portal => !accountsWithConflictsToRemove.has(portal));
+    const cleanedPortals = (deprecatedConfig.portals || []).filter(portal => !accountsWithConflictsToRemove.has(portal));
     return { ...deprecatedConfig, portals: cleanedPortals };
 }
-export async function handleMerge(deprecatedConfigPath, force, hideWarning) {
+export async function handleMerge(force, hideWarning) {
+    const deprecatedConfigPath = process.env.HUBSPOT_CONFIG_PATH || getLocalConfigFilePathIfExists();
     if (!hideWarning) {
-        uiLogger.warn(lib.configMigrate.deprecatedConfigWarning(deprecatedConfigPath || getConfigPath(undefined, false)));
+        uiLogger.warn(lib.configMigrate.deprecatedConfigWarning(deprecatedConfigPath || ''));
         uiLogger.log('');
     }
     uiLogger.log(lib.configMigrate.handleMerge.description(ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME));
@@ -140,19 +151,32 @@ export async function handleMerge(deprecatedConfigPath, force, hideWarning) {
             return true; // exit with "true" so the user is shown a success message instead of an error
         }
     }
-    const deprecatedConfig = getDeprecatedConfig(deprecatedConfigPath);
-    const globalConfig = getGlobalConfig();
-    if (!deprecatedConfig || !globalConfig) {
+    let deprecatedConfig;
+    let globalConfig;
+    try {
+        deprecatedConfig = getConfigAtPath(deprecatedConfigPath || '');
+        globalConfig = getConfig();
+    }
+    catch (error) {
+        debugError(error);
         return true;
     }
     const mergedConfig = await handleMergeConfigProperties(globalConfig, deprecatedConfig, force);
     const cleanedDeprecatedConfig = await handleAccountNameConflicts(mergedConfig, deprecatedConfig, force);
-    const { skippedAccountIds } = mergeExistingConfigs(mergedConfig, cleanedDeprecatedConfig);
+    const { skippedAccountIds } = mergeConfigAccounts(mergedConfig, cleanedDeprecatedConfig);
     if (skippedAccountIds.length > 0) {
         uiLogger.log('');
         uiLogger.log(lib.configMigrate.handleMerge.skippedExistingAccounts(skippedAccountIds));
         uiLogger.log('');
     }
+    try {
+        archiveConfigAtPath(deprecatedConfigPath);
+    }
+    catch (error) {
+        debugError(error);
+        uiLogger.error(lib.configMigrate.errors.archive(deprecatedConfigPath));
+        return true;
+    }
     uiLogger.success(lib.configMigrate.handleMerge.success);
     return true;
 }

package/lib/configOptions.js

@@ -1,4 +1,4 @@
-import { updateAllowUsageTracking, updateAllowAutoUpdates, updateDefaultCmsPublishMode, updateHttpTimeout, isConfigFlagEnabled, updateAutoOpenBrowser, } from '@hubspot/local-dev-lib/config';
+import { updateAllowUsageTracking, updateAllowAutoUpdates, updateDefaultCmsPublishMode, updateHttpTimeout, updateAutoOpenBrowser, getConfig, } from '@hubspot/local-dev-lib/config';
 import { CMS_PUBLISH_MODE } from '@hubspot/local-dev-lib/constants/files';
 import { commaSeparatedValues } from '@hubspot/local-dev-lib/text';
 import { trackCommandUsage } from './usageTracking.js';
@@ -110,5 +110,6 @@ export async function setAutoOpenBrowser({ accountId, autoOpenBrowser, }) {
         : lib.configOptions.setAutoOpenBrowser.disabled);
 }
 export function isAutoOpenBrowserEnabled() {
-    return isConfigFlagEnabled('autoOpenBrowser', true);
+    const config = getConfig();
+    return config?.autoOpenBrowser !== false; // Default to true
 }