@hubspot/cli 7.7.19-experimental.3 → 7.7.21-experimental.0

package/lib/__tests__/developerTestAccounts.test.js

@@ -0,0 +1,145 @@
+import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { mockHubSpotHttpError } from '../testUtils.js';
+import * as errorHandlers from '../errorHandlers/index.js';
+import { getHasDevTestAccounts, handleDeveloperTestAccountCreateError, validateDevTestAccountUsageLimits, } from '../developerTestAccounts.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/developerTestAccounts');
+vi.mock('../errorHandlers');
+const mockedGetAccountId = getAccountId;
+const mockedGetConfigAccounts = getConfigAccounts;
+const mockedFetchDeveloperTestAccounts = fetchDeveloperTestAccounts;
+const APP_DEVELOPER_ACCOUNT_1 = {
+    name: 'app-developer-1',
+    accountId: 123,
+    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    env: 'prod',
+};
+const APP_DEVELOPER_ACCOUNT_2 = {
+    name: 'app-developer-2',
+    accountId: 456,
+    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    env: 'prod',
+};
+const accounts = [
+    APP_DEVELOPER_ACCOUNT_1,
+    APP_DEVELOPER_ACCOUNT_2,
+    {
+        name: 'test-account',
+        accountId: 789,
+        parentAccountId: APP_DEVELOPER_ACCOUNT_1.accountId,
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        env: 'prod',
+    },
+];
+describe('lib/developerTestAccounts', () => {
+    describe('getHasDevTestAccounts()', () => {
+        it('should return true if there are developer test accounts associated with the account', () => {
+            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            mockedGetConfigAccounts.mockReturnValueOnce(accounts);
+            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
+            expect(result).toBe(true);
+        });
+        it('should return false if there are no developer test accounts associated with the account', () => {
+            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_2.accountId);
+            mockedGetConfigAccounts.mockReturnValueOnce(accounts);
+            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_2);
+            expect(result).toBe(false);
+        });
+        it('should return false if there are no accounts configured', () => {
+            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            mockedGetConfigAccounts.mockReturnValueOnce(undefined);
+            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
+            expect(result).toBe(false);
+        });
+    });
+    describe('validateDevTestAccountUsageLimits()', () => {
+        afterEach(() => {
+            mockedGetAccountId.mockRestore();
+            mockedFetchDeveloperTestAccounts.mockRestore();
+        });
+        it('should return null if the account id is not found', async () => {
+            mockedGetAccountId.mockReturnValueOnce(undefined);
+            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            expect(result).toBe(null);
+        });
+        it('should return null if there is no developer test account data', async () => {
+            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: null,
+            });
+            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            expect(result).toBe(null);
+        });
+        it('should return the test account data if the account has not reached the limit', async () => {
+            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            const testAccountData = {
+                maxTestPortals: 10,
+                results: [],
+            };
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: testAccountData,
+            });
+            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            expect(result).toEqual(expect.objectContaining(testAccountData));
+        });
+        it('should throw an error if the account has reached the limit', async () => {
+            mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: {
+                    maxTestPortals: 0,
+                    results: [{}],
+                },
+            });
+            await expect(validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1)).rejects.toThrow();
+        });
+    });
+    describe('handleDeveloperTestAccountCreateError()', () => {
+        let loggerErrorSpy;
+        let logErrorSpy;
+        beforeEach(() => {
+            loggerErrorSpy = vi.spyOn(logger, 'error');
+            logErrorSpy = vi.spyOn(errorHandlers, 'logError');
+        });
+        afterEach(() => {
+            loggerErrorSpy.mockRestore();
+            logErrorSpy.mockRestore();
+        });
+        it('should log and throw an error if the account is missing the required scopes', () => {
+            const missingScopesError = mockHubSpotHttpError('Missing scopes error', {
+                status: 403,
+                data: {
+                    message: 'Missing scopes error',
+                    category: 'MISSING_SCOPES',
+                },
+            });
+            expect(() => handleDeveloperTestAccountCreateError(missingScopesError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Missing scopes error');
+            expect(loggerErrorSpy).toHaveBeenCalled();
+        });
+        it('should log and throw an error if the account is missing the required scopes', () => {
+            const portalLimitReachedError = mockHubSpotHttpError('Portal limit reached error', {
+                status: 400,
+                data: {
+                    message: 'Portal limit reached error',
+                    errorType: 'TEST_PORTAL_LIMIT_REACHED',
+                },
+            });
+            expect(() => handleDeveloperTestAccountCreateError(portalLimitReachedError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Portal limit reached error');
+            expect(loggerErrorSpy).toHaveBeenCalled();
+        });
+        it('should log a generic error message for an unknown error type', () => {
+            const someUnknownError = mockHubSpotHttpError('Some unknown error', {
+                status: 400,
+                data: {
+                    message: 'Some unknown error',
+                    category: 'SOME_UNKNOWN_ERROR',
+                },
+            });
+            expect(() => handleDeveloperTestAccountCreateError(someUnknownError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Some unknown error');
+            expect(logErrorSpy).toHaveBeenCalled();
+        });
+    });
+});

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

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

package/lib/__tests__/hasFeature.test.js

@@ -0,0 +1,35 @@
+import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { hasFeature } from '../hasFeature.js';
+vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
+const mockedFetchEnabledFeatures = fetchEnabledFeatures;
+describe('lib/hasFeature', () => {
+    describe('hasFeature()', () => {
+        const accountId = 123;
+        beforeEach(() => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-1': true,
+                        'feature-2': false,
+                        'feature-3': true,
+                    },
+                },
+            });
+        });
+        it('should return true if the feature is enabled', async () => {
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-1');
+            expect(result).toBe(true);
+        });
+        it('should return false if the feature is not enabled', async () => {
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-2');
+            expect(result).toBe(false);
+        });
+        it('should return false if the feature is not present', async () => {
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-4');
+            expect(result).toBe(false);
+        });
+    });
+});

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

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

