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

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

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

package/lib/__tests__/developerTestAccounts.test.js

@@ -0,0 +1,156 @@
+import { getAllConfigAccounts, getConfigAccountIfExists, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
+import { uiLogger } from '../ui/logger.js';
+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';
+import { logError } from '../errorHandlers/index.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/api/developerTestAccounts');
+vi.mock('../errorHandlers');
+const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
+const mockedGetAllConfigAccounts = getAllConfigAccounts;
+const mockedGetConfigAccountById = getConfigAccountById;
+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',
+        authType: 'personalaccesskey',
+    },
+];
+describe('lib/developerTestAccounts', () => {
+    describe('getHasDevTestAccounts()', () => {
+        it('should return true if there are developer test accounts associated with the account', () => {
+            mockedGetAllConfigAccounts.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', () => {
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_2);
+            mockedGetAllConfigAccounts.mockReturnValueOnce(accounts);
+            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_2);
+            expect(result).toBe(false);
+        });
+        it('should return false if there are no accounts configured', () => {
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
+            mockedGetAllConfigAccounts.mockReturnValueOnce(undefined);
+            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
+            expect(result).toBe(false);
+        });
+    });
+    describe('validateDevTestAccountUsageLimits()', () => {
+        afterEach(() => {
+            mockedGetConfigAccountIfExists.mockRestore();
+            mockedFetchDeveloperTestAccounts.mockRestore();
+        });
+        it('should return null if the account id is not found', async () => {
+            mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
+                data: null,
+            });
+            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 () => {
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
+            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 () => {
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
+            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 () => {
+            mockedGetConfigAccountIfExists.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1);
+            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(uiLogger, 'error');
+            logErrorSpy = vi.spyOn(errorHandlers, 'logError');
+            // Mock account config for uiAccountDescription calls
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: APP_DEVELOPER_ACCOUNT_1.accountId,
+                name: 'Test Account',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'test-key',
+                env: 'prod',
+            });
+        });
+        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(uiLogger.error).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(uiLogger.error).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(logError).toHaveBeenCalled();
+        });
+    });
+});

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

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

package/lib/__tests__/hasFeature.test.js

@@ -0,0 +1,167 @@
+import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { http } from '@hubspot/local-dev-lib/http';
+import { hasFeature, hasUnfiedAppsAccess } from '../hasFeature.js';
+import { FEATURES } from '../constants.js';
+vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
+vi.mock('@hubspot/local-dev-lib/http');
+const mockedFetchEnabledFeatures = fetchEnabledFeatures;
+const mockedHttp = http;
+describe('lib/hasFeature', () => {
+    describe('hasFeature()', () => {
+        const accountId = 123;
+        it('should return true if the feature is enabled', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-1': true,
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-1');
+            expect(result).toBe(true);
+        });
+        it('should return false if the feature is disabled', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-2': false,
+                    },
+                },
+            });
+            // @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 () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {},
+                },
+            });
+            // @ts-expect-error test data
+            const result = await hasFeature(accountId, 'feature-4');
+            expect(result).toBe(false);
+        });
+        it('should return true for APPS_HOME feature when not present in enabled features (defaults on)', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {},
+                },
+            });
+            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
+            expect(result).toBe(true);
+        });
+        it('should respect explicit setting for APPS_HOME feature even when it defaults on', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        [FEATURES.APPS_HOME]: false,
+                    },
+                },
+            });
+            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
+            expect(result).toBe(false);
+        });
+        it('should handle truthy values correctly', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-truthy': 'yes',
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const truthyResult = await hasFeature(accountId, 'feature-truthy');
+            expect(truthyResult).toBe(true);
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-number': 1,
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const numberResult = await hasFeature(accountId, 'feature-number');
+            expect(numberResult).toBe(true);
+        });
+        it('should handle falsy values correctly', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-null': null,
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const nullResult = await hasFeature(accountId, 'feature-null');
+            expect(nullResult).toBe(false);
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-zero': 0,
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const zeroResult = await hasFeature(accountId, 'feature-zero');
+            expect(zeroResult).toBe(false);
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-empty': '',
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const emptyResult = await hasFeature(accountId, 'feature-empty');
+            expect(emptyResult).toBe(false);
+        });
+        it('should propagate errors from fetchEnabledFeatures', async () => {
+            const error = new Error('API error');
+            mockedFetchEnabledFeatures.mockRejectedValueOnce(error);
+            await expect(hasFeature(accountId, FEATURES.UNIFIED_APPS)).rejects.toThrow('API error');
+        });
+    });
+    describe('hasUnfiedAppsAccess()', () => {
+        const accountId = 123;
+        it('should return true when API returns true', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: true });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(true);
+            expect(mockedHttp.get).toHaveBeenCalledWith(accountId, {
+                url: 'developer-tooling/external/developer-portal/has-unified-dev-platform-access',
+            });
+        });
+        it('should return false when API returns false', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: false });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(false);
+        });
+        it('should handle truthy values correctly', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: 'yes' });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(true);
+        });
+        it('should handle falsy values correctly', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: null });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(false);
+        });
+        it('should handle undefined response data', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: undefined });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(false);
+        });
+        it('should propagate errors from http.get', async () => {
+            const error = new Error('Network error');
+            mockedHttp.get.mockRejectedValueOnce(error);
+            await expect(hasUnfiedAppsAccess(accountId)).rejects.toThrow('Network error');
+        });
+    });
+});

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

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

