@hubspot/cli 7.11.8-experimental.0 → 8.0.0-beta.1

package/commands/account/__tests__/auth.test.js

@@ -1,9 +1,79 @@
 import yargs from 'yargs';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as personalAccessKeyLib from '@hubspot/local-dev-lib/personalAccessKey';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { addGlobalOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
+import * as configMigrate from '../../../lib/configMigrate.js';
+import * as processLib from '../../../lib/process.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import * as personalAccessKeyPromptLib from '../../../lib/prompts/personalAccessKeyPrompt.js';
+import * as accountNamePromptLib from '../../../lib/prompts/accountNamePrompt.js';
+import * as setAsDefaultPromptLib from '../../../lib/prompts/setAsDefaultAccountPrompt.js';
+import * as parsingLib from '../../../lib/parsing.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
 import accountAuthCommand from '../auth.js';
 vi.mock('../../../lib/commonOpts');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('../../../lib/configMigrate.js');
+vi.mock('../../../lib/process.js');
+vi.mock('../../../lib/prompts/personalAccessKeyPrompt.js');
+vi.mock('../../../lib/prompts/accountNamePrompt.js');
+vi.mock('../../../lib/prompts/setAsDefaultAccountPrompt.js');
+vi.mock('../../../lib/parsing.js');
+vi.mock('../../../lib/ui/index.js');
+vi.mock('../../../lib/errorHandlers/index.js');
+const localConfigFileExistsSpy = vi.spyOn(configLib, 'localConfigFileExists');
+const globalConfigFileExistsSpy = vi.spyOn(configLib, 'globalConfigFileExists');
+const createEmptyConfigFileSpy = vi.spyOn(configLib, 'createEmptyConfigFile');
+const getAccessTokenSpy = vi.spyOn(personalAccessKeyLib, 'getAccessToken');
+const updateConfigWithAccessTokenSpy = vi.spyOn(personalAccessKeyLib, 'updateConfigWithAccessToken');
+const handleMergeSpy = vi.spyOn(configMigrate, 'handleMerge');
+const handleMigrationSpy = vi.spyOn(configMigrate, 'handleMigration');
+const handleExitSpy = vi.spyOn(processLib, 'handleExit');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const trackAuthActionSpy = vi.spyOn(usageTrackingLib, 'trackAuthAction');
+const personalAccessKeyPromptSpy = vi.spyOn(personalAccessKeyPromptLib, 'personalAccessKeyPrompt');
+const cliAccountNamePromptSpy = vi.spyOn(accountNamePromptLib, 'cliAccountNamePrompt');
+const setAsDefaultAccountPromptSpy = vi.spyOn(setAsDefaultPromptLib, 'setAsDefaultAccountPrompt');
+const parseStringToNumberSpy = vi.spyOn(parsingLib, 'parseStringToNumber');
+const processExitSpy = vi.spyOn(process, 'exit');
 describe('commands/account/auth', () => {
     const yargsMock = yargs;
+    beforeEach(() => {
+        // @ts-expect-error Mock implementation
+        processExitSpy.mockImplementation(() => { });
+        localConfigFileExistsSpy.mockReturnValue(false);
+        globalConfigFileExistsSpy.mockReturnValue(true);
+        createEmptyConfigFileSpy.mockImplementation(() => { });
+        handleExitSpy.mockImplementation(async () => { });
+        trackCommandUsageSpy.mockImplementation(async () => { });
+        trackAuthActionSpy.mockResolvedValue(undefined);
+        personalAccessKeyPromptSpy.mockResolvedValue({
+            personalAccessKey: 'test-key',
+            env: 'prod',
+        });
+        getAccessTokenSpy.mockResolvedValue({
+            portalId: 456789,
+            accessToken: 'test-access-token',
+            expiresAt: '2025-01-01T00:00:00.000Z',
+            scopeGroups: ['content'],
+            encodedOAuthRefreshToken: 'encoded-token',
+            hubName: 'Test Hub',
+            accountType: 'STANDARD',
+        });
+        cliAccountNamePromptSpy.mockResolvedValue({ name: 'test-account' });
+        updateConfigWithAccessTokenSpy.mockResolvedValue({
+            accountId: 456789,
+            name: 'test-account',
+            authType: 'personalaccesskey',
+            env: 'prod',
+            auth: { tokenInfo: { accessToken: 'test-token' } },
+            personalAccessKey: 'test-key',
+        });
+        setAsDefaultAccountPromptSpy.mockResolvedValue(true);
+    });
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(accountAuthCommand.command).toEqual('auth');
@@ -23,4 +93,114 @@ describe('commands/account/auth', () => {
             expect(addGlobalOptions).toHaveBeenCalledWith(yargsMock);
         });
     });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 0,
+                d: false,
+                debug: false,
+                _: [],
+                $0: '',
+            };
+        });
+        it('should track command usage', async () => {
+            await accountAuthCommand.handler(args);
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('account-auth', {}, undefined);
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'started');
+        });
+        it('should not track when tracking is disabled', async () => {
+            args.disableTracking = true;
+            await accountAuthCommand.handler(args);
+            expect(trackCommandUsageSpy).not.toHaveBeenCalled();
+            expect(trackAuthActionSpy).not.toHaveBeenCalled();
+            expect(updateConfigWithAccessTokenSpy).toHaveBeenCalled();
+        });
+        it('should parse user provided account ID', async () => {
+            args.userProvidedAccount = '123456';
+            parseStringToNumberSpy.mockReturnValue(123456);
+            await accountAuthCommand.handler(args);
+            expect(parseStringToNumberSpy).toHaveBeenCalledWith('123456');
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('account-auth', {}, 123456);
+        });
+        it('should error on invalid account ID', async () => {
+            args.userProvidedAccount = 'invalid';
+            parseStringToNumberSpy.mockImplementation(() => {
+                throw new Error('Invalid');
+            });
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledWith('--account must be a number.');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should handle merge when both configs exist', async () => {
+            localConfigFileExistsSpy.mockReturnValue(true);
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            handleMergeSpy.mockResolvedValue(true);
+            await accountAuthCommand.handler(args);
+            expect(handleMergeSpy).toHaveBeenCalled();
+        });
+        it('should exit if merge is not confirmed', async () => {
+            localConfigFileExistsSpy.mockReturnValue(true);
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            handleMergeSpy.mockResolvedValue(false);
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.log).toHaveBeenCalled();
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'error');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should handle migration when only local config exists', async () => {
+            localConfigFileExistsSpy.mockReturnValue(true);
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            handleMigrationSpy.mockResolvedValue(true);
+            await accountAuthCommand.handler(args);
+            expect(handleMigrationSpy).toHaveBeenCalled();
+        });
+        it('should create config file if it does not exist', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            await accountAuthCommand.handler(args);
+            expect(createEmptyConfigFileSpy).toHaveBeenCalledWith(true);
+        });
+        it('should prompt for personal access key', async () => {
+            await accountAuthCommand.handler(args);
+            expect(personalAccessKeyPromptSpy).toHaveBeenCalledWith({
+                env: ENVIRONMENTS.PROD,
+                account: undefined,
+            });
+        });
+        it('should use provided personal access key', async () => {
+            args.personalAccessKey = 'provided-key';
+            await accountAuthCommand.handler(args);
+            expect(personalAccessKeyPromptSpy).not.toHaveBeenCalled();
+            expect(getAccessTokenSpy).toHaveBeenCalledWith('provided-key', ENVIRONMENTS.PROD);
+        });
+        it('should use QA environment when qa flag is set', async () => {
+            args.qa = true;
+            await accountAuthCommand.handler(args);
+            expect(getAccessTokenSpy).toHaveBeenCalledWith('test-key', ENVIRONMENTS.QA);
+        });
+        it('should prompt for account name for new config', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            await accountAuthCommand.handler(args);
+            expect(cliAccountNamePromptSpy).toHaveBeenCalledWith('test-hub');
+        });
+        it('should not prompt for account name for existing config', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            await accountAuthCommand.handler(args);
+            expect(setAsDefaultAccountPromptSpy).toHaveBeenCalledWith('test-account');
+        });
+        it('should exit with error if config update fails', async () => {
+            getAccessTokenSpy.mockRejectedValue(new Error('Invalid key'));
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed'));
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'error');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should log success for new config', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.success).toHaveBeenCalled();
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'complete', 456789);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+    });
 });

