@hubspot/cli 7.10.0 → 7.11.0-experimental.0

package/lib/ui/__tests__/SpinniesManager.test.js

@@ -0,0 +1,489 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import SpinniesManager from '../SpinniesManager.js';
+// Mock dependencies
+vi.mock('readline', () => ({
+    default: {
+        clearScreenDown: vi.fn(),
+        moveCursor: vi.fn(),
+        clearLine: vi.fn(),
+    },
+}));
+vi.mock('cli-cursor', () => ({
+    default: {
+        hide: vi.fn(),
+        show: vi.fn(),
+    },
+}));
+vi.mock('../logger.js', () => ({
+    uiLogger: {
+        debug: vi.fn(),
+        log: vi.fn(),
+    },
+}));
+describe('SpinniesManager', () => {
+    let spinniesManager;
+    let mockUiLogger;
+    beforeEach(async () => {
+        // Reset the singleton instance before each test
+        vi.clearAllMocks();
+        // Get the mocked logger
+        const loggerModule = await import('../logger.js');
+        mockUiLogger = loggerModule.uiLogger;
+        // Mock process.stderr
+        Object.defineProperty(process, 'stderr', {
+            value: {
+                write: vi.fn(),
+                isTTY: true,
+                columns: 80,
+            },
+            writable: true,
+        });
+        // Mock process.env
+        delete process.env.CI;
+        spinniesManager = SpinniesManager;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('initialization', () => {
+        it('should initialize with default options', () => {
+            spinniesManager.init();
+            expect(spinniesManager.hasActiveSpinners()).toBe(false);
+        });
+        it('should initialize with custom options', () => {
+            const customOptions = {
+                spinnerColor: 'red',
+                succeedColor: 'blue',
+                failColor: 'yellow',
+            };
+            spinniesManager.init(customOptions);
+            spinniesManager.add('test', { text: 'Test spinner' });
+            const spinner = spinniesManager.pick('test');
+            expect(spinner).toBeDefined();
+        });
+        it('should set disableSpins to true in CI environment', () => {
+            process.env.CI = 'true';
+            spinniesManager.init();
+            spinniesManager.add('test', { text: 'Test spinner' });
+            const spinner = spinniesManager.pick('test');
+            expect(spinner).toBeDefined();
+        });
+        it('should use fallback spinner when terminal does not support unicode', () => {
+            Object.defineProperty(process, 'platform', {
+                value: 'win32',
+                writable: true,
+            });
+            delete process.env.TERM_PROGRAM;
+            delete process.env.WT_SESSION;
+            spinniesManager.init();
+            spinniesManager.add('test', { text: 'Test spinner' });
+            const spinner = spinniesManager.pick('test');
+            expect(spinner).toBeDefined();
+        });
+    });
+    describe('spinner management', () => {
+        beforeEach(() => {
+            spinniesManager.init();
+        });
+        describe('add', () => {
+            it('should add a spinner with name', () => {
+                spinniesManager.add('test-spinner', {
+                    text: 'Loading...',
+                });
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner).toBeDefined();
+                expect(spinner?.text).toBe('Loading...');
+                expect(spinner?.status).toBe('spinning');
+                expect(spinniesManager.hasActiveSpinners()).toBe(true);
+            });
+            it('should add a spinner without name and generate one', () => {
+                spinniesManager.add('', { text: 'Loading...' });
+                // Since we can't get the generated name directly, check that a spinner was added
+                expect(spinniesManager.hasActiveSpinners()).toBe(true);
+            });
+            it('should use spinner name as text if no text provided', () => {
+                spinniesManager.add('test-spinner');
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner?.text).toBe('test-spinner');
+            });
+            it('should add multiple spinners', () => {
+                spinniesManager.add('spinner1', { text: 'First' });
+                spinniesManager.add('spinner2', { text: 'Second' });
+                const spinner1 = spinniesManager.pick('spinner1');
+                const spinner2 = spinniesManager.pick('spinner2');
+                expect(spinner1).toBeDefined();
+                expect(spinner2).toBeDefined();
+                expect(spinniesManager.hasActiveSpinners()).toBe(true);
+            });
+        });
+        describe('pick', () => {
+            it('should return spinner by name', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                const picked = spinniesManager.pick('test-spinner');
+                expect(picked).toBeDefined();
+                expect(picked?.text).toBe('Loading...');
+            });
+            it('should return undefined for non-existent spinner', () => {
+                const picked = spinniesManager.pick('non-existent');
+                expect(picked).toBeUndefined();
+            });
+        });
+        describe('update', () => {
+            it('should update spinner properties', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                spinniesManager.update('test-spinner', {
+                    text: 'Updated text',
+                    color: 'red',
+                });
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner?.text).toBe('Updated text');
+                expect(spinner?.color).toBe('red');
+            });
+            it('should update spinner status', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                spinniesManager.update('test-spinner', {
+                    status: 'succeed',
+                });
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner).toBeDefined();
+                expect(spinner?.status).toBe('succeed');
+            });
+            it('should log and return early for invalid spinner name', async () => {
+                // @ts-expect-error testing bad input
+                spinniesManager.update(123, { text: 'test' });
+                expect(mockUiLogger.debug).toHaveBeenCalledWith('A spinner reference name must be specified');
+            });
+        });
+        describe('succeed', () => {
+            it('should mark spinner as succeeded', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                spinniesManager.succeed('test-spinner', { text: 'Success!' });
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner?.status).toBe('succeed');
+                expect(spinner?.text).toBe('Success!');
+            });
+            it('should succeed without updating text', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                spinniesManager.succeed('test-spinner');
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner?.status).toBe('succeed');
+                expect(spinner?.text).toBe('Loading...');
+            });
+        });
+        describe('fail', () => {
+            it('should mark spinner as failed', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                spinniesManager.fail('test-spinner', { text: 'Failed!' });
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner?.status).toBe('fail');
+                expect(spinner?.text).toBe('Failed!');
+            });
+            it('should fail without updating text', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                spinniesManager.fail('test-spinner');
+                const spinner = spinniesManager.pick('test-spinner');
+                expect(spinner?.status).toBe('fail');
+                expect(spinner?.text).toBe('Loading...');
+            });
+        });
+        describe('remove', () => {
+            it('should remove spinner by name', () => {
+                spinniesManager.add('test-spinner', { text: 'Loading...' });
+                expect(spinniesManager.pick('test-spinner')).toBeDefined();
+                spinniesManager.remove('test-spinner');
+                expect(spinniesManager.pick('test-spinner')).toBeUndefined();
+            });
+            it('should log debug message for invalid name', async () => {
+                // @ts-expect-error Testing bad case
+                spinniesManager.remove(123);
+                expect(mockUiLogger.debug).toHaveBeenCalledWith('A spinner reference name must be specified');
+            });
+            it('should handle undefined name', async () => {
+                // @ts-expect-error bad input
+                spinniesManager.remove(undefined);
+                expect(mockUiLogger.debug).toHaveBeenCalledWith('A spinner reference name must be specified');
+            });
+        });
+        describe('stopAll', () => {
+            beforeEach(() => {
+                // @ts-expect-error private
+                spinniesManager.spinners = {};
+                spinniesManager.add('spinner1', { text: 'First' });
+                spinniesManager.add('spinner2', { text: 'Second' });
+            });
+            it('should stop all active spinners with default status', () => {
+                // Check spinners exist before stopping
+                expect(spinniesManager.pick('spinner1')).toBeDefined();
+                expect(spinniesManager.pick('spinner2')).toBeDefined();
+                // Mock checkIfActiveSpinners to prevent clearing of spinners
+                const originalCheckIfActiveSpinners = 
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners;
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = vi.fn();
+                const result = spinniesManager.stopAll();
+                // The result should contain the updated spinners
+                expect(result.spinner1?.status).toBe('stopped');
+                expect(result.spinner2?.status).toBe('stopped');
+                expect(result.spinner1?.color).toBe('gray');
+                expect(result.spinner2?.color).toBe('gray');
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = originalCheckIfActiveSpinners;
+            });
+            it('should stop all active spinners with succeed status', () => {
+                // Check spinners exist before stopping
+                expect(spinniesManager.pick('spinner1')).toBeDefined();
+                expect(spinniesManager.pick('spinner2')).toBeDefined();
+                // Mock checkIfActiveSpinners to prevent clearing of spinners
+                const originalCheckIfActiveSpinners = 
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners;
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = vi.fn();
+                const result = spinniesManager.stopAll('succeed');
+                expect(result.spinner1?.status).toBe('succeed');
+                expect(result.spinner2?.status).toBe('succeed');
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = originalCheckIfActiveSpinners;
+            });
+            it('should stop all active spinners with fail status', () => {
+                // Check spinners exist before stopping
+                expect(spinniesManager.pick('spinner1')).toBeDefined();
+                expect(spinniesManager.pick('spinner2')).toBeDefined();
+                // Mock checkIfActiveSpinners to prevent clearing of spinners
+                const originalCheckIfActiveSpinners = 
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners;
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = vi.fn();
+                const result = spinniesManager.stopAll('fail');
+                expect(result.spinner1?.status).toBe('fail');
+                expect(result.spinner2?.status).toBe('fail');
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = originalCheckIfActiveSpinners;
+            });
+            it('should not change already completed spinners', () => {
+                // Add a spinner that is already completed
+                spinniesManager.add('completed', { text: 'Done' });
+                spinniesManager.succeed('completed');
+                // Verify it exists and is succeeded
+                expect(spinniesManager.pick('completed')?.status).toBe('succeed');
+                // Mock checkIfActiveSpinners to prevent clearing of spinners
+                const originalCheckIfActiveSpinners = 
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners;
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = vi.fn();
+                const result = spinniesManager.stopAll();
+                // Completed spinners should not change status
+                expect(result.completed?.status).toBe('succeed');
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = originalCheckIfActiveSpinners;
+            });
+            it('should handle non-spinnable status correctly', () => {
+                // Add spinner with non-spinnable status
+                spinniesManager.add('non-spin', {
+                    text: 'Non-spinnable',
+                    status: 'non-spinnable',
+                });
+                // Verify it exists with correct status
+                expect(spinniesManager.pick('non-spin')?.status).toBe('non-spinnable');
+                // Mock checkIfActiveSpinners to prevent clearing of spinners
+                const originalCheckIfActiveSpinners = 
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners;
+                // @ts-expect-error private method
+                spinniesManager.checkIfActiveSpinners = vi.fn();
+                const result = spinniesManager.stopAll();
+                // Non-spinnable status should not change
+                expect(result['non-spin']?.status).toBe('non-spinnable');
+                // @ts-expect-error Testing private method
+                spinniesManager.checkIfActiveSpinners = originalCheckIfActiveSpinners;
+            });
+        });
+    });
+    describe('active spinner detection', () => {
+        beforeEach(() => {
+            spinniesManager.init();
+        });
+        it('should detect active spinners', () => {
+            expect(spinniesManager.hasActiveSpinners()).toBe(false);
+            spinniesManager.add('active', { text: 'Loading...' });
+            expect(spinniesManager.hasActiveSpinners()).toBe(true);
+            spinniesManager.succeed('active');
+            expect(spinniesManager.hasActiveSpinners()).toBe(false);
+        });
+        it('should detect multiple active spinners', () => {
+            spinniesManager.add('active1', { text: 'Loading 1...' });
+            spinniesManager.add('active2', { text: 'Loading 2...' });
+            expect(spinniesManager.hasActiveSpinners()).toBe(true);
+            spinniesManager.succeed('active1');
+            expect(spinniesManager.hasActiveSpinners()).toBe(true);
+            spinniesManager.succeed('active2');
+            expect(spinniesManager.hasActiveSpinners()).toBe(false);
+        });
+    });
+    describe('output control', () => {
+        beforeEach(() => {
+            spinniesManager.init();
+        });
+        it('should disable output when requested', () => {
+            spinniesManager.setDisableOutput(true);
+            spinniesManager.add('test', { text: 'Test' });
+            // Output should be disabled, so no writes to stderr should occur
+            expect(process.stderr.write).not.toHaveBeenCalled();
+        });
+        it('should enable output by default', () => {
+            // Mock process.stderr.write to be a spy
+            const mockWrite = vi.fn();
+            Object.defineProperty(process.stderr, 'write', {
+                value: mockWrite,
+                writable: true,
+            });
+            // Set stderr.isTTY to false to trigger raw output mode
+            Object.defineProperty(process.stderr, 'isTTY', {
+                value: false,
+                writable: true,
+            });
+            spinniesManager.setDisableOutput(false);
+            spinniesManager.init(); // Re-init to pick up the new isTTY value
+            spinniesManager.add('test', { text: 'Test' });
+            // In non-TTY mode, it should write with raw output
+            expect(mockWrite).toHaveBeenCalledWith('- Test\n');
+        });
+    });
+    describe('error handling', () => {
+        beforeEach(() => {
+            spinniesManager.init();
+        });
+        it('should handle missing spinner in update', async () => {
+            spinniesManager.update('non-existent', { text: 'test' });
+            expect(mockUiLogger.debug).toHaveBeenCalledWith('No spinner initialized with name non-existent');
+        });
+        it('should handle missing spinner in setSpinnerProperties', async () => {
+            // @ts-expect-error Testing private method
+            spinniesManager.setSpinnerProperties('missing', {
+                text: 'test',
+            });
+            expect(mockUiLogger.debug).toHaveBeenCalledWith('No spinner initialized with name missing');
+        });
+        it('should handle invalid spinner name types', async () => {
+            // @ts-expect-error Testing private method
+            spinniesManager.setSpinnerProperties(null, { text: 'test' });
+            expect(mockUiLogger.debug).toHaveBeenCalledWith('A spinner reference name must be specified');
+            // @ts-expect-error Testing private method
+            spinniesManager.setSpinnerProperties(undefined, {
+                text: 'test',
+            });
+            expect(mockUiLogger.debug).toHaveBeenCalledWith('A spinner reference name must be specified');
+            // @ts-expect-error Testing private method
+            spinniesManager.setSpinnerProperties(123, { text: 'test' });
+            expect(mockUiLogger.debug).toHaveBeenCalledWith('A spinner reference name must be specified');
+        });
+    });
+    describe('SIGINT handling', () => {
+        beforeEach(() => {
+            spinniesManager.init();
+        });
+        it('should bind SIGINT handler on init', () => {
+            const processOnSpy = vi.spyOn(process, 'on');
+            const processRemoveAllListenersSpy = vi.spyOn(process, 'removeAllListeners');
+            spinniesManager.init();
+            expect(processRemoveAllListenersSpy).toHaveBeenCalledWith('SIGINT');
+            expect(processOnSpy).toHaveBeenCalledWith('SIGINT', expect.any(Function));
+        });
+    });
+    describe('spinner options validation', () => {
+        beforeEach(() => {
+            spinniesManager.init();
+        });
+        it('should handle custom spinner frames', () => {
+            const customOptions = {
+                spinner: {
+                    frames: ['|', '/', '-', '\\'],
+                    interval: 100,
+                },
+            };
+            spinniesManager.init(customOptions);
+            spinniesManager.add('custom', { text: 'Custom spinner' });
+            const spinner = spinniesManager.pick('custom');
+            expect(spinner).toBeDefined();
+            expect(spinner?.text).toBe('Custom spinner');
+        });
+        it('should handle custom colors', () => {
+            spinniesManager.add('colored', {
+                text: 'Colored spinner',
+                color: 'red',
+                spinnerColor: 'blue',
+                succeedColor: 'green',
+                failColor: 'yellow',
+            });
+            const spinner = spinniesManager.pick('colored');
+            expect(spinner?.color).toBe('red');
+            expect(spinner?.spinnerColor).toBe('blue');
+            expect(spinner?.succeedColor).toBe('green');
+            expect(spinner?.failColor).toBe('yellow');
+        });
+        it('should handle indentation', () => {
+            spinniesManager.add('indented', {
+                text: 'Indented spinner',
+                indent: 4,
+            });
+            const spinner = spinniesManager.pick('indented');
+            expect(spinner?.indent).toBe(4);
+        });
+        it('should handle custom prefixes', () => {
+            spinniesManager.init({
+                succeedPrefix: '[OK]',
+                failPrefix: '[ERR]',
+            });
+            spinniesManager.add('prefixed', {
+                text: 'Prefixed spinner',
+            });
+            const spinner = spinniesManager.pick('prefixed');
+            expect(spinner?.succeedPrefix).toBe('[OK]');
+            expect(spinner?.failPrefix).toBe('[ERR]');
+        });
+    });
+    describe('edge cases', () => {
+        beforeEach(() => {
+            spinniesManager.init();
+        });
+        it('should handle empty spinner name gracefully', () => {
+            spinniesManager.add('', { text: 'No name spinner' });
+            // Since we can't get the generated name directly, just verify a spinner was added
+            expect(spinniesManager.hasActiveSpinners()).toBe(true);
+        });
+        it('should handle null/undefined text', () => {
+            // @ts-expect-error Testing bad case
+            spinniesManager.add('null-text', { text: null });
+            const spinner = spinniesManager.pick('null-text');
+            expect(spinner?.text).toBe('null-text');
+        });
+        it('should handle non-TTY environments', () => {
+            const mockWrite = vi.fn();
+            Object.defineProperty(process.stderr, 'write', {
+                value: mockWrite,
+                writable: true,
+            });
+            Object.defineProperty(process.stderr, 'isTTY', {
+                value: false,
+                writable: true,
+            });
+            spinniesManager.init();
+            spinniesManager.add('no-tty', { text: 'No TTY' });
+            const spinner = spinniesManager.pick('no-tty');
+            expect(spinner).toBeDefined();
+            expect(mockWrite).toHaveBeenCalledWith('- No TTY\n');
+        });
+        it('should handle missing process.stderr.columns', () => {
+            // @ts-expect-error
+            delete process.stderr.columns;
+            spinniesManager.add('no-columns', {
+                text: 'A very long text that would normally be broken into multiple lines but now has to handle missing columns gracefully',
+            });
+            const spinner = spinniesManager.pick('no-columns');
+            expect(spinner).toBeDefined();
+        });
+    });
+});