package/lib/__tests__/npm.test.js

@@ -0,0 +1,57 @@
+import util from 'util';
+import { isGloballyInstalled, getLatestCliVersion, DEFAULT_PACKAGE_MANAGER, } from '../npm.js';
+import pkg from '../../package.json' with { type: 'json' };
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../ui/SpinniesManager');
+describe('lib/npm', () => {
+    let execMock;
+    function mockedPromisify(execMock) {
+        return vi
+            .fn()
+            .mockReturnValue(execMock);
+    }
+    beforeEach(() => {
+        execMock = vi.fn();
+        util.promisify = mockedPromisify(execMock);
+    });
+    describe('isGloballyInstalled()', () => {
+        it('should return true when exec is successful', async () => {
+            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
+            expect(actual).toBe(true);
+            expect(execMock).toHaveBeenCalledTimes(1);
+            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
+        });
+        it('should return false when exec is unsuccessful', async () => {
+            execMock.mockImplementationOnce(() => {
+                throw new Error('unsuccessful');
+            });
+            util.promisify = mockedPromisify(execMock);
+            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
+            expect(actual).toBe(false);
+            expect(execMock).toHaveBeenCalledTimes(1);
+            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
+        });
+    });
+    describe('getLatestCliVersion()', () => {
+        it('should return the version correctly', async () => {
+            const latest = '1.0.0';
+            const next = '1.0.0.beta.1';
+            execMock.mockResolvedValueOnce({
+                stdout: JSON.stringify({ latest, next }),
+            });
+            util.promisify = mockedPromisify(execMock);
+            const actual = await getLatestCliVersion();
+            expect(actual).toEqual({ latest, next });
+            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+        });
+        it('should throw any errors that encounter with the check', async () => {
+            const errorMessage = 'unsuccessful';
+            execMock.mockImplementationOnce(() => {
+                throw new Error(errorMessage);
+            });
+            util.promisify = mockedPromisify(execMock);
+            await expect(() => getLatestCliVersion()).rejects.toThrow(errorMessage);
+            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+        });
+    });
+});

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

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

package/lib/__tests__/oauth.test.js

