@hubspot/cli 7.8.0-experimental.0 → 7.8.0

package/lib/middleware/configMiddleware.js

@@ -1,10 +1,9 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { loadConfig, getAccountId, configFileExists, getConfigPath, validateConfig, } from '@hubspot/local-dev-lib/config';
 import { validateAccount } from '../validation.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
-import { i18n } from '../lang.js';
+import { commands } from '../../lang/en.js';
 import { uiDeprecatedTag } from '../ui/index.js';
-import { isTargetedCommand } from './utils.js';
+import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from './commandTargetingUtils.js';
 import { parseStringToNumber } from '../parsing.js';
 import { uiLogger } from '../ui/logger.js';
 import { lib } from '../../lang/en.js';
@@ -14,9 +13,7 @@ export function handleDeprecatedEnvVariables(argv) {
     if (argv.useEnv &&
         process.env.HUBSPOT_PORTAL_ID &&
         !process.env.HUBSPOT_ACCOUNT_ID) {
-        uiDeprecatedTag(i18n(`commands.generalErrors.handleDeprecatedEnvVariables.portalEnvVarDeprecated`, {
-            configPath: getConfigPath(),
-        }));
+        uiDeprecatedTag(commands.generalErrors.handleDeprecatedEnvVariables.portalEnvVarDeprecated);
         process.env.HUBSPOT_ACCOUNT_ID = process.env.HUBSPOT_PORTAL_ID;
     }
 }
@@ -39,99 +36,42 @@ export async function injectAccountIdMiddleware(argv) {
         argv.derivedAccountId = getAccountId(account);
     }
 }
