@hubspot/cli 8.2.0-beta.0 → 8.2.0-experimental.0

package/lib/__tests__/serverlessLogs.test.js

@@ -1,163 +0,0 @@
-import { outputLogs } from '../ui/serverlessFunctionLogs.js';
-import { tailLogs } from '../serverlessLogs.js';
-import { handleKeypress } from '../process.js';
-vi.mock('../ui/serverlessFunctionLogs');
-vi.mock('../ui/SpinniesManager', () => ({
-    default: {
-        init: vi.fn(),
-        add: vi.fn(),
-        remove: vi.fn(),
-        succeed: vi.fn(),
-        fail: vi.fn(),
-        stopAll: vi.fn(),
-    },
-}));
-vi.mock('../process');
-vi.useFakeTimers();
-const ACCOUNT_ID = 123;
-function terminateTailLogs() {
-    const keypressCallback = vi.mocked(handleKeypress).mock.calls[0][0];
-    keypressCallback({ name: 'q' });
-}
-describe('lib/serverlessLogs', () => {
-    describe('tailLogs()', () => {
-        afterEach(() => {
-            vi.clearAllTimers();
-            vi.clearAllMocks();
-        });
-        it('calls tailCall() to get the next results', async () => {
-            const compact = false;
-            const fetchLatest = vi.fn(() => Promise.resolve({
-                data: {
-                    id: '1234',
-                    executionTime: 510,
-                    log: 'Log message',
-                    error: { message: '', type: '', stackTrace: [] },
-                    status: 'SUCCESS',
-                    createdAt: 1620232011451,
-                    memory: '70/128 MB',
-                    duration: '53.40 ms',
-                },
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                // eslint-disable-next-line
-                config: { headers: {} },
-            }));
-            const tailCall = vi.fn(() => Promise.resolve({
-                data: {
-                    results: [],
-                    paging: {
-                        next: {
-                            after: 'somehash',
-                        },
-                    },
-                },
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                // eslint-disable-next-line
-                config: { headers: {} },
-            }));
-            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            await vi.advanceTimersByTimeAsync(0);
-            expect(fetchLatest).toHaveBeenCalled();
-            expect(tailCall).toHaveBeenCalledTimes(1);
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(tailCall).toHaveBeenCalledTimes(2);
-            terminateTailLogs();
-            await tailPromise;
-        });
-        it('outputs results', async () => {
-            const compact = false;
-            const fetchLatest = vi.fn(() => Promise.resolve({
-                data: {
-                    id: '1234',
-                    executionTime: 510,
-                    log: 'Log message',
-                    error: {
-                        message: '',
-                        type: '',
-                        stackTrace: [],
-                        statusCode: null,
-                    },
-                    status: 'SUCCESS',
-                    createdAt: 1620232011451,
-                    memory: '70/128 MB',
-                    duration: '53.40 ms',
-                },
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                // eslint-disable-next-line
-                config: { headers: {} },
-            }));
-            const latestLogResponse = {
-                results: [
-                    {
-                        id: '456',
-                        executionTime: 510,
-                        log: 'Message 1',
-                        error: null,
-                        status: 'SUCCESS',
-                        createdAt: 1620232011451,
-                        memory: '70/128 MB',
-                        duration: '53.40 ms',
-                    },
-                    {
-                        id: '457',
-                        executionTime: 510,
-                        log: 'Message 2',
-                        error: null,
-                        status: 'SUCCESS',
-                        createdAt: 1620232011451,
-                        memory: '70/128 MB',
-                        duration: '53.40 ms',
-                    },
-                ],
-                paging: {
-                    next: {
-                        after: 'somehash',
-                    },
-                },
-            };
-            const tailCall = vi.fn(() => Promise.resolve({
-                data: latestLogResponse,
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                // eslint-disable-next-line
-                config: { headers: {} },
-            }));
-            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            await vi.advanceTimersByTimeAsync(0);
-            expect(outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
-            expect(tailCall).toHaveBeenCalledTimes(1);
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(tailCall).toHaveBeenCalledTimes(2);
-            terminateTailLogs();
-            await tailPromise;
-        });
-        it('handles no logs', async () => {
-            const compact = false;
-            const fetchLatest = vi.fn(() => {
-                return Promise.reject({
-                    message: '',
-                    type: '',
-                    stackTrace: [],
-                    statusCode: 404,
-                });
-            });
-            const tailCall = vi.fn(() => Promise.reject({
-                message: '',
-                type: '',
-                stackTrace: [],
-                statusCode: 404,
-            }));
-            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            expect(tailCall).toHaveBeenCalledTimes(1);
-        });
-    });
-});

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

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

package/lib/__tests__/usageTracking.test.js

@@ -1,197 +0,0 @@
-import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { getConfig, getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
-import { uiLogger } from '../ui/logger.js';
-import { trackCommandUsage, trackHelpUsage, trackConvertFieldsUsage, trackAuthAction, trackCommandMetadataUsage, } from '../usageTracking.js';
-import { pkg } from '../jsonLoader.js';
-const version = pkg.version;
-// Unmock the usageTracking module for this test file
-vi.unmock('../usageTracking.js');
-vi.mock('@hubspot/local-dev-lib/trackUsage');
-vi.mock('@hubspot/local-dev-lib/config');
-const mockedTrackUsage = trackUsage;
-const mockedGetConfig = getConfig;
-const mockedGetConfigAccountById = getConfigAccountById;
-const mockedUiLogger = uiLogger;
-describe('lib/usageTracking', () => {
-    const mockPlatform = 'darwin';
-    const mockNodeVersion = 'v16.14.0';
-    beforeEach(() => {
-        mockedGetConfig.mockReturnValue({ allowUsageTracking: true });
-        Object.defineProperty(process, 'platform', { value: mockPlatform });
-        Object.defineProperty(process, 'version', { value: mockNodeVersion });
-        delete process.env.DISABLE_USAGE_TRACKING;
-    });
-    afterEach(() => {
-        delete process.env.DISABLE_USAGE_TRACKING;
-    });
-    describe('trackCommandUsage()', () => {
-        const mockCommand = 'test-command';
-        const mockAccountId = 123;
-        it('should not track when tracking is disabled via config', async () => {
-            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
-            await trackCommandUsage(mockCommand);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-        });
-        it('should not track when --disable-usage-tracking flag is set', async () => {
-            process.env.DISABLE_USAGE_TRACKING = 'true';
-            await trackCommandUsage(mockCommand, {}, mockAccountId);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-            expect(mockedUiLogger.debug).toHaveBeenCalledWith('Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events');
-        });
-        it('should track command usage with default auth type', async () => {
-            await trackCommandUsage(mockCommand, {}, mockAccountId);
-            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
-                action: 'cli-command',
-                command: mockCommand,
-                os: 'macos',
-                nodeVersion: mockNodeVersion,
-                nodeMajorVersion: 'v16',
-                version,
-                authType: API_KEY_AUTH_METHOD.value,
-            }), mockAccountId);
-        });
-        it('should track command usage with custom auth type', async () => {
-            mockedGetConfigAccountById.mockReturnValue({ authType: 'oauth2' });
-            await trackCommandUsage(mockCommand, {}, mockAccountId);
-            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
-                authType: 'oauth2',
-            }), mockAccountId);
-        });
-        it('should handle tracking errors gracefully', async () => {
-            const error = new Error('Tracking failed');
-            mockedTrackUsage.mockImplementationOnce(() => {
-                throw error;
-            });
-            await trackCommandUsage(mockCommand);
-            expect(mockedUiLogger.debug).toHaveBeenCalledWith(expect.stringContaining(error.message));
-        });
-    });
-    describe('trackHelpUsage()', () => {
-        const mockCommand = 'help-command';
-        it('should not track when tracking is disabled via config', async () => {
-            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
-            await trackHelpUsage(mockCommand);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-        });
-        it('should not track when --disable-usage-tracking flag is set', async () => {
-            process.env.DISABLE_USAGE_TRACKING = 'true';
-            await trackHelpUsage(mockCommand);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-            expect(mockedUiLogger.debug).toHaveBeenCalledWith('Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events');
-        });
-        it('should track help usage with command', async () => {
-            await trackHelpUsage(mockCommand);
-            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
-                action: 'cli-help',
-                command: mockCommand,
-                os: 'macos',
-                nodeVersion: mockNodeVersion,
-                nodeMajorVersion: 'v16',
-                version,
-            }), undefined);
-        });
-        it('should track main help usage without command', async () => {
-            await trackHelpUsage('');
-            expect(mockedUiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('main command'));
-        });
-    });
-    describe('trackConvertFieldsUsage()', () => {
-        const mockCommand = 'convert-fields-command';
-        it('should not track when tracking is disabled via config', async () => {
-            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
-            await trackConvertFieldsUsage(mockCommand);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-        });
-        it('should not track when --disable-usage-tracking flag is set', async () => {
-            process.env.DISABLE_USAGE_TRACKING = 'true';
-            await trackConvertFieldsUsage(mockCommand);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-        });
-        it('should track convert fields usage', async () => {
-            await trackConvertFieldsUsage(mockCommand);
-            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
-                action: 'cli-process-fields',
-                command: mockCommand,
-                os: 'macos',
-                nodeVersion: mockNodeVersion,
-                nodeMajorVersion: 'v16',
-                version,
-            }), undefined);
-        });
-    });
-    describe('trackAuthAction()', () => {
-        const mockCommand = 'auth-command';
-        const mockAuthType = 'oauth2';
-        const mockStep = 'init';
-        const mockAccountId = 123;
-        it('should not track when tracking is disabled via config', async () => {
-            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
-            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-        });
-        it('should not track when --disable-usage-tracking flag is set', async () => {
-            process.env.DISABLE_USAGE_TRACKING = 'true';
-            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-        });
-        it('should track auth action', async () => {
-            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
-            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
-                action: 'cli-auth',
-                command: mockCommand,
-                authType: mockAuthType,
-                step: mockStep,
-                os: 'macos',
-                nodeVersion: mockNodeVersion,
-                nodeMajorVersion: 'v16',
-                version,
-            }), mockAccountId);
-        });
-    });
-    describe('trackCommandMetadataUsage()', () => {
-        const mockCommand = 'metadata-command';
-        const mockMeta = { assetType: 'test-asset' };
-        const mockAccountId = 123;
-        it('should not track when tracking is disabled via config', async () => {
-            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
-            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-        });
-        it('should not track when --disable-usage-tracking flag is set', async () => {
-            process.env.DISABLE_USAGE_TRACKING = 'true';
-            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
-            expect(mockedTrackUsage).not.toHaveBeenCalled();
-            expect(mockedUiLogger.debug).toHaveBeenCalledWith('Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events');
-        });
-        it('should track command metadata usage', async () => {
-            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
-            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
-                action: 'cli-command-metadata',
-                command: mockCommand,
-                assetType: 'test-asset',
-                os: 'macos',
-                nodeVersion: mockNodeVersion,
-                nodeMajorVersion: 'v16',
-                version,
-            }), mockAccountId);
-        });
-    });
-    describe('Platform detection', () => {
-        it('should return "macos" for darwin platform', async () => {
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            await trackHelpUsage('test');
-            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'macos' }), undefined);
-        });
-        it('should return "windows" for win32 platform', async () => {
-            Object.defineProperty(process, 'platform', { value: 'win32' });
-            await trackHelpUsage('test');
-            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'windows' }), undefined);
-        });
-        it('should return platform name for other platforms', async () => {
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            await trackHelpUsage('test');
-            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'linux' }), undefined);
-        });
-    });
-});

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

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