package/commands/account/__tests__/list.test.js

@@ -1,12 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import yargs from 'yargs';
-import { addConfigOptions } from '../../../lib/commonOpts.js';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as defaultAccountOverrideLib from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import * as commonOpts from '../../../lib/commonOpts.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
 import accountListCommand from '../list.js';
 vi.mock('../../../lib/commonOpts');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/config/defaultAccountOverride');
+vi.mock('../../../lib/ui/index.js');
+vi.mock('../../../lib/ui/table.js');
+const getConfigFilePathSpy = vi.spyOn(configLib, 'getConfigFilePath');
+const getAllConfigAccountsSpy = vi.spyOn(configLib, 'getAllConfigAccounts');
+const getConfigDefaultAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigDefaultAccountIfExists');
+const getDefaultAccountOverrideFilePathSpy = vi.spyOn(defaultAccountOverrideLib, 'getDefaultAccountOverrideFilePath');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
 const exampleSpy = vi
     .spyOn(yargs, 'example')
     .mockReturnValue(yargs);
 describe('commands/account/list', () => {
     const yargsMock = yargs;
+    beforeEach(() => {
+        getConfigFilePathSpy.mockReturnValue('/test/.hscli.config.yaml');
+        getAllConfigAccountsSpy.mockReturnValue([]);
+        getConfigDefaultAccountIfExistsSpy.mockReturnValue(undefined);
+        getDefaultAccountOverrideFilePathSpy.mockReturnValue(null);
+        trackCommandUsageSpy.mockImplementation(async () => { });
+    });
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(accountListCommand.command).toEqual(['list', 'ls']);
@@ -21,8 +43,111 @@ describe('commands/account/list', () => {
         it('should support the correct options', () => {
             accountListCommand.builder(yargsMock);
             expect(exampleSpy).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 123456,
+                d: false,
+                debug: false,
+                _: [],
+                $0: '',
+            };
+        });
+        it('should track command usage', async () => {
+            await accountListCommand.handler(args);
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('accounts-list', undefined, 123456);
+        });
+        it('should display accounts list when no default account', async () => {
+            const accounts = [
+                {
+                    accountId: 111111,
+                    name: 'Test Account 1',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                },
+                {
+                    accountId: 222222,
+                    name: 'Test Account 2',
+                    authType: 'oauth2',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                },
+            ];
+            getAllConfigAccountsSpy.mockReturnValue(accounts);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('Accounts'));
+        });
+        it('should display default account when present', async () => {
+            getConfigDefaultAccountIfExistsSpy.mockReturnValue({
+                accountId: 123456,
+                name: 'Default Account',
+            });
+            await accountListCommand.handler(args);
+            expect(getConfigDefaultAccountIfExistsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should display config file path when default account present', async () => {
+            getConfigDefaultAccountIfExistsSpy.mockReturnValue({
+                accountId: 123456,
+            });
+            await accountListCommand.handler(args);
+            expect(getConfigFilePathSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should display override file path when present', async () => {
+            getConfigDefaultAccountIfExistsSpy.mockReturnValue({
+                accountId: 123456,
+            });
+            getDefaultAccountOverrideFilePathSpy.mockReturnValue('/test/override.yaml');
+            await accountListCommand.handler(args);
+            expect(getDefaultAccountOverrideFilePathSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should group sandbox accounts under parent', async () => {
+            const accounts = [
+                {
+                    accountId: 111111,
+                    name: 'Parent Account',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                },
+                {
+                    accountId: 222222,
+                    name: 'Sandbox Account',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+                    parentAccountId: 111111,
+                },
+            ];
+            getAllConfigAccountsSpy.mockReturnValue(accounts);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should display app developer accounts', async () => {
+            const accounts = [
+                {
+                    accountId: 333333,
+                    name: 'App Developer Account',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+                },
+            ];
+            getAllConfigAccountsSpy.mockReturnValue(accounts);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should handle empty accounts list', async () => {
+            getAllConfigAccountsSpy.mockReturnValue([]);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
         });
     });
 });

package/commands/account/__tests__/rename.test.js

@@ -8,7 +8,6 @@ import * as usageTracking from '../../../lib/usageTracking.js';
 vi.mock('../../../lib/commonOpts');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../lib/errorHandlers/index.js');
-vi.mock('../../../lib/usageTracking.js');
 const positionalSpy = vi
     .spyOn(yargs, 'positional')
     .mockReturnValue(yargs);
@@ -33,7 +32,6 @@ describe('commands/account/rename', () => {
     describe('handler', () => {
         let args;
         beforeEach(() => {
-            vi.clearAllMocks();
             renameAccountSpy.mockReturnValue(undefined);
             processExitSpy.mockImplementation(() => {
                 throw new Error('process.exit called');

package/commands/account/__tests__/use.test.js

@@ -1,5 +1,25 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import yargs from 'yargs';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as defaultAccountOverrideLib from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/config/defaultAccountOverride');
+vi.mock('../../../lib/prompts/accountsPrompt.js');
+// Import after mocks
+import * as accountsPromptLib from '../../../lib/prompts/accountsPrompt.js';
 import accountUseCommand from '../use.js';
+const getConfigFilePathSpy = vi.spyOn(configLib, 'getConfigFilePath');
+const getConfigAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigAccountIfExists');
+const getConfigAccountByNameSpy = vi.spyOn(configLib, 'getConfigAccountByName');
+const getConfigAccountByIdSpy = vi.spyOn(configLib, 'getConfigAccountById');
+const getAllConfigAccountsSpy = vi.spyOn(configLib, 'getAllConfigAccounts');
+const setConfigAccountAsDefaultSpy = vi.spyOn(configLib, 'setConfigAccountAsDefault');
+const getDefaultAccountOverrideAccountIdSpy = vi.spyOn(defaultAccountOverrideLib, 'getDefaultAccountOverrideAccountId');
+const getDefaultAccountOverrideFilePathSpy = vi.spyOn(defaultAccountOverrideLib, 'getDefaultAccountOverrideFilePath');
+const selectAccountFromConfigSpy = vi.spyOn(accountsPromptLib, 'selectAccountFromConfig');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
 const positionalSpy = vi
     .spyOn(yargs, 'positional')
     .mockReturnValue(yargs);
@@ -8,6 +28,14 @@ const exampleSpy = vi
     .mockReturnValue(yargs);
 describe('commands/account/use', () => {
     const yargsMock = yargs;
+    beforeEach(() => {
+        getConfigFilePathSpy.mockReturnValue('/test/.hscli.config.yaml');
+        getAllConfigAccountsSpy.mockReturnValue([]);
+        getDefaultAccountOverrideAccountIdSpy.mockReturnValue(null);
+        getDefaultAccountOverrideFilePathSpy.mockReturnValue(null);
+        trackCommandUsageSpy.mockImplementation(async () => { });
+        setConfigAccountAsDefaultSpy.mockImplementation(() => { });
+    });
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(accountUseCommand.command).toEqual('use [account]');
@@ -29,4 +57,114 @@ describe('commands/account/use', () => {
             });
         });
     });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 0,
+                d: false,
+                debug: false,
+                _: [],
+                $0: '',
+            };
+        });
+        describe('with account ID', () => {
+            it('should set account by ID', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(getConfigAccountByIdSpy).toHaveBeenCalledWith(123456);
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('123456');
+                expect(uiLogger.success).toHaveBeenCalled();
+            });
+            it('should track command usage', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('accounts-use', undefined, 123456);
+            });
+        });
+        describe('with account name', () => {
+            it('should set account by name', async () => {
+                args.account = 'MyAccount';
+                const account = {
+                    accountId: 123456,
+                    name: 'MyAccount',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByNameSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(getConfigAccountByNameSpy).toHaveBeenCalledWith('MyAccount');
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('MyAccount');
+                expect(uiLogger.success).toHaveBeenCalled();
+            });
+        });
+        describe('account not found', () => {
+            it('should prompt when account not found', async () => {
+                args.account = 'InvalidAccount';
+                const account = {
+                    accountId: 999999,
+                    name: 'Selected Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(undefined);
+                selectAccountFromConfigSpy.mockResolvedValue(999999);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalled();
+                expect(selectAccountFromConfigSpy).toHaveBeenCalled();
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('999999');
+            });
+        });
+        describe('without account argument', () => {
+            it('should prompt for account selection', async () => {
+                const account = {
+                    accountId: 888888,
+                    name: 'Prompted Account',
+                };
+                selectAccountFromConfigSpy.mockResolvedValue(888888);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(selectAccountFromConfigSpy).toHaveBeenCalled();
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('888888');
+            });
+        });
+        describe('account override', () => {
+            it('should warn when account override is present', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                getDefaultAccountOverrideAccountIdSpy.mockReturnValue(777777);
+                getDefaultAccountOverrideFilePathSpy.mockReturnValue('/test/override.yaml');
+                getAllConfigAccountsSpy.mockReturnValue([account]);
+                await accountUseCommand.handler(args);
+                expect(getDefaultAccountOverrideAccountIdSpy).toHaveBeenCalled();
+                expect(uiLogger.warn).toHaveBeenCalled();
+            });
+            it('should not warn when no account override', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(uiLogger.warn).not.toHaveBeenCalled();
+            });
+        });
+    });
 });