-const SKIP_CONFIG_VALIDATION = {
-    init: { target: true },
-    auth: { target: true },
-    mcp: {
-        target: false,
-        subCommands: {
-            setup: { target: true },
-            start: { target: true },
-        },
-    },
-};
-export async function loadConfigMiddleware(argv) {
+export async function loadAndValidateConfigMiddleware(argv) {
     // Skip this when no command is provided
     if (!argv._.length || argv.help) {
         return;
     }
-    const maybeValidateConfig = () => {
-        if (!isTargetedCommand(argv._, SKIP_CONFIG_VALIDATION) &&
-            !validateConfig()) {
-            process.exit(EXIT_CODES.ERROR);
-        }
-    };
-    if (!configFileExists(true) &&
-        isTargetedCommand(argv._, {
-            account: { target: false, subCommands: { auth: { target: true } } },
-            config: { target: false, subCommands: { migrate: { target: true } } },
-        })) {
+    // Do not load or validate the config for the commands that do not require it
+    if (!shouldLoadConfigForCommand(argv._)) {
         return;
     }
+    // If the config file exists and the --config flag is used, exit with an error
     if (configFileExists(true) &&
         argv.config &&
-        !isTargetedCommand(argv._, {
-            config: { target: false, subCommands: { migrate: { target: true } } },
-        })) {
-        logger.error(i18n(`commands.generalErrors.loadConfigMiddleware.configFileExists`, {
-            configPath: getConfigPath(),
-        }));
+        !isTargetedCommand(argv._, { config: { migrate: true } })) {
+        uiLogger.error(commands.generalErrors.loadConfigMiddleware.configFileExists(getConfigPath()));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const config = loadConfig(argv.config, argv);
+    // We don't run validation for auth because users should be able to run it when
+    // no accounts are configured, but we still want to exit if the config file is not found
+    if (isTargetedCommand(argv._, { auth: true }) && !config) {
         process.exit(EXIT_CODES.ERROR);
     }
-    else if (!isTargetedCommand(argv._, { init: { target: true } })) {
-        const config = loadConfig(argv.config, argv);
-        // We don't run validateConfig() for auth because users should be able to run it when
-        // no accounts are configured, but we still want to exit if the config file is not found
-        if (isTargetedCommand(argv._, { auth: { target: true } }) && !config) {
+    // Only validate the config if the command requires it
+    if (shouldRunConfigValidationForCommand(argv._)) {
+        const configIsValid = validateConfig();
+        if (!configIsValid) {
             process.exit(EXIT_CODES.ERROR);
         }
     }
-    maybeValidateConfig();
 }
-const accountsSubCommands = {
-    target: false,
-    subCommands: {
-        auth: { target: true },
-        clean: { target: true },
-        list: { target: true },
-        ls: { target: true },
-        remove: { target: true },
-        use: { target: true },
-    },
-};
-const sandboxesSubCommands = {
-    target: false,
-    subCommands: {
-        delete: { target: true },
-    },
-};
-const configSubCommands = {
-    target: false,
-    subCommands: {
-        migrate: { target: true },
-    },
-};
-const SKIP_ACCOUNT_VALIDATION = {
-    init: { target: true },
-    auth: { target: true },
-    mcp: {
-        target: false,
-        subCommands: {
-            setup: { target: true },
-            start: { target: true },
-        },
-    },
-    account: accountsSubCommands,
-    accounts: accountsSubCommands,
-    sandbox: sandboxesSubCommands,
-    sandboxes: sandboxesSubCommands,
-    config: configSubCommands,
-};
 export async function validateAccountOptions(argv) {
     // Skip this when no command is provided
     if (argv._.length && !argv.help) {
         let validAccount = true;
-        if (!isTargetedCommand(argv._, SKIP_ACCOUNT_VALIDATION)) {
+        // Only validate the account if the command requires it
+        if (shouldRunAccountValidationForCommand(argv._)) {
             validAccount = await validateAccount(argv);
         }
         if (!validAccount) {

package/lib/middleware/fireAlarmMiddleware.js

@@ -3,6 +3,8 @@ import { fetchFireAlarms } from '@hubspot/local-dev-lib/api/fireAlarm';
 import { debugError } from '../errorHandlers/index.js';
 import pkg from '../../package.json' with { type: 'json' };
 import { logInBox } from '../ui/boxen.js';
+import { renderInline } from '../../ui/index.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 /*
  * Versions can be formatted like this:
  * =7.2.2 -> targets the exact version 7.2.2
@@ -98,12 +100,20 @@ async function logFireAlarms(accountId, command, version) {
             }
             return acc;
         }, '');
-        await logInBox({
-            contents: notifications,
-            options: {
+        if (!process.env.HUBSPOT_ENABLE_INK) {
+            await logInBox({
+                contents: notifications,
+                options: {
+                    title: 'Notifications',
+                },
+            });
+        }
+        else {
+            await renderInline(getWarningBox({
                 title: 'Notifications',
-            },
-        });
+                message: notifications,
+            }));
+        }
     }
 }
 export async function checkFireAlarms(argv) {

package/lib/middleware/gitMiddleware.js

@@ -1,8 +1,12 @@
-import { getConfigPath } from '@hubspot/local-dev-lib/config';
+import { getConfigPath, configFileExists } from '@hubspot/local-dev-lib/config';
 import { checkAndWarnGitInclusion } from '../ui/git.js';
 export function checkAndWarnGitInclusionMiddleware(argv) {
     // Skip this when no command is provided
     if (argv._.length) {
+        // Skip if using global config
+        if (configFileExists(true)) {
+            return;
+        }
         const configPath = getConfigPath();
         if (configPath) {
             checkAndWarnGitInclusion(configPath);

package/lib/middleware/notificationsMiddleware.js

@@ -1,8 +1,7 @@
 import updateNotifier from 'update-notifier';
-import chalk from 'chalk';
 import pkg from '../../package.json' with { type: 'json' };
-import { UI_COLORS, uiCommandReference } from '../ui/index.js';
-import { i18n } from '../lang.js';
+import { UI_COLORS } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
 const notifier = updateNotifier({
     pkg: { ...pkg, name: '@hubspot/cli' },
     distTag: 'latest',
@@ -12,13 +11,8 @@ const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
 export function notifyAboutUpdates() {
     notifier.notify({
         message: pkg.name === CMS_CLI_PACKAGE_NAME
-            ? i18n(`commands.generalErrors.updateNotify.cmsUpdateNotification`, {
-                packageName: CMS_CLI_PACKAGE_NAME,
-                updateCommand: uiCommandReference('{updateCommand}'),
-            })
-            : i18n(`commands.generalErrors.updateNotify.cliUpdateNotification`, {
-                updateCommand: uiCommandReference('{updateCommand}'),
-            }),
+            ? lib.middleware.updateNotification.cmsUpdateNotification(CMS_CLI_PACKAGE_NAME)
+            : lib.middleware.updateNotification.cliUpdateNotification,
         defer: false,
         boxenOptions: {
             borderColor: UI_COLORS.MARIGOLD_DARK,
@@ -28,7 +22,7 @@ export function notifyAboutUpdates() {
             borderStyle: 'round',
             title: pkg.name === CMS_CLI_PACKAGE_NAME
                 ? undefined
-                : chalk.bold(i18n(`commands.generalErrors.updateNotify.notifyTitle`)),
+                : lib.middleware.updateNotification.notifyTitle,
         },
     });
 }

package/lib/middleware/yargsChecksMiddleware.js

@@ -1,20 +1,17 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../ui/logger.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
-import { i18n } from '../lang.js';
+import { commands } from '../../lang/en.js';
 import { getIsInProject } from '../projects/config.js';
-import { isTargetedCommand } from './utils.js';
+import { isTargetedCommand } from './commandTargetingUtils.js';
 const UPLOAD_AND_WATCH_COMMANDS = {
-    upload: { target: true },
-    watch: { target: true },
+    upload: true,
+    watch: true,
 };
 export function performChecks(argv) {
     // Require "project" command when running upload/watch inside of a project
     if (isTargetedCommand(argv._, UPLOAD_AND_WATCH_COMMANDS) &&
         getIsInProject(argv.src)) {
-        logger.error(i18n(`commands.generalErrors.srcIsProject`, {
-            src: argv.src || './',
-            command: argv._.join(' '),
-        }));
+        uiLogger.error(commands.generalErrors.srcIsProject(argv.src || './', argv._.join(' ')));
         process.exit(EXIT_CODES.ERROR);
     }
     return true;

package/lib/npm.js

@@ -1,6 +1,6 @@
 import { exec as execAsync } from 'node:child_process';
 import util from 'util';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import pkg from '../package.json' with { type: 'json' };
 export const DEFAULT_PACKAGE_MANAGER = 'npm';
 export async function isGloballyInstalled(packageName) {
@@ -21,7 +21,7 @@ export async function getLatestCliVersion() {
 }
 export async function executeInstall(packages = [], flags, options) {
     const installCommand = `${DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
-    logger.debug('Running ', installCommand);
+    uiLogger.debug('Running', installCommand);
     const exec = util.promisify(execAsync);
     await exec(installCommand, options);
 }

package/lib/oauth.js

@@ -5,11 +5,11 @@ import { getAccountConfig } from '@hubspot/local-dev-lib/config';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
 import { handleExit } from './process.js';
-import { i18n } from './lang.js';
+import { lib } from '../lang/en.js';
 import { EXIT_CODES } from './enums/exitCodes.js';
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
@@ -18,7 +18,7 @@ function buildAuthUrl(oauthManager) {
     const env = accountEnv || ENVIRONMENTS.PROD;
     const scopes = accountScopes || DEFAULT_OAUTH_SCOPES;
     if (!clientId) {
-        logger.error(i18n(`lib.oauth.missingClientId`));
+        uiLogger.error(lib.oauth.missingClientId);
         process.exit(EXIT_CODES.ERROR);
     }
     return (`${getHubSpotWebsiteOrigin(env)}/oauth/${oauthManager.account.accountId}/authorize` +
@@ -77,7 +77,7 @@ async function authorize(oauthManager) {
                 reject();
             }
         });
-        server = app.listen(PORT, () => logger.log(`Waiting for authorization...`));
+        server = app.listen(PORT, () => uiLogger.log(`Waiting for authorization...`));
         handleServerOnProcessEnd(server);
     });
 }
@@ -91,7 +91,7 @@ function setupOauth(accountConfig) {
 }
 export async function authenticateWithOauth(accountConfig) {
     const oauthManager = setupOauth(accountConfig);
-    logger.log('Authorizing');
+    uiLogger.log('Authorizing');
     await authorize(oauthManager);
     addOauthToAccountConfig(oauthManager);
 }

package/lib/process.js

@@ -1,6 +1,7 @@
 import readline from 'readline';
-import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
-import { i18n } from './lang.js';
+import { setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
 import { logError } from './errorHandlers/index.js';
 const SIGHUP = 'SIGHUP';
 const uncaughtException = 'uncaughtException';
@@ -26,13 +27,13 @@ export function handleExit(callback) {
                 if (isSIGHUP) {
                     setLogLevel(LOG_LEVEL.NONE);
                 }
-                logger.debug(i18n(`lib.process.exitDebug`, { signal }));
+                uiLogger.debug(lib.process.exitDebug(signal));
                 if (signal === uncaughtException && args && args.length > 0) {
                     try {
                         logError(args[0]);
                     }
                     catch (e) {
-                        logger.error(args[0]);
+                        uiLogger.error(String(args[0]));
                     }
                 }
                 await callback({ isSIGHUP });

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

@@ -11,7 +11,7 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => {
     };
 });
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchAppMetadataByUid, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
 import { DevModeUnifiedInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
 import { requestPorts } from '@hubspot/local-dev-lib/portManager';
 import { getAccountConfig } from '@hubspot/local-dev-lib/config';
@@ -67,6 +67,8 @@ describe('AppDevModeInterface', () => {
             componentRoot: '/test/path',
             componentConfigPath: '/test/path/config.json',
             configUpdatedSinceLastUpload: false,
+            removed: false,
+            parsingErrors: [],
         },
         componentDeps: {},
         metaFilePath: '/test/path',
@@ -107,8 +109,8 @@ describe('AppDevModeInterface', () => {
         LocalDevState.mockImplementation(() => mockLocalDevState);
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
         // Mock external dependencies
-        fetchPublicAppsForPortal.mockResolvedValue({
-            data: { results: [mockPublicApp] },
+        fetchAppMetadataByUid.mockResolvedValue({
+            data: mockPublicApp,
         });
         fetchPublicAppProductionInstallCounts.mockResolvedValue({
             data: { uniquePortalInstallCount: 5 },
@@ -127,7 +129,16 @@ describe('AppDevModeInterface', () => {
         getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
         getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
         installAppAutoPrompt.mockResolvedValue(true);
-        installAppBrowserPrompt.mockResolvedValue(undefined);
+        installAppBrowserPrompt.mockImplementation(async () => {
+            setTimeout(() => {
+                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                if (addListenerCall) {
+                    const callback = addListenerCall[1];
+                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                }
+            }, 0);
+            return undefined;
+        });
         confirmPrompt.mockResolvedValue(true);
         installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
         // Mock process.exit
@@ -189,12 +200,12 @@ describe('AppDevModeInterface', () => {
         it('should return early if no app node exists', async () => {
             mockLocalDevState.projectNodes = {};
             await appDevModeInterface.setup({});
-            expect(fetchPublicAppsForPortal).not.toHaveBeenCalled();
+            expect(fetchAppMetadataByUid).not.toHaveBeenCalled();
             expect(UIEDevModeInterface.setup).not.toHaveBeenCalled();
         });
         it('should setup successfully with private app', async () => {
             await appDevModeInterface.setup({});
-            expect(fetchPublicAppsForPortal).toHaveBeenCalledWith(12345);
+            expect(fetchAppMetadataByUid).toHaveBeenCalledWith('test-app-uid', 12345);
             expect(fetchPublicAppProductionInstallCounts).toHaveBeenCalledWith(123, 12345);
             expect(fetchAppInstallationData).toHaveBeenCalledWith(67890, 999, 'test-app-uid', ['test-scope'], []);
             expect(UIEDevModeInterface.setup).toHaveBeenCalled();
@@ -240,21 +251,16 @@ describe('AppDevModeInterface', () => {
             await newAppDevModeInterface.setup({});
             expect(process.exit).toHaveBeenCalledWith(0);
         });
-        // @TODO: Restore test account auto install functionality
-        // it('should auto-install static auth app on test account', async () => {
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   await appDevModeInterface.setup({});
-        //   expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(
-        //     123,
-        //     67890,
-        //     [1, 2, 3]
-        //   );
-        // });
+        it('should auto-install static auth app on test account', async () => {
+            fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            await appDevModeInterface.setup({});
+            expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(123, 67890, [1, 2, 3]);
+        });
         it('should open browser for OAuth app installation', async () => {
             const oauthAppNode = {
                 ...mockAppNode,
@@ -293,81 +299,47 @@ describe('AppDevModeInterface', () => {
                 },
             });
             await appDevModeInterface.setup({});
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true, {
-                appUid: 'test-app-uid',
-                projectAccountId: 12345,
-                projectName: 'test-project',
-                testingAccountId: 67890,
-            });
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
         });
         it('should handle errors during setup', async () => {
             const error = new Error('Setup failed');
-            fetchPublicAppsForPortal.mockRejectedValue(error);
+            fetchAppMetadataByUid.mockRejectedValue(error);
             await appDevModeInterface.setup({});
             expect(logError).toHaveBeenCalledWith(error);
         });
-        it('should exit if app not found in portal', async () => {
-            // Set up conditions for non-automatic installation to force getAppInstallUrl call
-            getAccountConfig.mockReturnValue(null);
-            // First call for fetchAppData succeeds
-            fetchPublicAppsForPortal
-                .mockResolvedValueOnce({
-                data: { results: [mockPublicApp] },
-            })
-                // Second call for getAppInstallUrl fails (app not found)
-                .mockResolvedValueOnce({
-                data: { results: [] },
+        it('should exit if user declines auto-install', async () => {
+            // Set up conditions for automatic installation
+            getAccountConfig.mockReturnValue({
+                parentAccountId: 12345, // matches targetProjectAccountId
             });
+            isDeveloperTestAccount.mockReturnValue(true);
             fetchAppInstallationData.mockResolvedValue({
                 data: {
                     isInstalledWithScopeGroups: false,
                     previouslyAuthorizedScopeGroups: [],
                 },
             });
+            installAppAutoPrompt.mockResolvedValue(false);
+            // Create a new instance to trigger the exit during setup
+            const newAppDevModeInterface = new AppDevModeInterface({
+                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 () => {
+            fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            installStaticAuthAppOnTestAccount.mockRejectedValue(new Error('Install failed'));
             await appDevModeInterface.setup({});
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-        // @TODO: Restore test account auto install functionality
-        // it('should exit if user declines auto-install', async () => {
-        //   // Set up conditions for automatic installation
-        //   (getAccountConfig as Mock).mockReturnValue({
-        //     parentAccountId: 12345, // matches targetProjectAccountId
-        //   });
-        //   (isDeveloperTestAccount as Mock).mockReturnValue(true);
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   (installAppAutoPrompt as Mock).mockResolvedValue(false);
-        //   // Create a new instance to trigger the exit during setup
-        //   const newAppDevModeInterface = new AppDevModeInterface({
-        //     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);
-        // });
-        // @TODO: Restore test account auto install functionality
-        // it('should fallback to browser install if auto-install fails', async () => {
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   (installStaticAuthAppOnTestAccount as Mock).mockRejectedValue(
-        //     new Error('Install failed')
-        //   );
-        //   await appDevModeInterface.setup({});
-        //   expect(installAppBrowserPrompt).toHaveBeenCalledWith(
-        //     'http://static-install-url',
-        //     false
-        //   );
-        // });
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', false);
+        });
     });
     describe('start()', () => {
         it('should return early if no app node exists', async () => {
@@ -424,14 +396,21 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                if (addListenerCall) {
+                    const callback = addListenerCall[1];
+                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                }
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
@@ -457,14 +436,23 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
             });
             getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                setTimeout(() => {
+                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                    if (addListenerCall) {
+                        const callback = addListenerCall[1];
+                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                    }
+                }, 0);
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
@@ -501,14 +489,23 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                setTimeout(() => {
+                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                    if (addListenerCall) {
+                        const callback = addListenerCall[1];
+                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                    }
+                }, 0);
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();