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

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

@@ -0,0 +1,172 @@
+"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 vitest_1 = require("vitest");
+vitest_1.vi.mock('@hubspot/local-dev-lib/fs');
+vitest_1.vi.mock('@hubspot/local-dev-lib/config');
+vitest_1.vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vitest_1.vi.mock('../../projects/config');
+vitest_1.vi.mock('@hubspot/local-dev-lib/api/projects');
+vitest_1.vi.mock('util');
+vitest_1.vi.mock('../../../package.json', () => {
+    return {
+        default: {
+            version: '1.0.0',
+        },
+    };
+});
+const DiagnosticInfoBuilder_1 = require("../DiagnosticInfoBuilder");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
+const fs_1 = require("@hubspot/local-dev-lib/fs");
+const config_2 = require("../../projects/config");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const walk = fs_1.walk;
+const getAccessToken = personalAccessKey_1.getAccessToken;
+const getAccountConfig = config_1.getAccountConfig;
+const getConfigPath = config_1.getConfigPath;
+const getDefaultAccountOverrideFilePath = config_1.getDefaultAccountOverrideFilePath;
+const getAccountId = config_1.getAccountId;
+const getProjectConfig = config_2.getProjectConfig;
+const isConfigFlagEnabled = config_1.isConfigFlagEnabled;
+const fetchProject = projects_1.fetchProject;
+const mockPromisifyImpl = vitest_1.vi.fn();
+const utilPromisify = vitest_1.vi.fn(() => mockPromisifyImpl);
+util_1.default.promisify = utilPromisify;
+describe('lib/doctor/DiagnosticInfo', () => {
+    const accountId = 898989;
+    const accountConfig = {
+        env: 'prod',
+        authType: 'personalaccesskey',
+        accountType: 'STANDARD',
+        personalAccessKey: 'super-secret-key',
+    };
+    const nodeVersion = 'v18.17.0';
+    const processInfo = {
+        platform: 'darwin',
+        arch: 'x64',
+        versions: { node: nodeVersion },
+        mainModule: { path: '/path/to/main/module' },
+    };
+    const projectDir = '/Users/test/project';
+    const projectFiles = [
+        `${projectDir}/.gitignore`,
+        `${projectDir}/README.md`,
+        // Config files
+        `${projectDir}/hsproject.json`,
+        `${projectDir}/src/app/app.json`,
+        `${projectDir}/src/app/public-app.json`,
+        // Serverless files
+        `${projectDir}/src/app/app.functions/.env`,
+        `${projectDir}/src/app/app.functions/function.js`,
+        `${projectDir}/src/app/app.functions/serverless.json`,
+        `${projectDir}/src/app/app.functions/package.json`,
+        `${projectDir}/src/app/app.functions/package-lock.json`,
+        // Extension files
+        `${projectDir}/src/app/extensions/extension.js`,
+        `${projectDir}/src/app/extensions/extension.json`,
+        `${projectDir}/src/app/extensions/package.json`,
+        `${projectDir}/src/app/extension/package-lock.json`,
+        `${projectDir}/src/app/app.functions/node_modules/axios`,
+    ];
+    const npmVersion = 'v8.17.0';
+    const configPath = '/path/to/config';
+    const defaultAccountOverrideFile = 'path/to/default/account/override/.hsaccount';
+    beforeEach(() => {
+        getAccountId.mockReturnValue(accountId);
+        getAccountConfig.mockReturnValue(accountConfig);
+        walk.mockResolvedValue(projectFiles);
+        isConfigFlagEnabled.mockReturnValue(false);
+        mockPromisifyImpl.mockResolvedValue(npmVersion);
+    });
+    it('should initialize the required state on creation', () => {
+        const builder = new DiagnosticInfoBuilder_1.DiagnosticInfoBuilder(processInfo);
+        expect(getAccountId).toHaveBeenCalledTimes(1);
+        expect(getAccountConfig).toHaveBeenCalledTimes(1);
+        expect(builder.accountId).toEqual(accountId);
+        expect(builder.env).toEqual(accountConfig.env);
+        expect(builder.authType).toEqual(accountConfig.authType);
+        expect(builder.accountType).toEqual(accountConfig.accountType);
+        expect(builder.personalAccessKey).toEqual(accountConfig.personalAccessKey);
+        expect(builder.processInfo).toEqual(processInfo);
+    });
+    describe('generateDiagnosticInfo', () => {
+        let builder;
+        let projectConfig;
+        let projectDetails;
+        let accessToken;
+        beforeEach(() => {
+            builder = new DiagnosticInfoBuilder_1.DiagnosticInfoBuilder(processInfo);
+            projectConfig = {
+                projectDir,
+                projectConfig: {
+                    name: 'My project',
+                    srcDir: 'project-dir',
+                    platformVersion: 'test',
+                },
+            };
+            projectDetails = {
+                createdAt: 12345,
+                deletedAt: 0,
+                deployedBuildId: 1,
+                id: 8989898,
+                isLocked: false,
+                name: projectConfig.projectConfig.name,
+                portalId: accountId,
+                updatedAt: 12345,
+            };
+            accessToken = {
+                accessToken: 'super-secret-dont-put-this-in-a-unit-test',
+                accountType: 'STANDARD',
+                encodedOAuthRefreshToken: '',
+                expiresAt: '',
+                hubName: projectConfig.projectConfig.name,
+                portalId: accountId,
+                scopeGroups: [],
+                enabledFeatures: {},
+            };
+            getProjectConfig.mockResolvedValue(projectConfig);
+            // @ts-expect-error - Mocking AxiosResponse
+            fetchProject.mockResolvedValue({
+                data: projectDetails,
+            });
+            getAccessToken.mockResolvedValue(accessToken);
+            getConfigPath.mockReturnValue(configPath);
+            getDefaultAccountOverrideFilePath.mockReturnValue(defaultAccountOverrideFile);
+        });
+        it('should gather the required data and generate the diagnostic', async () => {
+            const diagnosticInfo = await builder.generateDiagnosticInfo();
+            expect(getProjectConfig).toHaveBeenCalledTimes(1);
+            expect(fetchProject).toHaveBeenCalledTimes(1);
+            expect(fetchProject).toHaveBeenCalledWith(accountId, projectConfig.projectConfig.name);
+            expect(getAccessToken).toHaveBeenCalledTimes(1);
+            expect(getAccessToken).toHaveBeenCalledWith(accountConfig.personalAccessKey, accountConfig.env, accountId);
+            // @ts-expect-error Accessing private field
+            expect(builder._projectConfig).toEqual(projectConfig);
+            expect(diagnosticInfo).toMatchSnapshot();
+        });
+        it('should handle errors when fetching project details', async () => {
+            fetchProject.mockRejectedValue(new Error('Failed to fetch project details'));
+            const diagnosticInfo = await builder.generateDiagnosticInfo();
+            expect(fetchProject).toHaveBeenCalledTimes(1);
+            expect(diagnosticInfo.project.details).toBeUndefined();
+        });
+        it('should handle errors when fetching access token', async () => {
+            getAccessToken.mockRejectedValue(new Error('Failed to fetch access token'));
+            const diagnosticInfo = await builder.generateDiagnosticInfo();
+            expect(getAccessToken).toHaveBeenCalledTimes(1);
+            expect(diagnosticInfo.account.name).toBeUndefined();
+            expect(diagnosticInfo.account.scopeGroups).toBeUndefined();
+            expect(diagnosticInfo.account.enabledFeatures).toBeUndefined();
+        });
+        it('should handle errors when fetching project filenames', async () => {
+            walk.mockRejectedValue(new Error('Failed to walk project directory'));
+            const diagnosticInfo = await builder.generateDiagnosticInfo();
+            expect(walk).toHaveBeenCalledTimes(1);
+            expect(diagnosticInfo.files).toEqual([]);
+        });
+    });
+});