@@ -0,0 +1,108 @@
+import express from 'express';
+import open from 'open';
+import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
+import { authenticateWithOauth } from '../oauth.js';
+vi.mock('express');
+vi.mock('open');
+vi.mock('@hubspot/local-dev-lib/models/OAuth2Manager');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/oauth');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedExpress = express;
+const mockedOAuth2Manager = OAuth2Manager;
+const mockedGetAccountConfig = getAccountConfig;
+describe('lib/oauth', () => {
+    const mockExpressReq = {
+        query: { code: 'test-auth-code' },
+    };
+    const mockExpressResp = { send: vi.fn() };
+    const mockAccountConfig = {
+        accountId: 123,
+        clientId: 'test-client-id',
+        clientSecret: 'test-client-secret',
+        scopes: ['test-scope'],
+        env: ENVIRONMENTS.PROD,
+    };
+    beforeEach(() => {
+        mockedExpress.mockReturnValue({
+            get: vi.fn().mockImplementation((path, callback) => {
+                if (path === '/oauth-callback') {
+                    callback(mockExpressReq, mockExpressResp);
+                }
+            }),
+            listen: vi.fn().mockReturnValue({ close: vi.fn() }),
+        });
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('authenticateWithOauth()', () => {
+        it('should setup OAuth and authenticate successfully', async () => {
+            // Mock successful OAuth flow
+            const mockOAuth2Manager = {
+                account: mockAccountConfig,
+                exchangeForTokens: vi.fn().mockResolvedValue({}),
+            };
+            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
+            mockedGetAccountConfig.mockReturnValue({
+                env: ENVIRONMENTS.PROD,
+            });
+            await authenticateWithOauth(mockAccountConfig);
+            // Verify OAuth2Manager was initialized correctly
+            expect(mockedOAuth2Manager).toHaveBeenCalledWith({
+                ...mockAccountConfig,
+                env: ENVIRONMENTS.PROD,
+            });
+            // Verify logger was called
+            expect(logger.log).toHaveBeenCalledWith('Authorizing');
+            // Verify OAuth tokens were added to config
+            expect(addOauthToAccountConfig).toHaveBeenCalledWith(mockOAuth2Manager);
+        });
+        it('should handle missing clientId', async () => {
+            const invalidConfig = {
+                ...mockAccountConfig,
+                clientId: undefined,
+            };
+            mockedOAuth2Manager.mockImplementation(() => ({
+                account: invalidConfig,
+            }));
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error('exit');
+            });
+            await expect(authenticateWithOauth(invalidConfig)).rejects.toThrow('exit');
+            expect(logger.error).toHaveBeenCalled();
+            expect(exitSpy).toHaveBeenCalled();
+            exitSpy.mockRestore();
+        });
+        it('should use default scopes when none provided', async () => {
+            const configWithoutScopes = {
+                ...mockAccountConfig,
+                scopes: undefined,
+            };
+            const mockOAuth2Manager = {
+                account: configWithoutScopes,
+                exchangeForTokens: vi.fn().mockResolvedValue({}),
+            };
+            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
+            await authenticateWithOauth(configWithoutScopes);
+            // Verify default scopes were used
+            expect(open).toHaveBeenCalledWith(expect.stringContaining(encodeURIComponent(DEFAULT_OAUTH_SCOPES.join(' '))), expect.anything());
+        });
+        it('should handle OAuth exchange failure', async () => {
+            const mockOAuth2Manager = {
+                account: mockAccountConfig,
+                exchangeForTokens: vi
+                    .fn()
+                    .mockRejectedValue(new Error('Exchange failed')),
+            };
+            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
+            await authenticateWithOauth(mockAccountConfig);
+            expect(mockExpressResp.send).toHaveBeenCalledWith(expect.stringContaining('Authorization failed'));
+        });
+    });
+});

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

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

package/lib/__tests__/parsing.test.js

