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

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const { notifyAboutUpdates } = require('../notificationsMiddleware');
+const notificationsMiddleware_1 = require("../notificationsMiddleware");
 describe('lib/middleware/notificationsMiddleware', () => {
     describe('notifyAboutUpdates()', () => {
         it('should safely execute without throwing an error', () => {
-            expect(() => notifyAboutUpdates()).not.toThrow();
+            expect(() => (0, notificationsMiddleware_1.notifyAboutUpdates)()).not.toThrow();
         });
     });
 });

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

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const http_1 = require("@hubspot/local-dev-lib/http");
 const requestMiddleware_1 = require("../requestMiddleware");
 const package_json_1 = __importDefault(require("../../../package.json"));
-jest.mock('@hubspot/local-dev-lib/http', () => ({
-    addUserAgentHeader: jest.fn(),
+vi.mock('@hubspot/local-dev-lib/http', () => ({
+    addUserAgentHeader: vi.fn(),
 }));
 describe('lib/middleware/requestMiddleware', () => {
     describe('setRequestHeaders()', () => {

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

@@ -37,17 +37,17 @@ const logger_1 = require("@hubspot/local-dev-lib/logger");
 const exitCodes_1 = require("../../enums/exitCodes");
 const projectsConfig = __importStar(require("../../projects/config"));
 const yargsChecksMiddleware_1 = require("../yargsChecksMiddleware");
-jest.mock('@hubspot/local-dev-lib/logger', () => ({
+vi.mock('@hubspot/local-dev-lib/logger', () => ({
     logger: {
-        error: jest.fn(),
+        error: vi.fn(),
     },
 }));
-jest.mock('../../projects/config');
-jest.mock('../../lang', () => ({
-    i18n: jest.fn(key => key),
+vi.mock('../../projects/config');
+vi.mock('../../lang', () => ({
+    i18n: vi.fn(key => key),
 }));
-const getIsInProjectSpy = jest.spyOn(projectsConfig, 'getIsInProject');
-const processExitSpy = jest.spyOn(process, 'exit');
+const getIsInProjectSpy = vi.spyOn(projectsConfig, 'getIsInProject');
+const processExitSpy = vi.spyOn(process, 'exit');
 describe('lib/middleware/yargsChecksMiddleware', () => {
     beforeEach(() => {
         processExitSpy.mockImplementation(code => {

package/lib/middleware/notificationsMiddleware.js

@@ -1,38 +1,41 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.notifyAboutUpdates = notifyAboutUpdates;
 // Update-notifier is CommonJS, so we need to use require
 const updateNotifier = require('update-notifier');
-const chalk = require('chalk');
-const pkg = require('../../package.json');
-const { UI_COLORS, uiCommandReference } = require('../ui');
-const { i18n } = require('../lang');
+const chalk_1 = __importDefault(require("chalk"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const ui_1 = require("../ui");
+const lang_1 = require("../lang");
 const notifier = updateNotifier({
-    pkg: { ...pkg, name: '@hubspot/cli' },
+    pkg: { ...package_json_1.default, name: '@hubspot/cli' },
     distTag: 'latest',
     shouldNotifyInNpmScript: true,
 });
 const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
 function notifyAboutUpdates() {
     notifier.notify({
-        message: pkg.name === CMS_CLI_PACKAGE_NAME
-            ? i18n(`commands.generalErrors.updateNotify.cmsUpdateNotification`, {
+        message: package_json_1.default.name === CMS_CLI_PACKAGE_NAME
+            ? (0, lang_1.i18n)(`commands.generalErrors.updateNotify.cmsUpdateNotification`, {
                 packageName: CMS_CLI_PACKAGE_NAME,
-                updateCommand: uiCommandReference('{updateCommand}'),
+                updateCommand: (0, ui_1.uiCommandReference)('{updateCommand}'),
             })
-            : i18n(`commands.generalErrors.updateNotify.cliUpdateNotification`, {
-                updateCommand: uiCommandReference('{updateCommand}'),
+            : (0, lang_1.i18n)(`commands.generalErrors.updateNotify.cliUpdateNotification`, {
+                updateCommand: (0, ui_1.uiCommandReference)('{updateCommand}'),
             }),
         defer: false,
         boxenOptions: {
-            borderColor: UI_COLORS.MARIGOLD_DARK,
+            borderColor: ui_1.UI_COLORS.MARIGOLD_DARK,
             margin: 1,
             padding: 1,
             textAlignment: 'center',
             borderStyle: 'round',
-            title: pkg.name === CMS_CLI_PACKAGE_NAME
+            title: package_json_1.default.name === CMS_CLI_PACKAGE_NAME
                 ? null
-                : chalk.bold(i18n(`commands.generalErrors.updateNotify.notifyTitle`)),
+                : chalk_1.default.bold((0, lang_1.i18n)(`commands.generalErrors.updateNotify.notifyTitle`)),
         },
     });
 }

package/lib/projects/__tests__/AppDevModeInterface.test.d.ts

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

package/lib/projects/__tests__/AppDevModeInterface.test.js

@@ -0,0 +1,517 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Mock the ui-extensions-dev-server module
+vitest_1.vi.mock('@hubspot/ui-extensions-dev-server', () => {
+    return {
+        DevModeUnifiedInterface: {
+            setup: vitest_1.vi.fn().mockResolvedValue(undefined),
+            start: vitest_1.vi.fn().mockResolvedValue(undefined),
+            fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
+            cleanup: vitest_1.vi.fn().mockResolvedValue(undefined),
+        },
+    };
+});
+const localDevAuth_1 = require("@hubspot/local-dev-lib/api/localDevAuth");
+const appsDev_1 = require("@hubspot/local-dev-lib/api/appsDev");
+const ui_extensions_dev_server_1 = require("@hubspot/ui-extensions-dev-server");
+const portManager_1 = require("@hubspot/local-dev-lib/portManager");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const AppDevModeInterface_1 = __importDefault(require("../localDev/AppDevModeInterface"));
+const LocalDevState_1 = __importDefault(require("../localDev/LocalDevState"));
+const LocalDevLogger_1 = __importDefault(require("../localDev/LocalDevLogger"));
+const installAppPrompt_1 = require("../../prompts/installAppPrompt");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const urls_1 = require("../../app/urls");
+const accountTypes_1 = require("../../accountTypes");
+const index_1 = require("../../errorHandlers/index");
+const constants_1 = require("../../constants");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+vitest_1.vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
+vitest_1.vi.mock('@hubspot/local-dev-lib/api/appsDev');
+vitest_1.vi.mock('@hubspot/local-dev-lib/portManager');
+vitest_1.vi.mock('@hubspot/local-dev-lib/config');
+vitest_1.vi.mock('../../prompts/installAppPrompt');
+vitest_1.vi.mock('../../prompts/promptUtils');
+vitest_1.vi.mock('../../app/urls');
+vitest_1.vi.mock('../../accountTypes');
+vitest_1.vi.mock('../../ui/logger');
+vitest_1.vi.mock('../../errorHandlers/index');
+vitest_1.vi.mock('../localDev/LocalDevState');
+vitest_1.vi.mock('../localDev/LocalDevLogger');
+describe('AppDevModeInterface', () => {
+    let appDevModeInterface;
+    let mockLocalDevState;
+    let mockLocalDevLogger;
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: '1.0.0',
+    };
+    const mockAppNode = {
+        uid: 'test-app-uid',
+        componentType: 'APPLICATION',
+        config: {
+            name: 'Test App',
+            description: 'Test app description',
+            logo: 'logo.png',
+            auth: {
+                type: constants_1.APP_AUTH_TYPES.STATIC,
+                requiredScopes: ['test-scope'],
+                optionalScopes: [],
+                conditionallyRequiredScopes: [],
+                redirectUrls: ['http://localhost:3000'],
+            },
+            distribution: constants_1.APP_DISTRIBUTION_TYPES.PRIVATE,
+        },
+        localDev: {
+            componentRoot: '/test/path',
+            componentConfigPath: '/test/path/config.json',
+            configUpdatedSinceLastUpload: false,
+        },
+        componentDeps: {},
+        metaFilePath: '/test/path',
+        files: [],
+    };
+    const mockAppData = {
+        id: 123,
+        clientId: 'test-client-id',
+        name: 'Test App',
+        installationState: constants_1.APP_INSTALLATION_STATES.NOT_INSTALLED,
+        scopeGroupIds: [1, 2, 3],
+    };
+    const mockPublicApp = {
+        id: 123,
+        clientId: 'test-client-id',
+        name: 'Test App',
+        sourceId: 'test-app-uid',
+        scopeGroupIds: [1, 2, 3],
+    };
+    beforeEach(() => {
+        vitest_1.vi.clearAllMocks();
+        mockLocalDevState = {
+            targetProjectAccountId: 12345,
+            targetTestingAccountId: 67890,
+            projectConfig: mockProjectConfig,
+            projectDir: '/test/project',
+            projectId: 999,
+            env: environments_1.ENVIRONMENTS.PROD,
+            projectNodes: { [mockAppNode.uid]: mockAppNode },
+            getAppDataByUid: vitest_1.vi.fn(),
+            setAppDataForUid: vitest_1.vi.fn(),
+            addListener: vitest_1.vi.fn(),
+        };
+        mockLocalDevLogger = {
+            addUploadWarning: vitest_1.vi.fn(),
+        };
+        // Mock constructors
+        LocalDevState_1.default.mockImplementation(() => mockLocalDevState);
+        LocalDevLogger_1.default.mockImplementation(() => mockLocalDevLogger);
+        // Mock external dependencies
+        appsDev_1.fetchPublicAppsForPortal.mockResolvedValue({
+            data: { results: [mockPublicApp] },
+        });
+        appsDev_1.fetchPublicAppProductionInstallCounts.mockResolvedValue({
+            data: { uniquePortalInstallCount: 5 },
+        });
+        localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+            data: {
+                isInstalledWithScopeGroups: true,
+                previouslyAuthorizedScopeGroups: [],
+            },
+        });
+        config_1.getAccountConfig.mockReturnValue({
+            parentAccountId: 12345,
+        });
+        accountTypes_1.isDeveloperTestAccount.mockReturnValue(true);
+        accountTypes_1.isSandbox.mockReturnValue(false);
+        urls_1.getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
+        urls_1.getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
+        installAppPrompt_1.installAppAutoPrompt.mockResolvedValue(true);
+        installAppPrompt_1.installAppBrowserPrompt.mockResolvedValue(undefined);
+        promptUtils_1.confirmPrompt.mockResolvedValue(true);
+        appsDev_1.installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
+        // Mock process.exit
+        vitest_1.vi.spyOn(global.process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process.exit called with code ${code}`);
+        });
+        appDevModeInterface = new AppDevModeInterface_1.default({
+            localDevState: mockLocalDevState,
+            localDevLogger: mockLocalDevLogger,
+        });
+    });
+    describe('constructor', () => {
+        it('should initialize with valid state', () => {
+            expect(appDevModeInterface).toBeInstanceOf(AppDevModeInterface_1.default);
+            expect(appDevModeInterface.localDevState).toBe(mockLocalDevState);
+            expect(appDevModeInterface.localDevLogger).toBe(mockLocalDevLogger);
+        });
+        it('should exit if targetProjectAccountId is missing', () => {
+            const mockLocalDevStateWithoutAccountId = {
+                ...mockLocalDevState,
+                targetProjectAccountId: null,
+            };
+            expect(() => {
+                new AppDevModeInterface_1.default({
+                    localDevState: mockLocalDevStateWithoutAccountId,
+                    localDevLogger: mockLocalDevLogger,
+                });
+            }).toThrow('Process.exit called with code 1');
+        });
+        it('should exit if projectConfig is missing', () => {
+            const mockLocalDevStateWithoutConfig = {
+                ...mockLocalDevState,
+                projectConfig: null,
+            };
+            expect(() => {
+                new AppDevModeInterface_1.default({
+                    localDevState: mockLocalDevStateWithoutConfig,
+                    localDevLogger: mockLocalDevLogger,
+                });
+            }).toThrow('Process.exit called with code 1');
+        });
+        it('should exit if projectDir is missing', () => {
+            const mockLocalDevStateWithoutDir = {
+                ...mockLocalDevState,
+                projectDir: null,
+            };
+            expect(() => {
+                new AppDevModeInterface_1.default({
+                    localDevState: mockLocalDevStateWithoutDir,
+                    localDevLogger: mockLocalDevLogger,
+                });
+            }).toThrow('Process.exit called with code 1');
+        });
+    });
+    describe('setup()', () => {
+        beforeEach(() => {
+            mockLocalDevState.getAppDataByUid.mockReturnValue(mockAppData);
+        });
+        it('should return early if no app node exists', async () => {
+            mockLocalDevState.projectNodes = {};
+            await appDevModeInterface.setup({});
+            expect(appsDev_1.fetchPublicAppsForPortal).not.toHaveBeenCalled();
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.setup).not.toHaveBeenCalled();
+        });
+        it('should setup successfully with private app', async () => {
+            await appDevModeInterface.setup({});
+            expect(appsDev_1.fetchPublicAppsForPortal).toHaveBeenCalledWith(12345);
+            expect(appsDev_1.fetchPublicAppProductionInstallCounts).toHaveBeenCalledWith(123, 12345);
+            expect(localDevAuth_1.fetchAppInstallationData).toHaveBeenCalledWith(67890, 999, 'test-app-uid', ['test-scope'], []);
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.setup).toHaveBeenCalled();
+        });
+        it('should show marketplace warning for marketplace apps', async () => {
+            const marketplaceAppNode = {
+                ...mockAppNode,
+                config: {
+                    ...mockAppNode.config,
+                    distribution: constants_1.APP_DISTRIBUTION_TYPES.MARKETPLACE,
+                },
+            };
+            mockLocalDevState.projectNodes = {
+                [marketplaceAppNode.uid]: marketplaceAppNode,
+            };
+            await appDevModeInterface.setup({});
+            expect(promptUtils_1.confirmPrompt).toHaveBeenCalled();
+            expect(mockLocalDevLogger.addUploadWarning).toHaveBeenCalled();
+        });
+        it('should exit if user declines marketplace warning', async () => {
+            const marketplaceAppNode = {
+                ...mockAppNode,
+                config: {
+                    ...mockAppNode.config,
+                    distribution: constants_1.APP_DISTRIBUTION_TYPES.MARKETPLACE,
+                },
+            };
+            mockLocalDevState.projectNodes = {
+                [marketplaceAppNode.uid]: marketplaceAppNode,
+            };
+            // Set up conditions to trigger marketplace warning
+            appsDev_1.fetchPublicAppProductionInstallCounts.mockResolvedValue({
+                data: { uniquePortalInstallCount: 5 },
+            });
+            mockLocalDevState.getAppDataByUid.mockReturnValue(mockAppData);
+            promptUtils_1.confirmPrompt.mockResolvedValue(false);
+            // Create a new instance to trigger the exit during setup
+            const newAppDevModeInterface = new AppDevModeInterface_1.default({
+                localDevState: mockLocalDevState,
+                localDevLogger: mockLocalDevLogger,
+            });
+            // The setup method catches the error, so we check that process.exit was called
+            await newAppDevModeInterface.setup({});
+            expect(process.exit).toHaveBeenCalledWith(0);
+        });
+        it('should auto-install static auth app on test account', async () => {
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            await appDevModeInterface.setup({});
+            expect(appsDev_1.installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(123, 67890, [1, 2, 3]);
+        });
+        it('should open browser for OAuth app installation', async () => {
+            const oauthAppNode = {
+                ...mockAppNode,
+                config: {
+                    ...mockAppNode.config,
+                    auth: {
+                        ...mockAppNode.config.auth,
+                        type: constants_1.APP_AUTH_TYPES.OAUTH,
+                    },
+                },
+            };
+            mockLocalDevState.projectNodes = { [oauthAppNode.uid]: oauthAppNode };
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            await appDevModeInterface.setup({});
+            expect(urls_1.getOauthAppInstallUrl).toHaveBeenCalledWith({
+                targetAccountId: 67890,
+                env: environments_1.ENVIRONMENTS.PROD,
+                clientId: 'test-client-id',
+                scopes: ['test-scope'],
+                redirectUrls: ['http://localhost:3000'],
+            });
+            expect(installAppPrompt_1.installAppBrowserPrompt).toHaveBeenCalled();
+        });
+        it('should handle app reinstallation', async () => {
+            // Set up conditions for non-automatic installation
+            config_1.getAccountConfig.mockReturnValue(null);
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: ['old-scope'],
+                },
+            });
+            await appDevModeInterface.setup({});
+            expect(installAppPrompt_1.installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
+        });
+        it('should handle errors during setup', async () => {
+            const error = new Error('Setup failed');
+            appsDev_1.fetchPublicAppsForPortal.mockRejectedValue(error);
+            await appDevModeInterface.setup({});
+            expect(index_1.logError).toHaveBeenCalledWith(error);
+        });
+        it('should exit if app not found in portal', async () => {
+            // Set up conditions for non-automatic installation to force getAppInstallUrl call
+            config_1.getAccountConfig.mockReturnValue(null);
+            // First call for fetchAppData succeeds
+            appsDev_1.fetchPublicAppsForPortal
+                .mockResolvedValueOnce({
+                data: { results: [mockPublicApp] },
+            })
+                // Second call for getAppInstallUrl fails (app not found)
+                .mockResolvedValueOnce({
+                data: { results: [] },
+            });
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            // The setup method catches the error, so we check that process.exit was called
+            await appDevModeInterface.setup({});
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('should exit if user declines auto-install', async () => {
+            // Set up conditions for automatic installation
+            config_1.getAccountConfig.mockReturnValue({
+                parentAccountId: 12345, // matches targetProjectAccountId
+            });
+            accountTypes_1.isDeveloperTestAccount.mockReturnValue(true);
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            installAppPrompt_1.installAppAutoPrompt.mockResolvedValue(false);
+            // Create a new instance to trigger the exit during setup
+            const newAppDevModeInterface = new AppDevModeInterface_1.default({
+                localDevState: mockLocalDevState,
+                localDevLogger: mockLocalDevLogger,
+            });
+            // The setup method catches the error, so we check that process.exit was called
+            await newAppDevModeInterface.setup({});
+            expect(process.exit).toHaveBeenCalledWith(0);
+        });
+        it('should fallback to browser install if auto-install fails', async () => {
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            appsDev_1.installStaticAuthAppOnTestAccount.mockRejectedValue(new Error('Install failed'));
+            await appDevModeInterface.setup({});
+            expect(installAppPrompt_1.installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', false);
+        });
+    });
+    describe('start()', () => {
+        it('should return early if no app node exists', async () => {
+            mockLocalDevState.projectNodes = {};
+            await appDevModeInterface.start();
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.start).not.toHaveBeenCalled();
+        });
+        it('should start UIE dev mode interface', async () => {
+            await appDevModeInterface.start();
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.start).toHaveBeenCalledWith({
+                accountId: 67890,
+                projectConfig: mockProjectConfig,
+                requestPorts: portManager_1.requestPorts,
+            });
+        });
+    });
+    describe('fileChange()', () => {
+        it('should return early if no app node exists', async () => {
+            mockLocalDevState.projectNodes = {};
+            await appDevModeInterface.fileChange('test.js', 'change');
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.fileChange).not.toHaveBeenCalled();
+        });
+        it('should forward file change to UIE dev mode interface', async () => {
+            await appDevModeInterface.fileChange('test.js', 'change');
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.fileChange).toHaveBeenCalledWith('test.js', 'change');
+        });
+    });
+    describe('cleanup()', () => {
+        it('should return early if no app node exists', async () => {
+            mockLocalDevState.projectNodes = {};
+            await appDevModeInterface.cleanup();
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.cleanup).not.toHaveBeenCalled();
+        });
+        it('should cleanup UIE dev mode interface', async () => {
+            await appDevModeInterface.cleanup();
+            expect(ui_extensions_dev_server_1.DevModeUnifiedInterface.cleanup).toHaveBeenCalled();
+        });
+    });
+    describe('isAutomaticallyInstallable()', () => {
+        it('should return true for static auth app on test account with correct parent', () => {
+            // This is testing private method behavior through setup()
+            expect(appDevModeInterface).toBeDefined();
+        });
+        it('should return false if target account config is missing', async () => {
+            // Reset mocks to ensure clean state
+            vitest_1.vi.clearAllMocks();
+            // Set up basic mocks
+            appsDev_1.fetchPublicAppsForPortal.mockResolvedValue({
+                data: { results: [mockPublicApp] },
+            });
+            appsDev_1.fetchPublicAppProductionInstallCounts.mockResolvedValue({
+                data: { uniquePortalInstallCount: 5 },
+            });
+            urls_1.getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
+            installAppPrompt_1.installAppBrowserPrompt.mockResolvedValue(undefined);
+            // Reset the mock LocalDevState
+            mockLocalDevState.getAppDataByUid = vitest_1.vi.fn().mockReturnValue(mockAppData);
+            mockLocalDevState.setAppDataForUid = vitest_1.vi.fn();
+            mockLocalDevState.addListener = vitest_1.vi.fn();
+            // Target account config is missing
+            config_1.getAccountConfig.mockReturnValue(null);
+            // App is not installed
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            // Create a new instance to avoid interference from previous test setup
+            const newAppDevModeInterface = new AppDevModeInterface_1.default({
+                localDevState: mockLocalDevState,
+                localDevLogger: mockLocalDevLogger,
+            });
+            await newAppDevModeInterface.setup({});
+            expect(installAppPrompt_1.installAppBrowserPrompt).toHaveBeenCalled();
+        });
+        it('should return false for OAuth app', async () => {
+            // Reset mocks to ensure clean state
+            vitest_1.vi.clearAllMocks();
+            // Set up basic mocks
+            appsDev_1.fetchPublicAppsForPortal.mockResolvedValue({
+                data: { results: [mockPublicApp] },
+            });
+            appsDev_1.fetchPublicAppProductionInstallCounts.mockResolvedValue({
+                data: { uniquePortalInstallCount: 5 },
+            });
+            urls_1.getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
+            installAppPrompt_1.installAppBrowserPrompt.mockResolvedValue(undefined);
+            // Reset the mock LocalDevState
+            mockLocalDevState.getAppDataByUid = vitest_1.vi.fn().mockReturnValue(mockAppData);
+            mockLocalDevState.setAppDataForUid = vitest_1.vi.fn();
+            mockLocalDevState.addListener = vitest_1.vi.fn();
+            const oauthAppNode = {
+                ...mockAppNode,
+                config: {
+                    ...mockAppNode.config,
+                    auth: {
+                        ...mockAppNode.config.auth,
+                        type: constants_1.APP_AUTH_TYPES.OAUTH,
+                    },
+                },
+            };
+            mockLocalDevState.projectNodes = { [oauthAppNode.uid]: oauthAppNode };
+            // App is not installed
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            // Create a new instance to avoid interference from previous test setup
+            const newAppDevModeInterface = new AppDevModeInterface_1.default({
+                localDevState: mockLocalDevState,
+                localDevLogger: mockLocalDevLogger,
+            });
+            await newAppDevModeInterface.setup({});
+            expect(installAppPrompt_1.installAppBrowserPrompt).toHaveBeenCalled();
+        });
+    });
+    describe('websocket server message handling', () => {
+        it('should check app installation when websocket server connects', async () => {
+            // Reset mocks to ensure clean state
+            vitest_1.vi.clearAllMocks();
+            // Set up basic mocks
+            appsDev_1.fetchPublicAppsForPortal.mockResolvedValue({
+                data: { results: [mockPublicApp] },
+            });
+            appsDev_1.fetchPublicAppProductionInstallCounts.mockResolvedValue({
+                data: { uniquePortalInstallCount: 5 },
+            });
+            urls_1.getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
+            installAppPrompt_1.installAppBrowserPrompt.mockResolvedValue(undefined);
+            // Reset the mock LocalDevState
+            mockLocalDevState.getAppDataByUid = vitest_1.vi.fn().mockReturnValue(mockAppData);
+            mockLocalDevState.setAppDataForUid = vitest_1.vi.fn();
+            mockLocalDevState.addListener = vitest_1.vi.fn();
+            // App is not installed so fetchAppInstallationData will be called
+            localDevAuth_1.fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            // Create a new instance to avoid interference from previous test setup
+            const newAppDevModeInterface = new AppDevModeInterface_1.default({
+                localDevState: mockLocalDevState,
+                localDevLogger: mockLocalDevLogger,
+            });
+            await newAppDevModeInterface.setup({});
+            // Simulate websocket server connection
+            const addListenerCall = mockLocalDevState.addListener.mock
+                .calls[0];
+            const [eventType, callback] = addListenerCall;
+            expect(eventType).toBe('devServerMessage');
+            // Call the callback with websocket connection message
+            await callback(constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+            expect(localDevAuth_1.fetchAppInstallationData).toHaveBeenCalledTimes(2); // Once in setup, once in listener
+        });
+    });
+});

package/lib/projects/__tests__/LocalDevProcess.test.d.ts

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