package/lib/__tests__/validation.test.js

@@ -1,143 +0,0 @@
-import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
-import { getOauthManager } from '@hubspot/local-dev-lib/oauth';
-import { accessTokenForPersonalAccessKey } from '@hubspot/local-dev-lib/personalAccessKey';
-import { validateAccount } from '../validation.js';
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../errorHandlers/index.js');
-vi.mock('@hubspot/local-dev-lib/oauth');
-vi.mock('@hubspot/local-dev-lib/personalAccessKey');
-vi.mock('../commonOpts');
-const yargsOption = (option) => ({
-    $0: '',
-    _: [''],
-    ...option,
-});
-describe('lib/validation', () => {
-    const getConfigAccountIfExistsMock = getConfigAccountIfExists;
-    const getConfigAccountByIdMock = getConfigAccountById;
-    const getOauthManagerMock = getOauthManager;
-    const accessTokenForPersonalAccessKeyMock = accessTokenForPersonalAccessKey;
-    describe('validateAccount', () => {
-        it('returns false if an account is missing', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce(null);
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
-        });
-        it('returns false if an account config is missing', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            getConfigAccountByIdMock.mockReturnValueOnce(undefined);
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
-        });
-        it('returns false for oauth2 authType if auth is missing', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'oauth2',
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
-        });
-        it('returns false if OAuth is missing configuration', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'oauth2',
-                auth: {
-                    clientId: 'foo',
-                },
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
-        });
-        it('returns false if an access token was not retrieved', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            getOauthManagerMock.mockReturnValueOnce({
-                accessToken() {
-                    return null;
-                },
-            });
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'oauth2',
-                auth: {
-                    clientId: 'foo',
-                    clientSecret: 'abc',
-                    tokenInfo: {
-                        refreshToken: 'def',
-                    },
-                },
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
-        });
-        it('returns false if an getting an access token throws', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            getOauthManagerMock.mockReturnValueOnce({
-                accessToken() {
-                    throw new Error('It failed');
-                },
-            });
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'oauth2',
-                auth: {
-                    clientId: 'foo',
-                    clientSecret: 'abc',
-                    tokenInfo: {
-                        refreshToken: 'def',
-                    },
-                },
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
-        });
-        it('returns true if OAuth is configured and an access token is received', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            getOauthManagerMock.mockReturnValueOnce({
-                accessToken() {
-                    return 'yep';
-                },
-            });
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'oauth2',
-                auth: {
-                    clientId: 'foo',
-                    clientSecret: 'abc',
-                    tokenInfo: {
-                        refreshToken: 'def',
-                    },
-                },
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
-        });
-        it('returns false if "personalaccesskey" configured and getting an access token throws', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
-                throw new Error('It failed');
-            });
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'personalaccesskey',
-                personalAccessKey: 'foo',
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
-        });
-        it('returns true if "personalaccesskey" configured and an access token is received', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
-                return 'secret-stuff';
-            });
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'personalaccesskey',
-                personalAccessKey: 'foo',
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
-        });
-        it('returns true if apiKey is configured and present', async () => {
-            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
-            getConfigAccountByIdMock.mockReturnValueOnce({
-                accountId: '123',
-                authType: 'apikey',
-                apiKey: 'my-secret-key',
-            });
-            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
-        });
-    });
-});

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

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

