@hubspot/cli 8.3.0 → 8.4.0-beta.0

package/commands/testAccount/__tests__/delete.test.js

@@ -1,29 +0,0 @@
-import yargs from 'yargs';
-import { addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
-import testAccountDeleteCommand from '../delete.js';
-vi.mock('../../../lib/commonOpts');
-describe('commands/testAccount/delete', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(testAccountDeleteCommand.command).toEqual('delete [test-account]');
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(testAccountDeleteCommand.describe).toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            testAccountDeleteCommand.builder(yargsMock);
-            expect(yargsMock.example).toHaveBeenCalledTimes(1);
-            expect(addTestingOptions).toHaveBeenCalledTimes(1);
-            expect(addTestingOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
-        });
-    });
-});

package/commands/testAccount/__tests__/importData.test.d.ts

@@ -1 +0,0 @@
-export {};

package/commands/testAccount/__tests__/importData.test.js

@@ -1,92 +0,0 @@
-import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
-import testAccountImportDataCommand from '../importData.js';
-import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import { handleImportData, handleTargetTestAccountSelectionFlow, } from '../../../lib/importData.js';
-import { trackCommandUsage } from '../../../lib/usageTracking.js';
-import { getImportDataRequest } from '@hubspot/local-dev-lib/crm';
-import { logError } from '../../../lib/errorHandlers/index.js';
-import { importDataFilePathPrompt } from '../../../lib/prompts/importDataFilePathPrompt.js';
-import { confirmImportDataPrompt } from '../../../lib/prompts/confirmImportDataPrompt.js';
-vi.mock('../../../lib/commonOpts');
-vi.mock('../../../lib/importData');
-vi.mock('@hubspot/local-dev-lib/crm');
-vi.mock('../../../lib/errorHandlers/index');
-vi.mock('../../../lib/prompts/importDataFilePathPrompt');
-vi.mock('../../../lib/prompts/confirmImportDataPrompt');
-describe('commands/testAccount/importData', () => {
-    const yargsMock = yargs;
-    const mockExit = vi
-        .spyOn(process, 'exit')
-        .mockImplementation(() => undefined);
-    const mockHandleImportData = vi.mocked(handleImportData);
-    const mockHandleTargetTestAccountSelectionFlow = vi.mocked(handleTargetTestAccountSelectionFlow);
-    const mockTrackCommandUsage = vi.mocked(trackCommandUsage);
-    const mockGetImportDataRequest = vi.mocked(getImportDataRequest);
-    const mockLogError = vi.mocked(logError);
-    const mockImportDataFilePathPrompt = vi.mocked(importDataFilePathPrompt);
-    const mockConfirmImportDataPrompt = vi.mocked(confirmImportDataPrompt);
-    beforeEach(() => {
-        mockExit.mockReset();
-        mockHandleImportData.mockReset();
-        mockHandleTargetTestAccountSelectionFlow.mockReset();
-        mockTrackCommandUsage.mockReset();
-        mockGetImportDataRequest.mockReset();
-        mockLogError.mockReset();
-        mockImportDataFilePathPrompt.mockReset();
-        mockConfirmImportDataPrompt.mockReset();
-    });
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(testAccountImportDataCommand.command).toEqual('import-data');
-        });
-    });
-    // describe('describe', () => {
-    //   it('should provide a description', () => {
-    //     expect(testAccountImportDataCommand.describe).toBeDefined();
-    //   });
-    // });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            testAccountImportDataCommand.builder(yargsMock);
-            expect(yargsMock.example).toHaveBeenCalledTimes(1);
-            expect(yargsMock.options).toHaveBeenCalledTimes(1);
-            expect(addAccountOptions).toHaveBeenCalledTimes(1);
-            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
-        });
-    });
-    describe('handler', () => {
-        it('should complete the flow given the correct args', async () => {
-            const targetAccountId = 123456789;
-            const mockArgs = {
-                d: false,
-                debug: false,
-                _: [],
-                $0: 'hs',
-                derivedAccountId: targetAccountId,
-                userProvidedAccount: 'test-account',
-                filePath: 'test-file.json',
-                skipConfirm: true,
-            };
-            mockHandleTargetTestAccountSelectionFlow.mockResolvedValue(targetAccountId);
-            mockGetImportDataRequest.mockReturnValue({
-                importRequest: {},
-                dataFileNames: ['test-file.json'],
-            });
-            mockHandleImportData.mockResolvedValue();
-            await testAccountImportDataCommand.handler(mockArgs);
-            expect(mockHandleTargetTestAccountSelectionFlow).toHaveBeenCalledWith(123456789, 'test-account');
-            expect(mockGetImportDataRequest).toHaveBeenCalledWith('test-file.json');
-            expect(mockHandleImportData).toHaveBeenCalledTimes(1);
-            expect(mockTrackCommandUsage).toHaveBeenCalledTimes(1);
-            expect(mockLogError).not.toHaveBeenCalled();
-            expect(mockImportDataFilePathPrompt).not.toHaveBeenCalled();
-            expect(mockConfirmImportDataPrompt).not.toHaveBeenCalled();
-            expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
-        });
-    });
-});