package/lib/__tests__/http.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import http from 'http';
+import { isServerRunningAtUrl } from '../http.js';
+describe('isServerRunningAtUrl', () => {
+    let server;
+    let serverPort;
+    beforeAll(async () => {
+        server = http.createServer((req, res) => {
+            res.writeHead(200);
+            res.end('OK');
+        });
+        await new Promise(resolve => {
+            server.listen(0, () => {
+                serverPort = server.address().port;
+                resolve();
+            });
+        });
+    });
+    afterAll(async () => {
+        await new Promise(resolve => {
+            server.close(() => resolve());
+        });
+    });
+    it('should return true when a server is running', async () => {
+        const result = await isServerRunningAtUrl(`http://localhost:${serverPort}`);
+        expect(result).toBe(true);
+    });
+    it('should return false when connection is refused', async () => {
+        const result = await isServerRunningAtUrl('http://localhost:59999');
+        expect(result).toBe(false);
+    });
+    it('should return false for invalid URLs', async () => {
+        const result = await isServerRunningAtUrl('not-a-valid-url');
+        expect(result).toBe(false);
+    });
+    it('should handle different paths on the same server', async () => {
+        const result = await isServerRunningAtUrl(`http://localhost:${serverPort}/some/path`);
+        expect(result).toBe(true);
+    });
+});

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

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

package/lib/__tests__/importData.test.js

@@ -0,0 +1,98 @@
+import { uiLogger } from '../ui/logger.js';
+import { createImport } from '@hubspot/local-dev-lib/api/crm';
+import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { handleImportData, handleTargetTestAccountSelectionFlow, } from '../importData.js';
+import { lib } from '../../lang/en.js';
+import { isDeveloperTestAccount, isStandardAccount, isAppDeveloperAccount, } from '../accountTypes.js';
+import { importDataTestAccountSelectPrompt } from '../prompts/importDataTestAccountSelectPrompt.js';
+vi.mock('@hubspot/local-dev-lib/api/crm');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../accountTypes');
+vi.mock('../prompts/importDataTestAccountSelectPrompt');
+describe('lib/importData', () => {
+    const mockUiLogger = vi.mocked(uiLogger);
+    const mockCreateImport = vi.mocked(createImport);
+    const mockGetConfigAccountById = vi.mocked(getConfigAccountById);
+    const mockGetConfigAccountIfExists = vi.mocked(getConfigAccountIfExists);
+    const mockIsDeveloperTestAccount = vi.mocked(isDeveloperTestAccount);
+    const mockIsStandardAccount = vi.mocked(isStandardAccount);
+    const mockIsAppDeveloperAccount = vi.mocked(isAppDeveloperAccount);
+    const mockImportDataTestAccountSelectPrompt = vi.mocked(importDataTestAccountSelectPrompt);
+    beforeEach(() => {
+        mockUiLogger.info.mockReset();
+        mockUiLogger.success.mockReset();
+        mockUiLogger.error.mockReset();
+        mockCreateImport.mockReset();
+        mockGetConfigAccountById.mockReset();
+        mockGetConfigAccountIfExists.mockReset();
+        mockIsDeveloperTestAccount.mockReset();
+        mockIsStandardAccount.mockReset();
+        mockIsAppDeveloperAccount.mockReset();
+        mockImportDataTestAccountSelectPrompt.mockReset();
+    });
+    describe('handleImportData', () => {
+        const targetAccountId = 123456789;
+        const dataFileNames = ['test-file.json'];
+        const importRequest = {
+            name: 'test-import',
+        };
+        it('should log the correct success message', async () => {
+            // @ts-expect-error - mockCreateImport is not typed correctly
+            mockCreateImport.mockResolvedValue({
+                data: { id: '123' },
+            });
+            await handleImportData(targetAccountId, dataFileNames, importRequest);
+            expect(mockUiLogger.info).toHaveBeenCalledWith(lib.importData.viewImportLink('https://app.hubspot.com', targetAccountId, '123'));
+        });
+        it('should log the correct error message', async () => {
+            mockCreateImport.mockRejectedValue(new Error('test-error'));
+            // weird because we catch the error, log a specific message, and then throw it again
+            await expect(handleImportData(targetAccountId, dataFileNames, importRequest)).rejects.toThrow('test-error');
+            expect(mockUiLogger.error).toHaveBeenCalledWith(lib.importData.errors.failedToImportData);
+        });
+    });
+    describe('handleTargetTestAccountSelectionFlow', () => {
+        const userProvidedAccountId = '1234';
+        const derivedAccountId = 123456789;
+        it('should error if the userProvidedAccountId is not the right account type', async () => {
+            mockGetConfigAccountIfExists.mockReturnValue({
+                accountId: 1234,
+            });
+            mockIsDeveloperTestAccount.mockReturnValue(false);
+            await expect(handleTargetTestAccountSelectionFlow(derivedAccountId, userProvidedAccountId)).rejects.toThrow(lib.importData.errors.notDeveloperTestAccount);
+        });
+        it('should error if the derivedAccountId belongs to the wrong account type', async () => {
+            mockGetConfigAccountIfExists.mockReturnValue({
+                accountId: derivedAccountId,
+            });
+            mockGetConfigAccountById.mockReturnValue({
+                accountId: derivedAccountId,
+            });
+            mockIsDeveloperTestAccount.mockReturnValue(false);
+            mockIsStandardAccount.mockReturnValue(false);
+            mockIsAppDeveloperAccount.mockReturnValue(false);
+            await expect(handleTargetTestAccountSelectionFlow(derivedAccountId, undefined)).rejects.toThrow(lib.importData.errors.incorrectAccountType(derivedAccountId));
+        });
+        it('should return the derivedAccountId if it is a developer test account', async () => {
+            mockIsDeveloperTestAccount.mockReturnValue(true);
+            mockGetConfigAccountById.mockReturnValue({
+                accountId: derivedAccountId,
+            });
+            const result = await handleTargetTestAccountSelectionFlow(derivedAccountId, undefined);
+            expect(result).toBe(derivedAccountId);
+        });
+        it('should return the result of the importDataTestAccountSelectPrompt if the derivedAccountId is a standard or app developer account', async () => {
+            mockIsDeveloperTestAccount.mockReturnValue(false);
+            mockIsStandardAccount.mockReturnValue(true);
+            mockIsAppDeveloperAccount.mockReturnValue(true);
+            mockImportDataTestAccountSelectPrompt.mockResolvedValue({
+                selectedAccountId: 890223,
+            });
+            mockGetConfigAccountById.mockReturnValue({
+                accountId: derivedAccountId,
+            });
+            const result = await handleTargetTestAccountSelectionFlow(derivedAccountId, undefined);
+            expect(result).toBe(890223);
+        });
+    });
+});

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

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