package/commands/account/auth.js

@@ -125,7 +125,7 @@ async function handler(args) {
             await trackAuthAction('account-auth', authType, TRACKING_STATUS.ERROR);
         }
         uiLogger.error(commands.account.subcommands.auth.errors.failedToUpdateConfig);
-        process.exit(EXIT_CODES.ERROR);
+        return process.exit(EXIT_CODES.ERROR);
     }
     const { accountId, name } = updatedConfig;
     if (!configAlreadyExists) {

package/commands/account/clean.js

@@ -7,13 +7,13 @@ import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import { selectAccountFromConfig } from '../../lib/prompts/accountsPrompt.js';
-import { getTableContents } from '../../lib/ui/table.js';
 import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 import { uiAccountDescription } from '../../lib/ui/index.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
+import { renderList } from '../../ui/render.js';
 const command = 'clean';
 const describe = commands.account.subcommands.clean.describe;
 async function handler(args) {
@@ -58,11 +58,12 @@ async function handler(args) {
                 ? commands.account.subcommands.clean.inactiveAccountsFound.one
                 : commands.account.subcommands.clean.inactiveAccountsFound.other(accountsToRemove.length),
         });
-        uiLogger.log(getTableContents(accountsToRemove.map(p => [uiAccountDescription(p.accountId)]), { border: { bodyLeft: '  ' } }));
+        renderList(accountsToRemove.map(p => [uiAccountDescription(p.accountId)]));
+        uiLogger.log('');
         let promptMessage = oneAccountFound
             ? commands.account.subcommands.clean.confirm.one
             : commands.account.subcommands.clean.confirm.other(accountsToRemove.length);
-        const accountOverride = getDefaultAccountOverrideAccountId();
+        const accountOverride = getDefaultAccountOverrideAccountId(accountsList);
         const overrideFilePath = getDefaultAccountOverrideFilePath();
         const accountOverrideMatches = accountsToRemove.some(account => account.accountId === accountOverride);
         if (overrideFilePath && accountOverride && accountOverrideMatches) {

package/commands/account/createOverride.js

@@ -2,7 +2,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import { getCwd } from '@hubspot/local-dev-lib/path';
 import { DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME } from '@hubspot/local-dev-lib/constants/config';
-import { getConfigFilePath, getConfigAccountIfExists, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
+import { getConfigFilePath, getConfigAccountIfExists, globalConfigFileExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
 import { getDefaultAccountOverrideAccountId, getDefaultAccountOverrideFilePath, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
@@ -21,7 +21,8 @@ async function handler(args) {
         uiLogger.error(commands.account.subcommands.createOverride.errors.globalConfigNotFound);
         process.exit(EXIT_CODES.ERROR);
     }
-    const accountOverrideId = getDefaultAccountOverrideAccountId();
+    const accounts = getAllConfigAccounts();
+    const accountOverrideId = getDefaultAccountOverrideAccountId(accounts);
     const overrideFilePath = getDefaultAccountOverrideFilePath();
     if (accountOverrideId && overrideFilePath) {
         uiLogger.log(commands.account.subcommands.createOverride.accountOverride(overrideFilePath, accountOverrideId.toString()));

package/commands/account/info.js

@@ -3,9 +3,9 @@ import { getDefaultAccountOverrideFilePath } from '@hubspot/local-dev-lib/config
 import { getAccessToken } from '@hubspot/local-dev-lib/personalAccessKey';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { indent } from '../../lib/ui/index.js';
-import { getTableContents } from '../../lib/ui/table.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
+import { renderList } from '../../ui/render.js';
 const describe = commands.account.subcommands.info.describe;
 const command = 'info [account]';
 async function handler(args) {
@@ -38,7 +38,7 @@ async function handler(args) {
         uiLogger.log(commands.account.subcommands.info.name(name));
         uiLogger.log(commands.account.subcommands.info.accountId(derivedAccountId));
         uiLogger.log(commands.account.subcommands.info.scopeGroups);
-        uiLogger.log(getTableContents(scopeGroups, { border: { bodyLeft: '  ' } }));
+        renderList(scopeGroups);
     }
     else {
         uiLogger.log(commands.account.subcommands.info.errors.notUsingPersonalAccessKey);

package/commands/account/list.js

@@ -1,13 +1,13 @@
 import { getConfigFilePath, getAllConfigAccounts, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { getDefaultAccountOverrideFilePath } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
 import { indent } from '../../lib/ui/index.js';
-import { getTableContents, getTableHeader } from '../../lib/ui/table.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { isSandbox, isDeveloperTestAccount } from '../../lib/accountTypes.js';
 import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { commands } from '../../lang/en.js';
+import { renderTable } from '../../ui/render.js';
 const command = ['list', 'ls'];
 const describe = commands.account.subcommands.list.describe;
 function sortAndMapAccounts(accounts) {
@@ -65,11 +65,11 @@ async function handler(args) {
     const accountsList = getAllConfigAccounts();
     const mappedAccountData = sortAndMapAccounts(accountsList);
     const accountData = getAccountData(mappedAccountData);
-    accountData.unshift(getTableHeader([
+    const tableHeader = [
         commands.account.subcommands.list.labels.name,
         commands.account.subcommands.list.labels.accountId,
         commands.account.subcommands.list.labels.authType,
-    ]));
+    ];
     const defaultAccount = getConfigDefaultAccountIfExists();
     const accountId = defaultAccount?.accountId;
     const overrideFilePath = getDefaultAccountOverrideFilePath();
@@ -88,7 +88,7 @@ async function handler(args) {
         uiLogger.log('');
     }
     uiLogger.log(commands.account.subcommands.list.accounts);
-    uiLogger.log(getTableContents(accountData, { border: { bodyLeft: '  ' } }));
+    renderTable(tableHeader, accountData, true);
 }
 function accountListBuilder(yargs) {
     yargs.example([['$0 accounts list']]);

package/commands/account/remove.js

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { getConfigFilePath, removeAccountFromConfig, getConfigDefaultAccountIfExists, getConfigAccountIfExists, getConfigAccountById, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
+import { getConfigFilePath, removeAccountFromConfig, getConfigDefaultAccountIfExists, getConfigAccountIfExists, getConfigAccountById, setConfigAccountAsDefault, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
 import { getDefaultAccountOverrideAccountId, getDefaultAccountOverrideFilePath, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
@@ -25,7 +25,8 @@ async function handler(args) {
     accountToRemoveConfig = getConfigAccountById(accountToRemoveId);
     trackCommandUsage('accounts-remove', undefined, accountToRemoveId);
     const currentDefaultAccount = getConfigDefaultAccountIfExists();
-    const accountOverride = getDefaultAccountOverrideAccountId();
+    const accounts = getAllConfigAccounts();
+    const accountOverride = getDefaultAccountOverrideAccountId(accounts);
     const overrideFilePath = getDefaultAccountOverrideFilePath();
     if (overrideFilePath &&
         accountOverride &&