package/lib/__tests__/CLIWebSocketServer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/__tests__/CLIWebSocketServer.test.js

@@ -1,252 +0,0 @@
-import { WebSocketServer } from 'ws';
-import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { uiLogger } from '../ui/logger.js';
-import CLIWebSocketServer from '../CLIWebSocketServer.js';
-import { lib } from '../../lang/en.js';
-import { pkg } from '../jsonLoader.js';
-vi.mock('ws');
-vi.mock('@hubspot/local-dev-lib/portManager');
-const INSTANCE_ID = 'test-websocket-server';
-const LOG_PREFIX = '[TestWebSocketServer]';
-const PORT = 1234;
-describe('CLIWebSocketServer', () => {
-    let mockWebSocket;
-    let mockWebSocketServer;
-    let server;
-    beforeEach(() => {
-        mockWebSocket = {
-            on: vi.fn(),
-            send: vi.fn(),
-            close: vi.fn(),
-        };
-        mockWebSocketServer = {
-            on: vi.fn(),
-            close: vi.fn(),
-        };
-        WebSocketServer.mockImplementation(() => mockWebSocketServer);
-        server = new CLIWebSocketServer({
-            instanceId: INSTANCE_ID,
-            logPrefix: LOG_PREFIX,
-            debug: true,
-        });
-    });
-    describe('start()', () => {
-        it('should throw error if port manager is not running', async () => {
-            isPortManagerServerRunning.mockResolvedValue(false);
-            await expect(server.start({})).rejects.toThrow(lib.CLIWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
-        });
-        it('should start websocket server on the assigned port', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                [INSTANCE_ID]: PORT,
-            });
-            await server.start({});
-            expect(WebSocketServer).toHaveBeenCalledWith({ port: PORT });
-            expect(mockWebSocketServer.on).toHaveBeenCalledWith('connection', expect.any(Function));
-        });
-        it('should log startup message when debug is enabled', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                [INSTANCE_ID]: PORT,
-            });
-            await server.start({});
-            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining(String(PORT)));
-        });
-    });
-    describe('origin validation', () => {
-        const validOrigins = [
-            'https://app.hubspot.com',
-            'https://app.hubspotqa.com',
-            'https://local.hubspot.com',
-            'https://local.hubspotqa.com',
-            'https://app-na2.hubspot.com',
-            'https://app-na2.hubspotqa.com',
-            'https://app-na3.hubspot.com',
-            'https://app-na3.hubspotqa.com',
-            'https://app-ap1.hubspot.com',
-            'https://app-ap1.hubspotqa.com',
-            'https://app-eu1.hubspot.com',
-            'https://app-eu1.hubspotqa.com',
-        ];
-        let connectionCallback;
-        beforeEach(async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                [INSTANCE_ID]: PORT,
-            });
-            await server.start({});
-            connectionCallback = mockWebSocketServer.on.mock
-                .calls[0][1];
-        });
-        validOrigins.forEach(origin => {
-            it(`should accept connection from ${origin}`, () => {
-                connectionCallback(mockWebSocket, { headers: { origin } });
-                expect(mockWebSocket.close).not.toHaveBeenCalled();
-                expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
-            });
-        });
-        const invalidOrigins = [
-            'https://malicious-site.com',
-            'https://app.malicious-site.com',
-            'https://app.hubspot.com.evil.com',
-        ];
-        invalidOrigins.forEach(origin => {
-            it(`should reject connection from "${origin}"`, () => {
-                connectionCallback(mockWebSocket, { headers: { origin } });
-                expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.CLIWebsocketServer.errors.originNotAllowed(origin));
-                expect(mockWebSocket.on).not.toHaveBeenCalled();
-            });
-        });
-        it('should reject connection with no origin header', () => {
-            connectionCallback(mockWebSocket, { headers: {} });
-            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.CLIWebsocketServer.errors.originNotAllowed());
-            expect(mockWebSocket.on).not.toHaveBeenCalled();
-        });
-    });
-    describe('sendCliMetadata', () => {
-        let connectionCallback;
-        beforeEach(async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                [INSTANCE_ID]: PORT,
-            });
-        });
-        it('should send cliVersion on connection', async () => {
-            await server.start({});
-            connectionCallback = mockWebSocketServer.on.mock
-                .calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify({
-                type: 'server:cliMetadata',
-                data: { cliVersion: pkg.version },
-            }));
-        });
-        it('should merge additional metadata when provided', async () => {
-            await server.start({
-                metadata: { customField: 'customValue', version: 2 },
-            });
-            connectionCallback = mockWebSocketServer.on.mock
-                .calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify({
-                type: 'server:cliMetadata',
-                data: {
-                    cliVersion: pkg.version,
-                    customField: 'customValue',
-                    version: 2,
-                },
-            }));
-        });
-    });
-    describe('callbacks', () => {
-        let connectionCallback;
-        beforeEach(async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                [INSTANCE_ID]: PORT,
-            });
-        });
-        it('should call onConnection for valid connections', async () => {
-            const onConnection = vi.fn();
-            await server.start({ onConnection });
-            connectionCallback = mockWebSocketServer.on.mock
-                .calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            expect(onConnection).toHaveBeenCalledWith(mockWebSocket);
-        });
-        it('should not call onConnection for rejected connections', async () => {
-            const onConnection = vi.fn();
-            await server.start({ onConnection });
-            connectionCallback = mockWebSocketServer.on.mock
-                .calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://malicious.com' },
-            });
-            expect(onConnection).not.toHaveBeenCalled();
-        });
-        it('should call onMessage when a valid message is received', async () => {
-            const onMessage = vi.fn().mockReturnValue(true);
-            await server.start({ onMessage });
-            connectionCallback = mockWebSocketServer.on.mock
-                .calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
-            messageCallback(JSON.stringify({ type: 'test:action', data: { key: 'value' } }));
-            expect(onMessage).toHaveBeenCalledWith(mockWebSocket, {
-                type: 'test:action',
-                data: { key: 'value' },
-            });
-        });
-        it('should log error when onMessage returns false', async () => {
-            const onMessage = vi.fn().mockReturnValue(false);
-            await server.start({ onMessage });
-            connectionCallback = mockWebSocketServer.on.mock
-                .calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
-            messageCallback(JSON.stringify({ type: 'UNKNOWN_TYPE' }));
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('UNKNOWN_TYPE'));
-        });
-        it('should call onClose when server closes', async () => {
-            const onClose = vi.fn();
-            await server.start({ onClose });
-            const closeCallback = mockWebSocketServer.on.mock.calls.find(call => call[0] === 'close')[1];
-            closeCallback();
-            expect(onClose).toHaveBeenCalled();
-        });
-    });
-    describe('message parsing', () => {
-        let messageCallback;
-        beforeEach(async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                [INSTANCE_ID]: PORT,
-            });
-            await server.start({});
-            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
-        });
-        it('should log error for messages missing a type field', () => {
-            messageCallback(JSON.stringify({}));
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Missing type field'));
-        });
-        it('should log error for invalid JSON', () => {
-            messageCallback('not valid json');
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Invalid JSON'));
-        });
-    });
-    describe('sendMessage()', () => {
-        it('should serialize and send a message to the websocket', () => {
-            const message = { type: 'test:message', data: { foo: 'bar' } };
-            server.sendMessage(mockWebSocket, message);
-            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify(message));
-        });
-    });
-    describe('shutdown()', () => {
-        it('should close the websocket server', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                [INSTANCE_ID]: PORT,
-            });
-            await server.start({});
-            server.shutdown();
-            expect(mockWebSocketServer.close).toHaveBeenCalled();
-        });
-        it('should handle shutdown when server was never started', () => {
-            expect(() => server.shutdown()).not.toThrow();
-        });
-    });
-});

