@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/lib/CLIWebSocketServer.d.ts

@@ -0,0 +1,28 @@
+import { WebSocket } from 'ws';
+export type CLIWebSocketMessage = {
+    type: string;
+    data?: unknown;
+};
+declare class CLIWebSocketServer {
+    private server?;
+    private instanceId;
+    private logPrefix?;
+    private debug?;
+    constructor({ instanceId, logPrefix, debug, }: {
+        instanceId: string;
+        logPrefix?: string;
+        debug?: boolean;
+    });
+    private log;
+    private logError;
+    sendMessage(websocket: WebSocket, message: CLIWebSocketMessage): void;
+    private sendCliMetadata;
+    start({ onConnection, onMessage, onClose, metadata, }: {
+        onConnection?: (websocket: WebSocket) => void;
+        onMessage?: (websocket: WebSocket, message: CLIWebSocketMessage) => boolean;
+        onClose?: () => void;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    shutdown(): void;
+}
+export default CLIWebSocketServer;

package/lib/CLIWebSocketServer.js

@@ -0,0 +1,91 @@
+import { WebSocketServer } from 'ws';
+import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
+import { pkg } from './jsonLoader.js';
+const DOMAINS = ['hubspot.com', 'hubspotqa.com'];
+const SUBDOMAINS = ['local', 'app', 'app-na2', 'app-na3', 'app-ap1', 'app-eu1'];
+const ALLOWED_ORIGIN_REGEX = new RegExp(`^https://(${SUBDOMAINS.join('|')})\\.(${DOMAINS.join('|')})$`);
+const CLI_METADATA_MESSAGE_TYPE = 'server:cliMetadata';
+class CLIWebSocketServer {
+    server;
+    instanceId;
+    logPrefix;
+    debug;
+    constructor({ instanceId, logPrefix, debug, }) {
+        this.instanceId = instanceId;
+        this.logPrefix = logPrefix;
+        this.debug = debug;
+    }
+    log(message) {
+        if (this.debug) {
+            uiLogger.log(`${this.logPrefix} ${message}`);
+        }
+    }
+    logError(message) {
+        if (this.debug) {
+            uiLogger.error(`${this.logPrefix} ${message}`);
+        }
+    }
+    sendMessage(websocket, message) {
+        websocket.send(JSON.stringify(message));
+    }
+    sendCliMetadata(websocket, metadata) {
+        this.sendMessage(websocket, {
+            type: CLI_METADATA_MESSAGE_TYPE,
+            data: {
+                cliVersion: pkg.version,
+                ...metadata,
+            },
+        });
+    }
+    async start({ onConnection, onMessage, onClose, metadata, }) {
+        const portManagerIsRunning = await isPortManagerServerRunning();
+        if (!portManagerIsRunning) {
+            throw new Error(lib.CLIWebsocketServer.errors.portManagerNotRunning(this.logPrefix));
+        }
+        const portData = await requestPorts([{ instanceId: this.instanceId }]);
+        const port = portData[this.instanceId];
+        this.server = new WebSocketServer({ port });
+        this.log(lib.CLIWebsocketServer.logs.startup(port));
+        this.server.on('connection', (ws, req) => {
+            const origin = req.headers.origin;
+            if (!origin || !ALLOWED_ORIGIN_REGEX.test(origin)) {
+                ws.close(1008, lib.CLIWebsocketServer.errors.originNotAllowed(origin));
+                return;
+            }
+            this.sendCliMetadata(ws, metadata);
+            if (onConnection) {
+                onConnection(ws);
+            }
+            ws.on('message', data => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (!message.type) {
+                        this.logError(lib.CLIWebsocketServer.errors.missingTypeField(data.toString()));
+                        return;
+                    }
+                    if (onMessage) {
+                        const messageHandled = onMessage(ws, message);
+                        if (!messageHandled) {
+                            this.logError(lib.CLIWebsocketServer.errors.unknownMessageType(message.type));
+                        }
+                    }
+                }
+                catch (e) {
+                    this.logError(lib.CLIWebsocketServer.errors.invalidJSON(data.toString()));
+                }
+            });
+        });
+        this.server.on('close', () => {
+            if (onClose) {
+                onClose();
+            }
+        });
+    }
+    shutdown() {
+        this.server?.close();
+        this.server = undefined;
+    }
+}
+export default CLIWebSocketServer;

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

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

package/lib/__tests__/CLIWebSocketServer.test.js

@@ -0,0 +1,252 @@
+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

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

package/lib/__tests__/accountAuth.test.js

@@ -0,0 +1,258 @@
+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

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