package/lib/__tests__/yargsUtils.test.js

@@ -1,124 +0,0 @@
-import { hasFlag, makeYargsBuilder, strictEnforceBoolean, } from '../yargsUtils.js';
-import * as commonOpts from '../commonOpts.js';
-vi.mock('../commonOpts');
-vi.mock('../../lang/en.js', () => ({
-    commands: {
-        config: {
-            subcommands: {
-                set: {
-                    errors: {
-                        invalidBoolean: (option, value) => `Invalid boolean value "${value}" for --${option}. Valid values are: true, false`,
-                    },
-                },
-            },
-        },
-    },
-}));
-const argvWithFlag = ['hs', 'command', '--test'];
-const argvWithoutFlag = ['hs', 'command'];
-describe('lib/yargsUtils', () => {
-    describe('hasFlag()', () => {
-        it('should return true if the flag is present', () => {
-            const flag = hasFlag('test', argvWithFlag);
-            expect(flag).toBe(true);
-        });
-        it('should return false if argv is an empty array', () => {
-            const flag = hasFlag('test', []);
-            expect(flag).toBe(false);
-        });
-        it('should return false if the flag is not present', () => {
-            const flag = hasFlag('test', argvWithoutFlag);
-            expect(flag).toBe(false);
-        });
-    });
-    describe('makeYargsBuilder()', () => {
-        it('should add specified options', async () => {
-            const builder = makeYargsBuilder(yargs => yargs, 'command', 'describe', {
-                useAccountOptions: true,
-                useConfigOptions: true,
-                useEnvironmentOptions: true,
-                useTestingOptions: true,
-                useGlobalOptions: true,
-            });
-            await builder({});
-            expect(commonOpts.addGlobalOptions).toHaveBeenCalled();
-            expect(commonOpts.addAccountOptions).toHaveBeenCalled();
-            expect(commonOpts.addConfigOptions).toHaveBeenCalled();
-            expect(commonOpts.addUseEnvironmentOptions).toHaveBeenCalled();
-            expect(commonOpts.addTestingOptions).toHaveBeenCalled();
-            expect(commonOpts.addCustomHelpOutput).toHaveBeenCalled();
-        });
-    });
-    describe('strictEnforceBoolean()', () => {
-        it('should validate valid boolean values (true/false, case-insensitive)', () => {
-            const validArgs = [
-                ['hs', 'config', 'set', '--allow-usage-tracking=true'],
-                ['hs', 'config', 'set', '--allow-usage-tracking=false'],
-                ['hs', 'config', 'set', '--allow-usage-tracking=TRUE'],
-                ['hs', 'config', 'set', '--allow-usage-tracking=False'],
-            ];
-            validArgs.forEach(args => {
-                expect(() => strictEnforceBoolean(args, ['allow-usage-tracking'])).not.toThrow();
-                expect(strictEnforceBoolean(args, ['allow-usage-tracking'])).toBe(true);
-            });
-        });
-        it('should reject invalid boolean values with descriptive error messages', () => {
-            const invalidCases = [
-                {
-                    args: ['hs', 'config', 'set', '--allow-usage-tracking=yes'],
-                    value: 'yes',
-                },
-                {
-                    args: ['hs', 'config', 'set', '--allow-usage-tracking=1'],
-                    value: '1',
-                },
-                {
-                    args: ['hs', 'config', 'set', '--auto-open-browser=maybe'],
-                    value: 'maybe',
-                },
-            ];
-            invalidCases.forEach(({ args, value }) => {
-                const option = args[3].split('=')[0].replace('--', '');
-                expect(() => strictEnforceBoolean(args, [option])).toThrow(`Invalid boolean value "${value}" for --${option}. Valid values are: true, false`);
-            });
-        });
-        it('should support multiple config values in a single command', () => {
-            const args = [
-                'hs',
-                'config',
-                'set',
-                '--allow-usage-tracking=true',
-                '--auto-open-browser=false',
-                '--allow-auto-updates=true',
-                '--http-timeout=5000',
-                '--default-cms-publish-mode=draft',
-            ];
-            const booleanOptions = [
-                'allow-usage-tracking',
-                'auto-open-browser',
-                'allow-auto-updates',
-            ];
-            expect(() => strictEnforceBoolean(args, booleanOptions)).not.toThrow();
-            expect(strictEnforceBoolean(args, booleanOptions)).toBe(true);
-        });
-        it('should error when one of multiple values is invalid', () => {
-            const args = [
-                'hs',
-                'config',
-                'set',
-                '--allow-usage-tracking=true',
-                '--auto-open-browser=invalid',
-                '--http-timeout=5000',
-            ];
-            const booleanOptions = ['allow-usage-tracking', 'auto-open-browser'];
-            expect(() => strictEnforceBoolean(args, booleanOptions)).toThrow('Invalid boolean value "invalid" for --auto-open-browser. Valid values are: true, false');
-        });
-        it('should maintain backwards compatability', () => {
-            expect(() => strictEnforceBoolean(['hs', 'config', 'set', '--allow-usage-tracking=true'], ['allow-usage-tracking'])).not.toThrow();
-            // No values provided (interactive mode)
-            expect(() => strictEnforceBoolean(['hs', 'config', 'set'], ['allow-usage-tracking'])).not.toThrow();
-            // Flag without equals sign (succeed with true)
-            expect(() => strictEnforceBoolean(['hs', 'config', 'set', '--allow-usage-tracking'], ['allow-usage-tracking'])).not.toThrow();
-        });
-    });
-});

package/lib/app/__tests__/migrate.test.d.ts

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