package/lib/__tests__/npmCli.test.js

@@ -0,0 +1,84 @@
+import util from 'util';
+import { isGloballyInstalled, getLatestPackageVersion, isInstalledGloballyWithNPM, DEFAULT_PACKAGE_MANAGER, } from '../npm/npmCli.js';
+import { pkg } from '../jsonLoader.js';
+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('getLatestPackageVersion()', () => {
+        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 getLatestPackageVersion(pkg.name);
+            expect(actual).toEqual({ latest, next });
+            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+        });
+        it('should return null values when the check fails', async () => {
+            const errorMessage = 'unsuccessful';
+            execMock.mockImplementationOnce(() => {
+                throw new Error(errorMessage);
+            });
+            util.promisify = mockedPromisify(execMock);
+            const result = await getLatestPackageVersion(pkg.name);
+            expect(result).toEqual({ latest: null, next: null });
+            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+        });
+    });
+    describe('isInstalledGloballyWithNPM()', () => {
+        it('should return true when npm is installed and package is in npm global list', async () => {
+            execMock.mockResolvedValueOnce({ stdout: '', stderr: '' }); // npm check
+            execMock.mockResolvedValueOnce({ stdout: '', stderr: '' }); // npm list succeeds
+            const result = await isInstalledGloballyWithNPM('@hubspot/cli');
+            expect(result).toBe(true);
+            expect(execMock).toHaveBeenCalledTimes(2);
+            expect(execMock).toHaveBeenNthCalledWith(1, 'npm --version');
+            expect(execMock).toHaveBeenNthCalledWith(2, 'npm list -g @hubspot/cli --depth=0');
+        });
+        it('should return false when npm is not globally installed', async () => {
+            execMock.mockRejectedValueOnce(new Error('npm not found')); // npm check fails
+            const result = await isInstalledGloballyWithNPM('@hubspot/cli');
+            expect(result).toBe(false);
+            expect(execMock).toHaveBeenCalledTimes(1);
+            expect(execMock).toHaveBeenCalledWith('npm --version');
+        });
+        it('should return false when npm list fails (package not installed via npm)', async () => {
+            execMock.mockResolvedValueOnce({ stdout: '', stderr: '' }); // npm check
+            execMock.mockRejectedValueOnce(new Error('Package not found')); // npm list fails
+            const result = await isInstalledGloballyWithNPM('@hubspot/cli');
+            expect(result).toBe(false);
+            expect(execMock).toHaveBeenCalledTimes(2);
+            expect(execMock).toHaveBeenNthCalledWith(1, 'npm --version');
+            expect(execMock).toHaveBeenNthCalledWith(2, 'npm list -g @hubspot/cli --depth=0');
+        });
+    });
+});

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

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