package/lib/doctor/__tests__/Doctor.test.d.ts

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

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

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Doctor_1 = require("../Doctor");
+const dependencyManagement_1 = require("../../dependencyManagement");
+const portManager_1 = require("@hubspot/local-dev-lib/portManager");
+const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
+const HubSpotHttpError_1 = require("@hubspot/local-dev-lib/models/HubSpotHttpError");
+const axios_1 = require("axios");
+const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const util_1 = require("util");
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../Diagnosis');
+vi.mock('../../ui/SpinniesManager');
+vi.mock('../DiagnosticInfoBuilder');
+vi.mock('../../dependencyManagement');
+vi.mock('../../npm');
+vi.mock('@hubspot/local-dev-lib/portManager');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('util');
+const hasMissingPackages = vi.mocked(dependencyManagement_1.hasMissingPackages);
+const isPortManagerPortAvailable = vi.mocked(portManager_1.isPortManagerPortAvailable);
+const utilPromisify = vi.mocked(util_1.promisify);
+const accessTokenForPersonalAccessKey = vi.mocked(personalAccessKey_1.accessTokenForPersonalAccessKey);
+const authorizedScopesForPortalAndUser = vi.mocked(personalAccessKey_1.authorizedScopesForPortalAndUser);
+const scopesOnAccessToken = vi.mocked(personalAccessKey_1.scopesOnAccessToken);
+const isSpecifiedError = vi.mocked(index_1.isSpecifiedError);
+describe('lib/doctor/Doctor', () => {
+    let doctor;
+    // @ts-ignore
+    const diagnosticInfo = {
+        account: {},
+        arch: 'x64',
+        config: 'path/to/config',
+        configSettings: { httpUseLocalhost: false },
+        configFiles: ['src/serverless.json'],
+        diagnosis: '',
+        envFiles: [],
+        files: [],
+        jsonFiles: ['src/serverless.json', 'src/extension.json'],
+        packageFiles: ['src/package.json'],
+        packageLockFiles: ['src/package-lock.json'],
+        path: '',
+        platform: 'darwin',
+        project: {
+            config: {
+                projectDir: '/path/to/project',
+                projectConfig: {
+                    name: 'my-project',
+                    srcDir: '/path/to/project',
+                    platformVersion: 'test',
+                },
+            },
+        },
+        versions: {
+            node: '18.1.2',
+            '@hubspot/cli': '6.0.0',
+            npm: '6.14.13',
+        },
+    };
+    beforeEach(() => {
+        doctor = new Doctor_1.Doctor({
+            generateDiagnosticInfo: vi.fn().mockResolvedValue({
+                ...diagnosticInfo,
+            }),
+        });
+        utilPromisify.mockReturnValue(vi.fn().mockImplementation((filename) => {
+            if (filename.includes('invalid')) {
+                return 'not-valid-json';
+            }
+            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 () => {
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCliSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: `node v${diagnosticInfo.versions.node} is installed`,
+                });
+            });
+            it('should add error section if node version is not available', async () => {
+                doctor = new Doctor_1.Doctor({
+                    generateDiagnosticInfo: vi.fn().mockResolvedValue({
+                        ...diagnosticInfo,
+                        versions: {},
+                    }),
+                });
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCliSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: 'Unable to determine what version of node is installed',
+                });
+            });
+            it('should add error section if minimum node version is not met', async () => {
+                doctor = new Doctor_1.Doctor({
+                    generateDiagnosticInfo: vi.fn().mockResolvedValue({
+                        ...diagnosticInfo,
+                        versions: { node: '1.0.0' },
+                    }),
+                });
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCliSection).toHaveBeenCalledWith({
+                    type: 'warning',
+                    message: expect.stringMatching(/Minimum Node version is not met/),
+                });
+            });
+        });
+        describe('npm version', () => {
+            it('should add success section if npm is installed', async () => {
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCliSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: `npm v${diagnosticInfo.versions.npm} is installed`,
+                });
+            });
+            it('should add error section if npm is not installed', async () => {
+                doctor = new Doctor_1.Doctor({
+                    generateDiagnosticInfo: vi.fn().mockResolvedValue({
+                        ...diagnosticInfo,
+                        versions: {},
+                    }),
+                });
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCliSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: expect.any(String),
+                });
+            });
+        });
+    });
+    describe('CLI Config Checks', () => {
+        describe('Personal Access Key', () => {
+            it('should add success sections if the access token is valid', async () => {
+                scopesOnAccessToken.mockResolvedValueOnce(['scope1']);
+                authorizedScopesForPortalAndUser.mockResolvedValueOnce([
+                    {
+                        scopeGroup: {
+                            name: 'scope1',
+                            shortDescription: 'scope1',
+                            longDescription: 'scope1',
+                        },
+                        portalAuthorized: true,
+                        userAuthorized: true,
+                    },
+                ]);
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: 'Default account active',
+                });
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: expect.stringMatching(/Personal Access Key is valid./),
+                });
+            });
+            it('should add an error section if it is unable to determine if the portal is active', async () => {
+                accessTokenForPersonalAccessKey.mockRejectedValueOnce(new HubSpotHttpError_1.HubSpotHttpError('Invalid token', { cause: new axios_1.AxiosError() }));
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: 'Unable to determine if the portal is active',
+                });
+            });
+            it('should add an error section if the portal is inactive', async () => {
+                accessTokenForPersonalAccessKey.mockRejectedValueOnce(new HubSpotHttpError_1.HubSpotHttpError('Invalid token'));
+                isSpecifiedError.mockImplementation((err, fields) => {
+                    return (fields.statusCode === 401 &&
+                        fields.category === 'INVALID_AUTHENTICATION' &&
+                        fields?.subCategory === 'LocalDevAuthErrorType.PORTAL_NOT_ACTIVE');
+                });
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: "Default account isn't active",
+                    secondaryMessaging: expect.stringMatching(/to remove inactive accounts from your CLI config/),
+                });
+            });
+            it('should add an error section if the portal is not found', async () => {
+                accessTokenForPersonalAccessKey.mockRejectedValueOnce(new HubSpotHttpError_1.HubSpotHttpError('Not found'));
+                isSpecifiedError.mockImplementation((err, fields) => {
+                    return (fields.statusCode === 404 &&
+                        fields.category === 'INVALID_AUTHENTICATION' &&
+                        fields?.subCategory === 'LocalDevAuthErrorType.INVALID_PORTAL_ID');
+                });
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: "Default account isn't active",
+                    secondaryMessaging: expect.stringMatching(/to remove inactive accounts from your CLI config/),
+                });
+            });
+            it('should add multiple sections if token is invalid but the portal is active', async () => {
+                accessTokenForPersonalAccessKey.mockRejectedValueOnce(new HubSpotHttpError_1.HubSpotHttpError('Not found'));
+                isSpecifiedError.mockImplementation((err, fields) => {
+                    return (fields.statusCode === 401 &&
+                        fields.category === 'INVALID_AUTHENTICATION' &&
+                        fields?.subCategory ===
+                            'LocalDevAuthErrorType.FAILED_TO_SIGN_REFRESH_TOKEN_DECODE');
+                });
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: 'Default account active',
+                });
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: 'Personal access key is invalid',
+                    secondaryMessaging: expect.stringMatching(/To get a new key, run/),
+                });
+            });
+            it('should add an error section if we are unable to determine if the portal is active', async () => {
+                accessTokenForPersonalAccessKey.mockRejectedValueOnce(new HubSpotHttpError_1.HubSpotHttpError('Not found'));
+                isSpecifiedError.mockReturnValue(false);
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    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),
+                });
+            });
+            it('should not warn when the missing scope is not authorized', async () => {
+                scopesOnAccessToken.mockResolvedValueOnce(['scope1']);
+                authorizedScopesForPortalAndUser.mockResolvedValueOnce([
+                    {
+                        scopeGroup: {
+                            name: 'scope1',
+                            shortDescription: 'scope1',
+                            longDescription: 'scope1',
+                        },
+                        portalAuthorized: true,
+                        userAuthorized: true,
+                    },
+                    {
+                        scopeGroup: {
+                            name: 'scope2',
+                            shortDescription: 'scope2',
+                            longDescription: 'scope2',
+                        },
+                        portalAuthorized: true,
+                        userAuthorized: false,
+                    },
+                ]);
+                await doctor.diagnose();
+                expect(doctor['diagnosis']?.addCLIConfigSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: expect.stringMatching(/Personal Access Key is valid./),
+                });
+            });
+        });
+    });
+    describe('Project Checks', () => {
+        describe('Dependencies', () => {
+            it('should add warning section if dependencies are missing', async () => {
+                hasMissingPackages.mockResolvedValue(true);
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                    type: 'warning',
+                    message: expect.stringMatching(/missing dependencies in/),
+                    secondaryMessaging: expect.stringMatching(/to install all project dependencies locally/),
+                });
+            });
+            it('should add success section if no dependencies are missing', async () => {
+                hasMissingPackages.mockResolvedValue(false);
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: 'App dependencies are installed and up to date',
+                });
+            });
+            it('should add error section if the package.json file is invalid JSON', async () => {
+                hasMissingPackages.mockImplementationOnce(() => {
+                    throw new Error('Uh oh');
+                });
+                utilPromisify.mockReturnValueOnce(vi.fn().mockImplementation((filename) => {
+                    if (filename.endsWith('package.json')) {
+                        return 'not-valid-json';
+                    }
+                    return JSON.stringify({ valid: true });
+                }));
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: expect.stringMatching(/invalid JSON in/),
+                });
+            });
+            it('should add error section if it is unable to determine if dependencies need installed', async () => {
+                hasMissingPackages.mockImplementationOnce(() => {
+                    throw new Error('Uh oh');
+                });
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: expect.stringMatching(/Unable to determine if dependencies are installed/),
+                });
+            });
+        });
+        describe('Port', () => {
+            it('should add warning section if port is in use', async () => {
+                isPortManagerPortAvailable.mockResolvedValue(false);
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis?.addProjectSection).toHaveBeenCalledWith({
+                    type: 'warning',
+                    message: 'Port 8080 is in use',
+                    secondaryMessaging: expect.stringMatching(/Make sure it is available if before running/),
+                });
+            });
+            it('should add success section if port is available', async () => {
+                isPortManagerPortAvailable.mockResolvedValue(true);
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: 'Port 8080 available for local development',
+                });
+            });
+        });
+        describe('JSON Files', () => {
+            it('should add success section if project json files are valid', async () => {
+                utilPromisify.mockReturnValueOnce(vi.fn().mockResolvedValue(JSON.stringify({ valid: true })));
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                    type: 'success',
+                    message: 'JSON files valid',
+                });
+            });
+            it('should add error section if project json files are invalid', async () => {
+                utilPromisify.mockReturnValueOnce(vi.fn().mockResolvedValue('not-valid-json'));
+                await doctor.diagnose();
+                // @ts-expect-error Testing private method
+                expect(doctor.diagnosis.addProjectSection).toHaveBeenCalledWith({
+                    type: 'error',
+                    message: expect.stringMatching(/invalid JSON in/),
+                });
+            });
+        });
+    });
+});

