@hubspot/cli 7.7.19-experimental.2 → 7.7.20-experimental.0

package/lib/__tests__/developerTestAccounts.test.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("@hubspot/local-dev-lib/config");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_2 = require("@hubspot/local-dev-lib/constants/config");
+const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
+const testUtils_1 = require("../testUtils");
+const errorHandlers = __importStar(require("../errorHandlers"));
+const developerTestAccounts_2 = require("../developerTestAccounts");
+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 = config_1.getAccountId;
+const mockedGetConfigAccounts = config_1.getConfigAccounts;
+const mockedFetchDeveloperTestAccounts = developerTestAccounts_1.fetchDeveloperTestAccounts;
+const APP_DEVELOPER_ACCOUNT_1 = {
+    name: 'app-developer-1',
+    accountId: 123,
+    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    env: 'prod',
+};
+const APP_DEVELOPER_ACCOUNT_2 = {
+    name: 'app-developer-2',
+    accountId: 456,
+    accountType: config_2.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: config_2.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 = (0, developerTestAccounts_2.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 = (0, developerTestAccounts_2.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 = (0, developerTestAccounts_2.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 (0, developerTestAccounts_2.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 (0, developerTestAccounts_2.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 (0, developerTestAccounts_2.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((0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1)).rejects.toThrow();
+        });
+    });
+    describe('handleDeveloperTestAccountCreateError()', () => {
+        let loggerErrorSpy;
+        let logErrorSpy;
+        beforeEach(() => {
+            loggerErrorSpy = vi.spyOn(logger_1.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 = (0, testUtils_1.mockHubSpotHttpError)('Missing scopes error', {
+                status: 403,
+                data: {
+                    message: 'Missing scopes error',
+                    category: 'MISSING_SCOPES',
+                },
+            });
+            expect(() => (0, developerTestAccounts_2.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 = (0, testUtils_1.mockHubSpotHttpError)('Portal limit reached error', {
+                status: 400,
+                data: {
+                    message: 'Portal limit reached error',
+                    errorType: 'TEST_PORTAL_LIMIT_REACHED',
+                },
+            });
+            expect(() => (0, developerTestAccounts_2.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 = (0, testUtils_1.mockHubSpotHttpError)('Some unknown error', {
+                status: 400,
+                data: {
+                    message: 'Some unknown error',
+                    category: 'SOME_UNKNOWN_ERROR',
+                },
+            });
+            expect(() => (0, developerTestAccounts_2.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,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const localDevAuth_1 = require("@hubspot/local-dev-lib/api/localDevAuth");
+const hasFeature_1 = require("../hasFeature");
+vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
+const mockedFetchEnabledFeatures = localDevAuth_1.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 (0, hasFeature_1.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 (0, hasFeature_1.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 (0, hasFeature_1.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,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const npm_1 = require("../npm");
+const package_json_1 = __importDefault(require("../../package.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_1.default.promisify = mockedPromisify(execMock);
+    });
+    describe('isGloballyInstalled()', () => {
+        it('should return true when exec is successful', async () => {
+            const actual = await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER);
+            expect(actual).toBe(true);
+            expect(execMock).toHaveBeenCalledTimes(1);
+            expect(execMock).toHaveBeenCalledWith(`${npm_1.DEFAULT_PACKAGE_MANAGER} --version`);
+        });
+        it('should return false when exec is unsuccessful', async () => {
+            execMock.mockImplementationOnce(() => {
+                throw new Error('unsuccessful');
+            });
+            util_1.default.promisify = mockedPromisify(execMock);
+            const actual = await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER);
+            expect(actual).toBe(false);
+            expect(execMock).toHaveBeenCalledTimes(1);
+            expect(execMock).toHaveBeenCalledWith(`${npm_1.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_1.default.promisify = mockedPromisify(execMock);
+            const actual = await (0, npm_1.getLatestCliVersion)();
+            expect(actual).toEqual({ latest, next });
+            expect(execMock).toHaveBeenCalledWith(`npm info ${package_json_1.default.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_1.default.promisify = mockedPromisify(execMock);
+            await expect(() => (0, npm_1.getLatestCliVersion)()).rejects.toThrow(errorMessage);
+            expect(execMock).toHaveBeenCalledWith(`npm info ${package_json_1.default.name} dist-tags --json`);
+        });
+    });
+});

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

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

package/lib/__tests__/oauth.test.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const open_1 = __importDefault(require("open"));
+const OAuth2Manager_1 = require("@hubspot/local-dev-lib/models/OAuth2Manager");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const oauth_1 = require("@hubspot/local-dev-lib/oauth");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const oauth_2 = require("../oauth");
+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_1.default;
+const mockedOAuth2Manager = OAuth2Manager_1.OAuth2Manager;
+const mockedGetAccountConfig = config_1.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_1.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_1.ENVIRONMENTS.PROD,
+            });
+            await (0, oauth_2.authenticateWithOauth)(mockAccountConfig);
+            // Verify OAuth2Manager was initialized correctly
+            expect(mockedOAuth2Manager).toHaveBeenCalledWith({
+                ...mockAccountConfig,
+                env: environments_1.ENVIRONMENTS.PROD,
+            });
+            // Verify logger was called
+            expect(logger_1.logger.log).toHaveBeenCalledWith('Authorizing');
+            // Verify OAuth tokens were added to config
+            expect(oauth_1.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((0, oauth_2.authenticateWithOauth)(invalidConfig)).rejects.toThrow('exit');
+            expect(logger_1.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 (0, oauth_2.authenticateWithOauth)(configWithoutScopes);
+            // Verify default scopes were used
+            expect(open_1.default).toHaveBeenCalledWith(expect.stringContaining(encodeURIComponent(auth_1.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 (0, oauth_2.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,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parsing_1 = require("../parsing");
+describe('lib/parsing', () => {
+    describe('parseStringToNumber', () => {
+        it('should parse valid integer strings', () => {
+            expect((0, parsing_1.parseStringToNumber)('123')).toBe(123);
+            expect((0, parsing_1.parseStringToNumber)('0')).toBe(0);
+            expect((0, parsing_1.parseStringToNumber)('-456')).toBe(-456);
+            expect((0, parsing_1.parseStringToNumber)('999')).toBe(999);
+        });
+        it('should parse strings with leading zeros', () => {
+            expect((0, parsing_1.parseStringToNumber)('007')).toBe(7);
+            expect((0, parsing_1.parseStringToNumber)('0123')).toBe(123);
+        });
+        it('should throw error for strings with leading whitespace', () => {
+            expect(() => (0, parsing_1.parseStringToNumber)('  42')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('\t123')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for invalid number strings', () => {
+            expect(() => (0, parsing_1.parseStringToNumber)('abc')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('NaN')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for strings with non-numeric characters', () => {
+            expect(() => (0, parsing_1.parseStringToNumber)('123abc')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('456def')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('12.34')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for strings with mixed content', () => {
+            expect(() => (0, parsing_1.parseStringToNumber)('123 456')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('1,234')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.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,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const polling_1 = require("../polling");
+const constants_1 = require("../constants");
+// 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: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.SUCCESS },
+            ]);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            // Fast-forward through two polling intervals
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
+            const result = await pollPromise;
+            expect(result.status).toBe(polling_1.DEFAULT_POLLING_STATES.SUCCESS);
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is ERROR', async () => {
+            const mockCallback = createMockCallback([
+                { status: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.ERROR },
+            ]);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: polling_1.DEFAULT_POLLING_STATES.ERROR,
+            });
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is FAILURE', async () => {
+            const mockCallback = createMockCallback([
+                { status: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.FAILURE },
+            ]);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: polling_1.DEFAULT_POLLING_STATES.FAILURE,
+            });
+        });
+        it('should reject when status is REVERTED', async () => {
+            const mockCallback = createMockCallback([
+                { status: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.REVERTED },
+            ]);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: polling_1.DEFAULT_POLLING_STATES.REVERTED,
+            });
+        });
+        it('should reject when callback throws an error', async () => {
+            const mockCallback = vi
+                .fn()
+                .mockRejectedValue(new Error('Network error'));
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.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,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const process_1 = require("../process");
+vi.mock('readline');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedReadline = readline_1.default;
+const mockedLogger = logger_1.logger;
+const mockedSetLogLevel = logger_1.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', () => {
+            (0, process_1.handleExit)(mockCallback);
+            process_1.TERMINATION_SIGNALS.forEach(signal => {
+                expect(processRemoveListenerSpy).toHaveBeenCalledWith(signal);
+                expect(processOnSpy).toHaveBeenCalledWith(signal, expect.any(Function));
+            });
+        });
+        it('should handle SIGHUP signal correctly', async () => {
+            (0, process_1.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(logger_1.LOG_LEVEL.NONE);
+            expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: true });
+            expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGHUP'));
+        });
+        it('should handle non-SIGHUP signals correctly', async () => {
+            (0, process_1.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 () => {
+            (0, process_1.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(() => { });
+            (0, process_1.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(),
+                },
+            });
+            (0, process_1.handleKeypress)(mockCallback);
+            expect(process.stdin.setRawMode).toBeUndefined();
+        });
+    });
+});

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

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