package/lib/__tests__/accountAuth.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/__tests__/accountAuth.test.js

@@ -1,258 +0,0 @@
-import { updateConfigAccount, createEmptyConfigFile, getConfigFilePath, localConfigFileExists, globalConfigFileExists, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
-import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
-import { toKebabCase } from '@hubspot/local-dev-lib/text';
-import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
-import { handleMerge, handleMigration } from '../configMigrate.js';
-import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
-import { cliAccountNamePrompt } from '../prompts/accountNamePrompt.js';
-import { setAsDefaultAccountPrompt } from '../prompts/setAsDefaultAccountPrompt.js';
-import { authenticateNewAccount } from '../accountAuth.js';
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('@hubspot/local-dev-lib/personalAccessKey');
-vi.mock('@hubspot/local-dev-lib/text');
-vi.mock('../configMigrate.js');
-vi.mock('../errorHandlers/index.js');
-vi.mock('../prompts/personalAccessKeyPrompt.js');
-vi.mock('../prompts/accountNamePrompt.js');
-vi.mock('../prompts/setAsDefaultAccountPrompt.js');
-vi.mock('../ui/logger.js', () => ({
-    uiLogger: {
-        log: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-const mockedUpdateConfigAccount = updateConfigAccount;
-const mockedCreateEmptyConfigFile = createEmptyConfigFile;
-const mockedGetConfigFilePath = getConfigFilePath;
-const mockedLocalConfigFileExists = localConfigFileExists;
-const mockedGlobalConfigFileExists = globalConfigFileExists;
-const mockedSetConfigAccountAsDefault = setConfigAccountAsDefault;
-const mockedGetAccessToken = getAccessToken;
-const mockedUpdateConfigWithAccessToken = updateConfigWithAccessToken;
-const mockedToKebabCase = toKebabCase;
-const mockedHandleMerge = handleMerge;
-const mockedHandleMigration = handleMigration;
-const mockedPersonalAccessKeyPrompt = personalAccessKeyPrompt;
-const mockedCliAccountNamePrompt = cliAccountNamePrompt;
-const mockedSetAsDefaultAccountPrompt = setAsDefaultAccountPrompt;
-describe('lib/accountAuth', () => {
-    describe('authenticateNewAccount()', () => {
-        const mockAccessToken = {
-            portalId: 123456,
-            accessToken: 'test-token',
-            expiresAt: '2025-01-01',
-            scopeGroups: ['test-scope'],
-            enabledFeatures: { 'test-feature': 1 },
-            encodedOAuthRefreshToken: 'test-refresh-token',
-            hubName: 'Test Hub',
-            accountType: 'STANDARD',
-        };
-        const mockAccountConfig = {
-            name: 'test-hub',
-            accountId: 123456,
-            env: 'prod',
-            accountType: 'STANDARD',
-            authType: PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
-            personalAccessKey: 'test-key',
-            auth: {
-                tokenInfo: {
-                    accessToken: 'test-token',
-                    expiresAt: '2025-01-01',
-                },
-            },
-        };
-        beforeEach(() => {
-            vi.clearAllMocks();
-            mockedLocalConfigFileExists.mockReturnValue(false);
-            mockedGlobalConfigFileExists.mockReturnValue(false);
-            mockedGetAccessToken.mockResolvedValue(mockAccessToken);
-            mockedUpdateConfigWithAccessToken.mockResolvedValue(mockAccountConfig);
-            mockedToKebabCase.mockReturnValue('test-hub');
-            mockedCliAccountNamePrompt.mockResolvedValue({ name: 'test-hub' });
-            mockedGetConfigFilePath.mockReturnValue('/path/to/config');
-            mockedPersonalAccessKeyPrompt.mockResolvedValue({
-                personalAccessKey: 'test-key',
-            });
-        });
-        it('should create config file if it does not exist', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(false);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCreateEmptyConfigFile).toHaveBeenCalledWith(true);
-        });
-        it('should not create config file if it already exists', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCreateEmptyConfigFile).not.toHaveBeenCalled();
-        });
-        it('should use provided personal access key without prompting', async () => {
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedPersonalAccessKeyPrompt).not.toHaveBeenCalled();
-            expect(mockedGetAccessToken).toHaveBeenCalledWith('test-key', 'prod');
-        });
-        it('should prompt for personal access key if not provided', async () => {
-            await authenticateNewAccount({
-                env: 'prod',
-                accountId: 123456,
-            });
-            expect(mockedPersonalAccessKeyPrompt).toHaveBeenCalledWith({
-                env: 'prod',
-                account: 123456,
-            });
-            expect(mockedGetAccessToken).toHaveBeenCalledWith('test-key', 'prod');
-        });
-        it('should prompt for account name if config does not exist', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(false);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCliAccountNamePrompt).toHaveBeenCalledWith('test-hub');
-        });
-        it('should not prompt for account name if config already exists', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCliAccountNamePrompt).not.toHaveBeenCalled();
-        });
-        it('should set account as default when setAsDefaultAccount is true', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-                setAsDefaultAccount: true,
-            });
-            expect(mockedSetConfigAccountAsDefault).toHaveBeenCalledWith('test-hub');
-        });
-        it('should prompt to set as default when setAsDefaultAccount is not provided and config exists', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedSetAsDefaultAccountPrompt).toHaveBeenCalledWith('test-hub');
-        });
-        it('should return the updated account config on success', async () => {
-            const result = await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(result).toEqual(mockAccountConfig);
-        });
-        it('should return null if access token fetch fails', async () => {
-            mockedGetAccessToken.mockRejectedValue(new Error('Invalid token'));
-            const result = await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(result).toBeNull();
-        });
-        it('should return null if config update fails', async () => {
-            mockedUpdateConfigWithAccessToken.mockResolvedValue(null);
-            const result = await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(result).toBeNull();
-        });
-        it('should handle missing account name and prompt for it', async () => {
-            mockedGlobalConfigFileExists.mockReturnValue(true);
-            mockedUpdateConfigWithAccessToken.mockResolvedValue({
-                ...mockAccountConfig,
-                name: undefined,
-            });
-            mockedCliAccountNamePrompt.mockResolvedValue({
-                name: 'new-account-name',
-            });
-            await authenticateNewAccount({
-                env: 'prod',
-                providedPersonalAccessKey: 'test-key',
-                accountId: 123456,
-            });
-            expect(mockedCliAccountNamePrompt).toHaveBeenCalledWith('test-hub');
-            expect(mockedUpdateConfigAccount).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'new-account-name',
-            }));
-        });
-        describe('config migration', () => {
-            it('should handle migration when local config exists and global does not', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(false);
-                mockedHandleMigration.mockResolvedValue(true);
-                await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(mockedHandleMigration).toHaveBeenCalled();
-                expect(mockedHandleMerge).not.toHaveBeenCalled();
-            });
-            it('should handle merge when both local and global configs exist', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(true);
-                mockedHandleMerge.mockResolvedValue(true);
-                await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(mockedHandleMerge).toHaveBeenCalled();
-                expect(mockedHandleMigration).not.toHaveBeenCalled();
-            });
-            it('should return null if migration is not confirmed', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(false);
-                mockedHandleMigration.mockResolvedValue(false);
-                const result = await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(result).toBeNull();
-            });
-            it('should return null if merge is not confirmed', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(true);
-                mockedHandleMerge.mockResolvedValue(false);
-                const result = await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(result).toBeNull();
-            });
-            it('should return null if migration throws error', async () => {
-                mockedLocalConfigFileExists.mockReturnValue(true);
-                mockedGlobalConfigFileExists.mockReturnValue(false);
-                mockedHandleMigration.mockRejectedValue(new Error('Migration failed'));
-                const result = await authenticateNewAccount({
-                    env: 'prod',
-                    providedPersonalAccessKey: 'test-key',
-                    accountId: 123456,
-                });
-                expect(result).toBeNull();
-            });
-        });
-    });
-});

package/lib/__tests__/accountTypes.test.d.ts

@@ -1 +0,0 @@
-export {};