package/lib/mcp/setup.js

@@ -112,9 +112,9 @@ function setupMcpConfigFile(config) {
             fs_extra_1.default.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
         }
         let mcpConfig = {};
+        let configContent;
         try {
-            const configContent = fs_extra_1.default.readFileSync(config.configPath, 'utf8');
-            mcpConfig = JSON.parse(configContent);
+            configContent = fs_extra_1.default.readFileSync(config.configPath, 'utf8');
         }
         catch (error) {
             SpinniesManager_1.default.fail('spinner', {
@@ -123,6 +123,22 @@ function setupMcpConfigFile(config) {
             (0, errorHandlers_1.logError)(error);
             return false;
         }
+        try {
+            // In the event the file exists, but is empty, initialize it to and empty object
+            if (configContent.trim() === '') {
+                mcpConfig = {};
+            }
+            else {
+                mcpConfig = JSON.parse(configContent);
+            }
+        }
+        catch (error) {
+            SpinniesManager_1.default.fail('spinner', {
+                text: config.failedMessage,
+            });
+            logger_1.uiLogger.error(en_1.commands.mcp.setup.errors.errorParsingJsonFIle(config.configPath, error instanceof Error ? error.message : `${error}`));
+            return false;
+        }
         // Initialize mcpServers if it doesn't exist
         if (!mcpConfig.mcpServers) {
             mcpConfig.mcpServers = {};

package/lib/middleware/__test__/configMiddleware.test.js

@@ -38,21 +38,21 @@ const cliConfig = __importStar(require("@hubspot/local-dev-lib/config"));
 const validation = __importStar(require("../../validation"));
 const exitCodes_1 = require("../../enums/exitCodes");
 const configMiddleware_1 = require("../configMiddleware");
-jest.mock('@hubspot/local-dev-lib/logger', () => ({
+vi.mock('@hubspot/local-dev-lib/logger', () => ({
     logger: {
-        error: jest.fn(),
-        log: jest.fn(),
+        error: vi.fn(),
+        log: vi.fn(),
     },
 }));
-jest.mock('@hubspot/local-dev-lib/config');
-jest.mock('../../validation');
-const validateAccountSpy = jest.spyOn(validation, 'validateAccount');
-const loadConfigSpy = jest.spyOn(cliConfig, 'loadConfig');
-const getAccountIdSpy = jest.spyOn(cliConfig, 'getAccountId');
-const configFileExistsSpy = jest.spyOn(cliConfig, 'configFileExists');
-const getConfigPathSpy = jest.spyOn(cliConfig, 'getConfigPath');
-const validateConfigSpy = jest.spyOn(cliConfig, 'validateConfig');
-const processExitSpy = jest.spyOn(process, 'exit');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../validation');
+const validateAccountSpy = vi.spyOn(validation, 'validateAccount');
+const loadConfigSpy = vi.spyOn(cliConfig, 'loadConfig');
+const getAccountIdSpy = vi.spyOn(cliConfig, 'getAccountId');
+const configFileExistsSpy = vi.spyOn(cliConfig, 'configFileExists');
+const getConfigPathSpy = vi.spyOn(cliConfig, 'getConfigPath');
+const validateConfigSpy = vi.spyOn(cliConfig, 'validateConfig');
+const processExitSpy = vi.spyOn(process, 'exit');
 describe('lib/middleware/configMiddleware', () => {
     beforeEach(() => {
         processExitSpy.mockImplementation(code => {

package/lib/middleware/__test__/gitMiddleware.test.js

@@ -36,10 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const config = __importStar(require("@hubspot/local-dev-lib/config"));
 const gitUI = __importStar(require("../../ui/git"));
 const gitMiddleware_1 = require("../gitMiddleware");
-jest.mock('@hubspot/local-dev-lib/config');
-jest.mock('../../ui/git');
-const getConfigPathSpy = jest.spyOn(config, 'getConfigPath');
-const checkAndWarnGitInclusionSpy = jest.spyOn(gitUI, 'checkAndWarnGitInclusion');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../ui/git');
+const getConfigPathSpy = vi.spyOn(config, 'getConfigPath');
+const checkAndWarnGitInclusionSpy = vi.spyOn(gitUI, 'checkAndWarnGitInclusion');
 describe('lib/middleware/gitMiddleware', () => {
     describe('checkAndWarnGitInclusionMiddleware()', () => {
         it('should call checkAndWarnGitInclusion when command is provided and config path exists', () => {