@hubspot/cli 7.11.8-experimental.0 → 8.0.0-beta.1

package/lib/doctor/__tests__/Doctor.test.js

@@ -1,32 +1,62 @@
 import { Doctor } from '../Doctor.js';
 import { hasMissingPackages as _hasMissingPackages } from '../../dependencyManagement.js';
 import { isPortManagerPortAvailable as _isPortManagerPortAvailable } from '@hubspot/local-dev-lib/portManager';
-import { accessTokenForPersonalAccessKey as _accessTokenForPersonalAccessKey, authorizedScopesForPortalAndUser as _authorizedScopesForPortalAndUser, scopesOnAccessToken as _scopesOnAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
+import { accessTokenForPersonalAccessKey as _accessTokenForPersonalAccessKey, scopesOnAccessToken as _scopesOnAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
+import { fetchScopeAuthorizationData as _fetchScopeAuthorizationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
-import { AxiosError } from 'axios';
+import { AxiosError, AxiosHeaders } from 'axios';
 import { isSpecifiedError as _isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
 import { promisify as _promisify } from 'util';
 import { getConfigDefaultAccount as _getConfigDefaultAccount, getConfigDefaultAccountIfExists as _getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
-vi.mock('../../ui/logger.js');
+import { validateProjectConfig as _validateProjectConfig } from '../../projects/config.js';
+import { isV2Project as _isV2Project } from '../../projects/platformVersion.js';
+import { validateSourceDirectory as _validateSourceDirectory, handleTranslate as _handleTranslate, } from '../../projects/upload.js';
+import { validateProjectForProfile as _validateProjectForProfile } from '../../projects/projectProfiles.js';
+import { getAllHsProfiles as _getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
+import { getLatestCliVersion as _getLatestCliVersion } from '../../cliUpgradeUtils.js';
 vi.mock('../Diagnosis');
 vi.mock('../../ui/SpinniesManager');
 vi.mock('../DiagnosticInfoBuilder');
 vi.mock('../../dependencyManagement');
-vi.mock('../../npm');
+vi.mock('../../npm/npmCli');
 vi.mock('@hubspot/local-dev-lib/portManager');
 vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
 vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('util');
+vi.mock('../../projects/config.js');
+vi.mock('../../projects/platformVersion.js');
+vi.mock('../../projects/upload.js');
+vi.mock('../../projects/projectProfiles.js');
+vi.mock('@hubspot/project-parsing-lib/profiles');
+vi.mock('@hubspot/project-parsing-lib/constants');
+vi.mock('../../cliUpgradeUtils.js');
 const hasMissingPackages = vi.mocked(_hasMissingPackages);
 const isPortManagerPortAvailable = vi.mocked(_isPortManagerPortAvailable);
 const utilPromisify = vi.mocked(_promisify);
 const accessTokenForPersonalAccessKey = vi.mocked(_accessTokenForPersonalAccessKey);
-const authorizedScopesForPortalAndUser = vi.mocked(_authorizedScopesForPortalAndUser);
+const fetchScopeAuthorizationData = vi.mocked(_fetchScopeAuthorizationData);
 const scopesOnAccessToken = vi.mocked(_scopesOnAccessToken);
 const isSpecifiedError = vi.mocked(_isSpecifiedError);
 const getConfigDefaultAccount = vi.mocked(_getConfigDefaultAccount);
 const getConfigDefaultAccountIfExists = vi.mocked(_getConfigDefaultAccountIfExists);
+const validateProjectConfig = vi.mocked(_validateProjectConfig);
+const isV2Project = vi.mocked(_isV2Project);
+const validateSourceDirectory = vi.mocked(_validateSourceDirectory);
+const handleTranslate = vi.mocked(_handleTranslate);
+const validateProjectForProfile = vi.mocked(_validateProjectForProfile);
+const getAllHsProfiles = vi.mocked(_getAllHsProfiles);
+const getLatestCliVersion = vi.mocked(_getLatestCliVersion);
+function createMockScopeAuthorizationResponse(results) {
+    return {
+        data: { results },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: { headers: new AxiosHeaders() },
+    };
+}
 describe('lib/doctor/Doctor', () => {
     let doctor;
     // @ts-ignore
@@ -55,7 +85,7 @@ describe('lib/doctor/Doctor', () => {
             },
         },
         versions: {
-            node: '18.1.2',
+            node: '20.1.2',
             '@hubspot/cli': '6.0.0',
             npm: '6.14.13',
         },
@@ -71,6 +101,11 @@ describe('lib/doctor/Doctor', () => {
         };
         getConfigDefaultAccount.mockReturnValue(mockAccount);
         getConfigDefaultAccountIfExists.mockReturnValue(mockAccount);
+        // Mock getLatestCliVersion to return valid versions by default
+        getLatestCliVersion.mockResolvedValue({
+            latest: '7.12.0',
+            next: '7.12.0-beta.1',
+        });
         doctor = new Doctor({
             generateDiagnosticInfo: vi.fn().mockResolvedValue({
                 ...diagnosticInfo,
@@ -83,9 +118,6 @@ describe('lib/doctor/Doctor', () => {
             return JSON.stringify({ valid: true });
         }));
     });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
     describe('CLI Checks', () => {
         describe('node version', () => {
             it('should add success section if node version is valid', async () => {
@@ -154,7 +186,7 @@ describe('lib/doctor/Doctor', () => {
         describe('Personal Access Key', () => {
             it('should add success sections if the access token is valid', async () => {
                 scopesOnAccessToken.mockResolvedValueOnce(['scope1']);
-                authorizedScopesForPortalAndUser.mockResolvedValueOnce([
+                fetchScopeAuthorizationData.mockResolvedValueOnce(createMockScopeAuthorizationResponse([
                     {
                         scopeGroup: {
                             name: 'scope1',
@@ -164,7 +196,7 @@ describe('lib/doctor/Doctor', () => {
                         portalAuthorized: true,
                         userAuthorized: true,
                     },
-                ]);
+                ]));
                 await doctor.diagnose();
                 // @ts-expect-error Testing private method
                 expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
@@ -247,47 +279,51 @@ describe('lib/doctor/Doctor', () => {
                     message: 'Unable to determine if the portal is active',
                 });
             });
-            it('should warn when there are missing authorized scopes', async () => {
-                scopesOnAccessToken.mockResolvedValueOnce(['scope1', 'scope2']);
-                authorizedScopesForPortalAndUser.mockResolvedValueOnce([
-                    {
-                        scopeGroup: {
-                            name: 'scope1',
-                            shortDescription: 'scope1',
-                            longDescription: 'scope1',
-                        },
-                        portalAuthorized: true,
-                        userAuthorized: true,
-                    },
-                    {
-                        scopeGroup: {
-                            name: 'scope2',
-                            shortDescription: 'scope2',
-                            longDescription: 'scope2',
-                        },
-                        portalAuthorized: true,
-                        userAuthorized: true,
-                    },
-                    {
-                        scopeGroup: {
-                            name: 'scope3',
-                            shortDescription: 'scope3',
-                            longDescription: 'scope3',
-                        },
-                        portalAuthorized: true,
-                        userAuthorized: true,
-                    },
-                ]);
-                await doctor.diagnose();
-                expect(doctor['diagnosis']?.addCLIConfigSection).toHaveBeenCalledWith({
-                    type: 'warning',
-                    message: 'Personal access key is valid, but there are more scopes available to your user that are not included in your key.',
-                    secondaryMessaging: expect.any(String),
-                });
-            });
+            // @TODO Restore test once PAK scope check functionality is restored
+            // it('should warn when there are missing authorized scopes', async () => {
+            //   scopesOnAccessToken.mockResolvedValueOnce(['scope1', 'scope2']);
+            //   fetchScopeAuthorizationData.mockResolvedValueOnce(
+            //     createMockScopeAuthorizationResponse([
+            //       {
+            //         scopeGroup: {
+            //           name: 'scope1',
+            //           shortDescription: 'scope1',
+            //           longDescription: 'scope1',
+            //         },
+            //         portalAuthorized: true,
+            //         userAuthorized: true,
+            //       },
+            //       {
+            //         scopeGroup: {
+            //           name: 'scope2',
+            //           shortDescription: 'scope2',
+            //           longDescription: 'scope2',
+            //         },
+            //         portalAuthorized: true,
+            //         userAuthorized: true,
+            //       },
+            //       {
+            //         scopeGroup: {
+            //           name: 'scope3',
+            //           shortDescription: 'scope3',
+            //           longDescription: 'scope3',
+            //         },
+            //         portalAuthorized: true,
+            //         userAuthorized: true,
+            //       },
+            //     ])
+            //   );
+            //   await doctor.diagnose();
+            //   expect(doctor['diagnosis']?.addCLIConfigSection).toHaveBeenCalledWith({
+            //     type: 'warning',
+            //     message:
+            //       'Personal access key is valid, but there are more scopes available to your user that are not included in your key.',
+            //     secondaryMessaging: expect.any(String),
+            //   });
+            // });
             it('should not warn when the missing scope is not authorized', async () => {
                 scopesOnAccessToken.mockResolvedValueOnce(['scope1']);
-                authorizedScopesForPortalAndUser.mockResolvedValueOnce([
+                fetchScopeAuthorizationData.mockResolvedValueOnce(createMockScopeAuthorizationResponse([
                     {
                         scopeGroup: {
                             name: 'scope1',
@@ -306,7 +342,7 @@ describe('lib/doctor/Doctor', () => {
                         portalAuthorized: true,
                         userAuthorized: false,
                     },
-                ]);
+                ]));
                 await doctor.diagnose();
                 expect(doctor['diagnosis']?.addCLIConfigSection).toHaveBeenCalledWith({
                     type: 'success',
@@ -407,4 +443,118 @@ describe('lib/doctor/Doctor', () => {
             });
         });
     });
+    describe('Networking Checks', () => {
+        it('should perform network connectivity check during diagnosis', async () => {
+            await doctor.diagnose();
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addNetworkingSection).toHaveBeenCalled();
+        });
+    });
+    describe('Project Validation', () => {
+        it('should skip validation if no project config exists', async () => {
+            doctor = new Doctor({
+                generateDiagnosticInfo: vi.fn().mockResolvedValue({
+                    ...diagnosticInfo,
+                    project: { config: null },
+                }),
+            });
+            await doctor.diagnose();
+            // @ts-expect-error Testing private method
+            const projectSections = doctor.diagnosis.project?.sections || [];
+            const validationSections = projectSections.filter((s) => s.message?.includes('validation'));
+            expect(validationSections.length).toBe(0);
+        });
+        it('should validate V1 projects successfully', async () => {
+            validateProjectConfig.mockReturnValue(undefined);
+            isV2Project.mockReturnValue(false);
+            await doctor.diagnose();
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                type: 'success',
+                message: 'Project configuration and structure is valid',
+            });
+        });
+        it('should handle invalid project config', async () => {
+            validateProjectConfig.mockImplementation(() => {
+                throw new Error('Invalid config');
+            });
+            await doctor.diagnose();
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                type: 'error',
+                message: 'Project configuration is invalid',
+                secondaryMessaging: 'Invalid config',
+            });
+        });
+        it('should validate V2 projects with profiles', async () => {
+            validateProjectConfig.mockReturnValue(undefined);
+            isV2Project.mockReturnValue(true);
+            validateSourceDirectory.mockResolvedValue(undefined);
+            getAllHsProfiles.mockResolvedValue(['dev', 'prod']);
+            validateProjectForProfile.mockResolvedValue([]);
+            await doctor.diagnose();
+            expect(validateProjectForProfile).toHaveBeenCalledTimes(2);
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                type: 'success',
+                message: 'Project configuration and structure is valid',
+            });
+        });
+        it('should report profile validation errors', async () => {
+            validateProjectConfig.mockReturnValue(undefined);
+            isV2Project.mockReturnValue(true);
+            validateSourceDirectory.mockResolvedValue(undefined);
+            getAllHsProfiles.mockResolvedValue(['dev']);
+            validateProjectForProfile.mockResolvedValue([
+                new Error('Validation error'),
+            ]);
+            await doctor.diagnose();
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                type: 'error',
+                message: "Project validation failed with profile 'dev' applied",
+                secondaryMessaging: expect.any(String),
+            });
+        });
+        it('should validate V2 projects without profiles', async () => {
+            validateProjectConfig.mockReturnValue(undefined);
+            isV2Project.mockReturnValue(true);
+            validateSourceDirectory.mockResolvedValue(undefined);
+            getAllHsProfiles.mockResolvedValue([]);
+            handleTranslate.mockResolvedValue(undefined);
+            await doctor.diagnose();
+            expect(handleTranslate).toHaveBeenCalled();
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                type: 'success',
+                message: 'Project configuration and structure is valid',
+            });
+        });
+        it('should handle translation failures', async () => {
+            validateProjectConfig.mockReturnValue(undefined);
+            isV2Project.mockReturnValue(true);
+            validateSourceDirectory.mockResolvedValue(undefined);
+            getAllHsProfiles.mockResolvedValue([]);
+            handleTranslate.mockRejectedValue(new Error('Translation failed'));
+            await doctor.diagnose();
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                type: 'warning',
+                message: 'Project validation failed',
+                secondaryMessaging: expect.any(String),
+            });
+        });
+        it('should handle source directory validation errors', async () => {
+            validateProjectConfig.mockReturnValue(undefined);
+            isV2Project.mockReturnValue(true);
+            validateSourceDirectory.mockRejectedValue(new Error('Source directory invalid'));
+            await doctor.diagnose();
+            // @ts-expect-error Testing private method
+            expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                type: 'error',
+                message: 'Project source directory validation failed',
+                secondaryMessaging: 'Source directory invalid',
+            });
+        });
+    });
 });

package/lib/errorHandlers/__tests__/index.test.d.ts

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

package/lib/errorHandlers/__tests__/index.test.js

@@ -0,0 +1,278 @@
+import { logError, debugError, ApiErrorContext, isErrorWithMessageOrReason, getErrorMessage, } from '../index.js';
+import { uiLogger } from '../../ui/logger.js';
+import { isHubSpotHttpError, isValidationError, } from '@hubspot/local-dev-lib/errors/index';
+import { getConfig } from '@hubspot/local-dev-lib/config';
+import { shouldSuppressError } from '../suppressError.js';
+import { isProjectValidationError } from '../../errors/ProjectValidationError.js';
+import { lib } from '../../../lang/en.js';
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../suppressError.js');
+vi.mock('../../errors/ProjectValidationError.js');
+describe('lib/errorHandlers/index', () => {
+    const uiLoggerErrorMock = uiLogger.error;
+    const uiLoggerDebugMock = uiLogger.debug;
+    const isHubSpotHttpErrorMock = isHubSpotHttpError;
+    const isValidationErrorMock = isValidationError;
+    const getConfigMock = getConfig;
+    const shouldSuppressErrorMock = shouldSuppressError;
+    const isProjectValidationErrorMock = isProjectValidationError;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        isHubSpotHttpErrorMock.mockReturnValue(false);
+        isValidationErrorMock.mockReturnValue(false);
+        shouldSuppressErrorMock.mockReturnValue(false);
+        isProjectValidationErrorMock.mockReturnValue(false);
+        getConfigMock.mockReturnValue({});
+    });
+    describe('logError', () => {
+        it('logs ProjectValidationError message and returns early', () => {
+            const error = {
+                message: 'Project validation failed',
+                name: 'ProjectValidationError',
+            };
+            isProjectValidationErrorMock.mockReturnValue(true);
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Project validation failed');
+            expect(uiLoggerErrorMock).toHaveBeenCalledTimes(1);
+        });
+        it('returns early when error should be suppressed', () => {
+            const error = new Error('Suppressed error');
+            shouldSuppressErrorMock.mockReturnValue(true);
+            logError(error);
+            expect(shouldSuppressErrorMock).toHaveBeenCalled();
+            expect(uiLoggerErrorMock).not.toHaveBeenCalled();
+        });
+        it('logs validation errors for HubSpotHttpError with validation errors', () => {
+            const mockError = {
+                formattedValidationErrors: vi
+                    .fn()
+                    .mockReturnValue('Formatted validation errors'),
+                updateContext: vi.fn(),
+                context: {},
+            };
+            isHubSpotHttpErrorMock.mockReturnValue(true);
+            isValidationErrorMock.mockReturnValue(true);
+            logError(mockError);
+            expect(mockError.formattedValidationErrors).toHaveBeenCalled();
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Formatted validation errors');
+        });
+        it('logs error message for errors with message property', () => {
+            const error = new Error('Something went wrong');
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Something went wrong');
+        });
+        it('logs error with both message and reason', () => {
+            const error = { message: 'Error message', reason: 'Error reason' };
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Error message Error reason');
+        });
+        it('logs unknown error message for errors without message or reason', () => {
+            const error = { foo: 'bar' };
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith(lib.errorHandlers.index.unknownErrorOccurred);
+        });
+        it('calls updateContext on HubSpotHttpError', () => {
+            const mockError = {
+                updateContext: vi.fn(),
+                context: {},
+                message: 'test',
+            };
+            isHubSpotHttpErrorMock.mockReturnValue(true);
+            logError(mockError);
+            expect(mockError.updateContext).toHaveBeenCalled();
+        });
+        describe('timeout error handling', () => {
+            it('shows config timeout message for direct ETIMEDOUT error matching default timeout', () => {
+                const mockError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 15000,
+                    updateContext: vi.fn(),
+                    context: {},
+                    message: 'Timeout',
+                };
+                isHubSpotHttpErrorMock.mockReturnValue(true);
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(mockError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(1, 'Timeout');
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.configTimeoutErrorOccurred(15000, 'hs config set'));
+            });
+            it('shows generic timeout message for direct ETIMEDOUT error with custom timeout', () => {
+                const mockError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 30000,
+                    updateContext: vi.fn(),
+                    context: {},
+                    message: 'Timeout',
+                };
+                isHubSpotHttpErrorMock.mockReturnValue(true);
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(mockError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.genericTimeoutErrorOccurred);
+            });
+            it('detects timeout error wrapped in error.cause', () => {
+                const causeError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 15000,
+                    name: 'HubSpotHttpError',
+                };
+                const wrapperError = new Error('Assets unavailable');
+                Object.defineProperty(wrapperError, 'cause', {
+                    value: causeError,
+                    writable: true,
+                });
+                isHubSpotHttpErrorMock.mockImplementation(err => {
+                    return err === causeError;
+                });
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(wrapperError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith('Assets unavailable');
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith(lib.errorHandlers.index.configTimeoutErrorOccurred(15000, 'hs config set'));
+            });
+            it('shows generic timeout message for wrapped timeout with different timeout value', () => {
+                const causeError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 60000,
+                    name: 'HubSpotHttpError',
+                };
+                const wrapperError = new Error('Assets unavailable');
+                Object.defineProperty(wrapperError, 'cause', {
+                    value: causeError,
+                    writable: true,
+                });
+                isHubSpotHttpErrorMock.mockImplementation(err => {
+                    return err === causeError;
+                });
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(wrapperError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.genericTimeoutErrorOccurred);
+            });
+            it('does not show timeout message for non-timeout errors', () => {
+                const error = new Error('Regular error');
+                logError(error);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(1);
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith('Regular error');
+            });
+        });
+    });
+    describe('debugError', () => {
+        it('logs HubSpotHttpError using toString', () => {
+            const mockError = {
+                toString: vi.fn().mockReturnValue('HubSpotHttpError details'),
+            };
+            isHubSpotHttpErrorMock.mockReturnValue(true);
+            debugError(mockError);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith('HubSpotHttpError details');
+        });
+        it('logs regular error using lib.errorHandlers.index.errorOccurred', () => {
+            const error = new Error('Regular error');
+            debugError(error);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith(lib.errorHandlers.index.errorOccurred('Error: Regular error'));
+        });
+        it('logs error.cause when it is a HubSpotHttpError', () => {
+            const causeError = {
+                toString: vi.fn().mockReturnValue('Cause error details'),
+            };
+            const error = new Error('Wrapper error');
+            Object.defineProperty(error, 'cause', {
+                value: causeError,
+                writable: true,
+            });
+            isHubSpotHttpErrorMock.mockImplementation(err => {
+                return err === causeError;
+            });
+            debugError(error);
+            expect(causeError.toString).toHaveBeenCalled();
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith('Cause error details');
+        });
+        it('logs error.cause using lib.errorHandlers.index.errorCause when not a HubSpotHttpError', () => {
+            const causeError = { customField: 'value' };
+            const error = new Error('Wrapper error');
+            Object.defineProperty(error, 'cause', {
+                value: causeError,
+                writable: true,
+            });
+            debugError(error);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith(expect.stringMatching(/^Cause:/));
+        });
+        it('logs context using lib.errorHandlers.index.errorContext when provided', () => {
+            const error = new Error('Error');
+            const context = new ApiErrorContext({
+                accountId: 123,
+                request: '/api/test',
+            });
+            debugError(error, context);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith(expect.stringMatching(/^Context:/));
+        });
+    });
+    describe('ApiErrorContext', () => {
+        it('creates context with all properties', () => {
+            const context = new ApiErrorContext({
+                accountId: 123,
+                request: '/api/test',
+                payload: '{"data": "value"}',
+                projectName: 'my-project',
+            });
+            expect(context.accountId).toBe(123);
+            expect(context.request).toBe('/api/test');
+            expect(context.payload).toBe('{"data": "value"}');
+            expect(context.projectName).toBe('my-project');
+        });
+        it('creates context with default values', () => {
+            const context = new ApiErrorContext();
+            expect(context.accountId).toBeUndefined();
+            expect(context.request).toBe('');
+            expect(context.payload).toBe('');
+            expect(context.projectName).toBe('');
+        });
+        it('creates context with partial properties', () => {
+            const context = new ApiErrorContext({
+                accountId: 456,
+            });
+            expect(context.accountId).toBe(456);
+            expect(context.request).toBe('');
+            expect(context.payload).toBe('');
+            expect(context.projectName).toBe('');
+        });
+    });
+    describe('isErrorWithMessageOrReason', () => {
+        it('returns true for object with message property', () => {
+            expect(isErrorWithMessageOrReason({ message: 'test' })).toBe(true);
+        });
+        it('returns true for object with reason property', () => {
+            expect(isErrorWithMessageOrReason({ reason: 'test' })).toBe(true);
+        });
+        it('returns true for object with both message and reason', () => {
+            expect(isErrorWithMessageOrReason({ message: 'msg', reason: 'rsn' })).toBe(true);
+        });
+        it('returns true for Error instances', () => {
+            expect(isErrorWithMessageOrReason(new Error('test'))).toBe(true);
+        });
+        it('returns false for null', () => {
+            expect(isErrorWithMessageOrReason(null)).toBe(false);
+        });
+        it('returns false for undefined', () => {
+            expect(isErrorWithMessageOrReason(undefined)).toBe(false);
+        });
+        it('returns false for primitive values', () => {
+            expect(isErrorWithMessageOrReason('string')).toBe(false);
+            expect(isErrorWithMessageOrReason(123)).toBe(false);
+            expect(isErrorWithMessageOrReason(true)).toBe(false);
+        });
+        it('returns false for object without message or reason', () => {
+            expect(isErrorWithMessageOrReason({ foo: 'bar' })).toBe(false);
+        });
+        it('returns false for empty object', () => {
+            expect(isErrorWithMessageOrReason({})).toBe(false);
+        });
+    });
+    describe('getErrorMessage', () => {
+        it('returns message from Error instance', () => {
+            expect(getErrorMessage(new Error('Error message'))).toBe('Error message');
+        });
+    });
+});

package/lib/errorHandlers/index.d.ts

@@ -16,3 +16,4 @@ export declare function isErrorWithMessageOrReason(error: unknown): error is {
     message?: string;
     reason?: string;
 };
+export declare function getErrorMessage(error: unknown): string;

package/lib/errorHandlers/index.js

@@ -36,12 +36,21 @@ export function logError(error, context) {
         // Unknown errors
         uiLogger.error(lib.errorHandlers.index.unknownErrorOccurred);
     }
+    let timeoutError = null;
     if (isHubSpotHttpError(error) && error.code === 'ETIMEDOUT') {
+        timeoutError = error;
+    }
+    else if (error instanceof Error &&
+        isHubSpotHttpError(error.cause) &&
+        error.cause.code === 'ETIMEDOUT') {
+        timeoutError = error.cause;
+    }
+    if (timeoutError) {
         const config = getConfig();
         const defaultTimeout = config?.httpTimeout;
         // Timeout was caused by the default timeout
-        if (error.timeout && defaultTimeout === error.timeout) {
-            uiLogger.error(lib.errorHandlers.index.configTimeoutErrorOccurred(error.timeout, 'hs config set'));
+        if (timeoutError.timeout && defaultTimeout === timeoutError.timeout) {
+            uiLogger.error(lib.errorHandlers.index.configTimeoutErrorOccurred(timeoutError.timeout, 'hs config set'));
         }
         // Timeout was caused by a custom timeout set by the CLI or LDL
         else {
@@ -85,3 +94,6 @@ export function isErrorWithMessageOrReason(error) {
         error !== null &&
         ('message' in error || 'reason' in error));
 }
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : `${error}`;
+}