@hubspot/cli 8.0.1-experimental.0 → 8.0.3-experimental.0

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__/commandSuggestion.test.d.ts

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

package/lib/__tests__/commandSuggestion.test.js

@@ -0,0 +1,119 @@
+import yargs from 'yargs';
+import { addCommandSuggestions, commandSuggestionMappings, } from '../commandSuggestion.js';
+import { uiLogger } from '../ui/logger.js';
+import { uiCommandReference } from '../ui/index.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+vi.mock('../ui/logger.js');
+vi.mock('../ui/index.js');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+describe('lib/commandSuggestion', () => {
+    const uiLoggerErrorMock = uiLogger.error;
+    const uiCommandReferenceMock = uiCommandReference;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        commandSpy.mockClear();
+        uiCommandReferenceMock.mockImplementation((command) => `\`${command}\``);
+    });
+    describe('addCommandSuggestions', () => {
+        it('adds all command suggestions to yargs instance', () => {
+            addCommandSuggestions(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(Object.keys(commandSuggestionMappings).length);
+        });
+        it('registers each mapping from commandSuggestionMappings', () => {
+            addCommandSuggestions(yargs);
+            Object.entries(commandSuggestionMappings).forEach(([oldCommand]) => {
+                expect(commandSpy).toHaveBeenCalledWith(expect.objectContaining({
+                    command: oldCommand,
+                }));
+            });
+        });
+        it('returns the yargs instance', () => {
+            const yargsInstance = yargs;
+            const result = addCommandSuggestions(yargsInstance);
+            expect(result).toBe(yargsInstance);
+        });
+        it('creates command modules with handler that logs error and exits', () => {
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
+            });
+            addCommandSuggestions(yargs);
+            // Get the first registered command module
+            const firstCall = commandSpy.mock.calls[0];
+            const commandModule = firstCall[0];
+            const firstMapping = Object.entries(commandSuggestionMappings)[0];
+            const [, newCommand] = firstMapping;
+            // Verify the command module structure
+            expect(commandModule).toHaveProperty('command');
+            expect(commandModule).toHaveProperty('handler');
+            expect(commandModule).toHaveProperty('builder');
+            // Invoke the handler to verify behavior
+            expect(() => {
+                commandModule.handler({});
+            }).toThrow('process.exit called');
+            expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
+            expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            vi.restoreAllMocks();
+        });
+        it('creates command modules with builder that sets strict mode to false', async () => {
+            const yargsInstance = yargs;
+            const commandSpyForTest = vi
+                .spyOn(yargsInstance, 'command')
+                .mockReturnValue(yargsInstance);
+            addCommandSuggestions(yargsInstance);
+            // Get a command module and verify it has a builder
+            const firstCall = commandSpyForTest.mock.calls[0];
+            const commandModule = firstCall[0];
+            expect(commandModule).toHaveProperty('builder');
+            expect(typeof commandModule.builder).toBe('function');
+            // Create a mock yargs builder with strict method
+            const mockYargsBuilder = {
+                strict: vi.fn().mockReturnThis(),
+            };
+            await commandModule.builder(mockYargsBuilder);
+            expect(mockYargsBuilder.strict).toHaveBeenCalledWith(false);
+            commandSpyForTest.mockRestore();
+        });
+        it('handles commands with multiple words', () => {
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
+            });
+            // Find a multi-word command
+            const multiWordCommand = Object.entries(commandSuggestionMappings).find(([oldCommand]) => oldCommand.includes(' '));
+            expect(multiWordCommand).toBeDefined();
+            if (multiWordCommand) {
+                const [oldCommand, newCommand] = multiWordCommand;
+                const yargsInstance = yargs;
+                const commandSpyForTest = vi
+                    .spyOn(yargsInstance, 'command')
+                    .mockReturnValue(yargsInstance);
+                addCommandSuggestions(yargsInstance);
+                // Find the call for this multi-word command
+                const call = commandSpyForTest.mock.calls.find(call => call[0]
+                    .command === oldCommand);
+                expect(call).toBeDefined();
+                const commandModule = call[0];
+                expect(commandModule).toHaveProperty('handler');
+                // Invoke handler to verify it works with multi-word commands
+                expect(() => {
+                    commandModule.handler({});
+                }).toThrow('process.exit called');
+                expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
+                commandSpyForTest.mockRestore();
+            }
+            vi.restoreAllMocks();
+        });
+    });
+    describe('commandSuggestionMappings', () => {
+        it('all mappings point to valid new commands', () => {
+            Object.entries(commandSuggestionMappings).forEach(([, newCommand]) => {
+                expect(newCommand).toMatch(/^hs /);
+                expect(typeof newCommand).toBe('string');
+                expect(newCommand.length).toBeGreaterThan(0);
+            });
+        });
+    });
+});

package/lib/accountAuth.d.ts

@@ -0,0 +1,10 @@
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+type AuthenticateNewAccountOptions = {
+    env: Environment;
+    providedPersonalAccessKey?: string;
+    accountId?: number;
+    setAsDefaultAccount?: boolean;
+};
+export declare function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, }: AuthenticateNewAccountOptions): Promise<HubSpotConfigAccount | null>;
+export {};