package/lib/ui/index.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { getAccountConfig, configFileExists, } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountIfExists, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
 import { uiLogger } from './logger.js';
 import { supportsHyperlinkModule } from './supportHyperlinks.js';
 import { supportsColor } from './supportsColor.js';
@@ -38,7 +38,7 @@ export function uiLink(linkText, url) {
         : `${linkText}: ${encodedUrl}`;
 }
 export function uiAccountDescription(accountId, bold = true) {
-    const account = getAccountConfig(accountId || undefined);
+    const account = accountId ? getConfigAccountIfExists(accountId) : undefined;
     let message;
     if (account && account.accountType) {
         message = `${account.name ? `${account.name} ` : ''}[${HUBSPOT_ACCOUNT_TYPE_STRINGS[account.accountType]}] (${accountId})`;
@@ -46,6 +46,9 @@ export function uiAccountDescription(accountId, bold = true) {
     else {
         message = accountId ? accountId.toString() : '';
     }
+    if (message.trim().length === 0) {
+        return 'unknown account';
+    }
     return bold ? chalk.bold(message) : message;
 }
 export function uiInfoSection(title, logContent) {
@@ -64,7 +67,7 @@ export function uiCommandReference(command, withQuotes = true) {
         : commandReference);
 }
 export function uiAuthCommandReference({ accountId, qa, } = {}) {
-    const userIsUsingGlobalConfig = configFileExists(true);
+    const userIsUsingGlobalConfig = globalConfigFileExists();
     let command = 'hs auth';
     if (userIsUsingGlobalConfig) {
         command = 'hs account auth';

package/lib/usageTracking.js

@@ -1,5 +1,5 @@
 import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { isTrackingAllowed, getAccountConfig, } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, getConfig } 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 { pkg } from './jsonLoader.js';
@@ -28,13 +28,17 @@ export function getPlatform() {
     }
 }
 export async function trackCommandUsage(command, meta = {}, accountId) {
-    if (!isTrackingAllowed()) {
-        return;
+    try {
+        const config = getConfig();
+        if (config?.allowUsageTracking === false) {
+            return;
+        }
     }
+    catch (e) { }
     uiLogger.debug(`Attempting to track usage of "${command}" command`);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getAccountConfig(accountId);
+        const accountConfig = getConfigAccountById(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
@@ -49,7 +53,8 @@ export async function trackCommandUsage(command, meta = {}, accountId) {
     });
 }
 export async function trackHelpUsage(command) {
-    if (!isTrackingAllowed()) {
+    const config = getConfig();
+    if (config?.allowUsageTracking === false) {
         return;
     }
     if (command) {
@@ -81,13 +86,14 @@ export async function trackAuthAction(command, authType, step, accountId) {
     });
 }
 export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
-    if (!isTrackingAllowed()) {
+    const config = getConfig();
+    if (config?.allowUsageTracking === false) {
         return;
     }
     uiLogger.debug(`Attempting to track metadata usage of "${command}" command`);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getAccountConfig(accountId);
+        const accountConfig = getConfigAccountById(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
@@ -103,7 +109,8 @@ export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
 }
 async function trackCliInteraction({ action, accountId, command, authType, meta = {}, }) {
     try {
-        if (!isTrackingAllowed()) {
+        const config = getConfig();
+        if (config?.allowUsageTracking === false) {
             return;
         }
         const usageTrackingEvent = {

package/lib/validation.js

@@ -4,16 +4,17 @@ import { uiLogger } from '../lib/ui/logger.js';
 import { CMS_PUBLISH_MODE } from '@hubspot/local-dev-lib/constants/files';
 import { API_KEY_AUTH_METHOD, OAUTH_AUTH_METHOD, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
 import { commaSeparatedValues } from '@hubspot/local-dev-lib/text';
-import { getConfigPath, getAccountConfig, getAccountId, loadConfigFromEnvironment, } from '@hubspot/local-dev-lib/config';
+import { getConfigFilePath, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
 import { getOauthManager } from '@hubspot/local-dev-lib/oauth';
 import { accessTokenForPersonalAccessKey } from '@hubspot/local-dev-lib/personalAccessKey';
 import { getAbsoluteFilePath, getCwd, getExt, } from '@hubspot/local-dev-lib/path';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
 import { getCmsPublishMode } from './commonOpts.js';
 import { logError } from './errorHandlers/index.js';
 import { lib } from '../lang/en.js';
 export async function validateAccount(options) {
     const { derivedAccountId, userProvidedAccount } = options;
-    const accountId = getAccountId(derivedAccountId);
+    const accountId = derivedAccountId;
     if (!accountId) {
         if (userProvidedAccount) {
             uiLogger.error(lib.validation.accountNotFoundInConfig(userProvidedAccount));
@@ -23,33 +24,34 @@ export async function validateAccount(options) {
         }
         return false;
     }
-    if (userProvidedAccount && loadConfigFromEnvironment()) {
+    if (userProvidedAccount &&
+        process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG]) {
         throw new Error(lib.validation.userProvidedAccount);
     }
-    const accountConfig = getAccountConfig(accountId);
+    const accountConfig = getConfigAccountById(accountId);
     if (!accountConfig) {
         uiLogger.error(lib.validation.accountNotConfigured(accountId));
         return false;
     }
-    const { authType, auth, apiKey, personalAccessKey } = accountConfig;
+    const { authType } = accountConfig;
     if (typeof authType === 'string' && authType !== authType.toLowerCase()) {
-        uiLogger.error(lib.validation.invalidAuthType(authType, accountId, getConfigPath() || '', commaSeparatedValues([
+        uiLogger.error(lib.validation.invalidAuthType(authType, accountId, getConfigFilePath(), commaSeparatedValues([
             PERSONAL_ACCESS_KEY_AUTH_METHOD,
             OAUTH_AUTH_METHOD,
             API_KEY_AUTH_METHOD,
         ].map(method => method.value))));
     }
     if (authType === 'oauth2') {
-        if (typeof auth !== 'object') {
+        if (typeof accountConfig.auth !== 'object') {
             uiLogger.error(lib.validation.oauth2ConfigMissing(accountId));
             return false;
         }
-        const { clientId, clientSecret, tokenInfo } = auth;
+        const { clientId, clientSecret, tokenInfo } = accountConfig.auth;
         if (!clientId || !clientSecret || !tokenInfo || !tokenInfo.refreshToken) {
             uiLogger.error(lib.validation.oauth2ConfigIncorrect(accountId));
             return false;
         }
-        const oauth = getOauthManager(accountId, accountConfig);
+        const oauth = getOauthManager(accountConfig);
         try {
             let accessToken;
             if (oauth) {
@@ -66,7 +68,7 @@ export async function validateAccount(options) {
         }
     }
     else if (authType === 'personalaccesskey') {
-        if (!personalAccessKey) {
+        if (!accountConfig.personalAccessKey) {
             uiLogger.error(lib.validation.personalAccessKeyMissing(accountId));
             return false;
         }
@@ -82,7 +84,7 @@ export async function validateAccount(options) {
             return false;
         }
     }
-    else if (!apiKey) {
+    else if (!accountConfig.apiKey) {
         uiLogger.error(lib.validation.authConfigurationMissing(accountId));
         return false;
     }