@@ -0,0 +1,34 @@
+import { parseStringToNumber } from '../parsing.js';
+describe('lib/parsing', () => {
+    describe('parseStringToNumber', () => {
+        it('should parse valid integer strings', () => {
+            expect(parseStringToNumber('123')).toBe(123);
+            expect(parseStringToNumber('0')).toBe(0);
+            expect(parseStringToNumber('-456')).toBe(-456);
+            expect(parseStringToNumber('999')).toBe(999);
+        });
+        it('should parse strings with leading zeros', () => {
+            expect(parseStringToNumber('007')).toBe(7);
+            expect(parseStringToNumber('0123')).toBe(123);
+        });
+        it('should throw error for strings with leading whitespace', () => {
+            expect(() => parseStringToNumber('  42')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('\t123')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for invalid number strings', () => {
+            expect(() => parseStringToNumber('abc')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('NaN')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for strings with non-numeric characters', () => {
+            expect(() => parseStringToNumber('123abc')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('456def')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('12.34')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for strings with mixed content', () => {
+            expect(() => parseStringToNumber('123 456')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('1,234')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('1.23e4')).toThrow('Unable to parse string to number');
+        });
+    });
+});

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

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

package/lib/__tests__/polling.test.js

@@ -0,0 +1,76 @@
+import { poll, DEFAULT_POLLING_STATES } from '../polling.js';
+import { DEFAULT_POLLING_DELAY } from '../constants.js';
+// Helper to create a mock polling callback
+const createMockCallback = (responses) => {
+    let callCount = 0;
+    return vi.fn(() => {
+        const response = responses[callCount];
+        callCount++;
+        return Promise.resolve({ data: response });
+    });
+};
+describe('lib/polling', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('poll()', () => {
+        it('should resolve when status is SUCCESS', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.SUCCESS },
+            ]);
+            const pollPromise = poll(mockCallback);
+            // Fast-forward through two polling intervals
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            const result = await pollPromise;
+            expect(result.status).toBe(DEFAULT_POLLING_STATES.SUCCESS);
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is ERROR', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.ERROR },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.ERROR,
+            });
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is FAILURE', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.FAILURE },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.FAILURE,
+            });
+        });
+        it('should reject when status is REVERTED', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.REVERTED },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.REVERTED,
+            });
+        });
+        it('should reject when callback throws an error', async () => {
+            const mockCallback = vi
+                .fn()
+                .mockRejectedValue(new Error('Network error'));
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY);
+            await expect(pollPromise).rejects.toThrow('Network error');
+            expect(mockCallback).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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

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

package/lib/__tests__/process.test.js

@@ -0,0 +1,85 @@
+import readline from 'readline';
+import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
+import { handleExit, handleKeypress, TERMINATION_SIGNALS } from '../process.js';
+vi.mock('readline');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedReadline = readline;
+const mockedLogger = logger;
+const mockedSetLogLevel = setLogLevel;
+const processRemoveListenerSpy = vi.spyOn(process, 'removeAllListeners');
+const processOnSpy = vi.spyOn(process, 'on');
+describe('lib/process', () => {
+    describe('handleExit()', () => {
+        const mockCallback = vi.fn();
+        it('should set up listeners for all termination signals', () => {
+            handleExit(mockCallback);
+            TERMINATION_SIGNALS.forEach(signal => {
+                expect(processRemoveListenerSpy).toHaveBeenCalledWith(signal);
+                expect(processOnSpy).toHaveBeenCalledWith(signal, expect.any(Function));
+            });
+        });
+        it('should handle SIGHUP signal correctly', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGHUP
+            const sighupCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGHUP')?.[1];
+            expect(sighupCallback).toBeDefined();
+            sighupCallback();
+            expect(mockedSetLogLevel).toHaveBeenCalledWith(LOG_LEVEL.NONE);
+            expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: true });
+            expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGHUP'));
+        });
+        it('should handle non-SIGHUP signals correctly', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGINT
+            const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
+            expect(sigintCallback).toBeDefined();
+            sigintCallback();
+            expect(mockedSetLogLevel).not.toHaveBeenCalled();
+            expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: false });
+            expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGINT'));
+        });
+        it('should prevent duplicate exit handling', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGINT
+            const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
+            expect(sigintCallback).toBeDefined();
+            sigintCallback();
+            sigintCallback(); // Second call should be ignored
+            expect(mockCallback).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('handleKeypress()', () => {
+        const mockCallback = vi.fn();
+        it('should set up keypress handling correctly', () => {
+            // Mock process.stdin
+            Object.defineProperty(process, 'stdin', {
+                value: {
+                    isTTY: true,
+                    setRawMode: vi.fn(),
+                    on: vi.fn(),
+                    removeAllListeners: vi.fn(),
+                },
+            });
+            mockedReadline.createInterface.mockReturnValue({});
+            mockedReadline.emitKeypressEvents.mockImplementation(() => { });
+            handleKeypress(mockCallback);
+            expect(mockedReadline.createInterface).toHaveBeenCalledWith(process.stdin, process.stdout);
+            expect(mockedReadline.emitKeypressEvents).toHaveBeenCalledWith(process.stdin);
+            expect(process.stdin.setRawMode).toHaveBeenCalledWith(true);
+            expect(process.stdin.removeAllListeners).toHaveBeenCalledWith('keypress');
+            expect(process.stdin.on).toHaveBeenCalledWith('keypress', expect.any(Function));
+        });
+        it('should not set raw mode when stdin is not TTY', () => {
+            // Mock process.stdin as non-TTY
+            Object.defineProperty(process, 'stdin', {
+                value: {
+                    isTTY: false,
+                    on: vi.fn(),
+                    removeAllListeners: vi.fn(),
+                },
+            });
+            handleKeypress(mockCallback);
+            expect(process.stdin.setRawMode).toBeUndefined();
+        });
+    });
+});

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

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