@hubspot/cli 8.9.1 → 8.10.0-beta.0

package/lib/mcp/promotion.js

@@ -0,0 +1,109 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
+import { STATE_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { commands } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { trackMcpPromotionShown } from '../usageTracking.js';
+import { MCP_CLIENTS, MCP_SERVER_NAME } from './clients.js';
+const ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function configContainsMcpServer(value) {
+    if (typeof value === 'string') {
+        return value === MCP_SERVER_NAME;
+    }
+    if (Array.isArray(value)) {
+        return value.some(configContainsMcpServer);
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Object.entries(value).some(([key, childValue]) => {
+        return key === MCP_SERVER_NAME || configContainsMcpServer(childValue);
+    });
+}
+function textConfigContainsMcpServer(configContent) {
+    return configContent.includes(MCP_SERVER_NAME);
+}
+function jsonConfigContainsMcpServer(configContent) {
+    const parsedConfig = JSON.parse(configContent);
+    return configContainsMcpServer(parsedConfig);
+}
+export function detectConfiguredMcpClients() {
+    const homeDirectory = os.homedir();
+    return MCP_CLIENTS.reduce((clients, client) => {
+        try {
+            const configPath = path.join(homeDirectory, ...client.detection.pathSegments);
+            if (!fs.existsSync(configPath)) {
+                return clients;
+            }
+            const configContent = fs.readFileSync(configPath, 'utf8');
+            const hasMcpServer = client.detection.type === 'json'
+                ? jsonConfigContainsMcpServer(configContent)
+                : textConfigContainsMcpServer(configContent);
+            if (hasMcpServer) {
+                clients.push(client.id);
+            }
+        }
+        catch (e) {
+            debugError(e);
+            return clients;
+        }
+        return clients;
+    }, []);
+}
+function isScriptSafeSuppressed() {
+    return Boolean(process.env.CI || process.env.HUBSPOT_MCP_AI_AGENT || !process.stdout.isTTY);
+}
+function hasRecentPromotion(lastShownAt, now, cooldownMs) {
+    if (!lastShownAt) {
+        return false;
+    }
+    const lastShownTime = new Date(lastShownAt).getTime();
+    if (Number.isNaN(lastShownTime)) {
+        return false;
+    }
+    return now.getTime() - lastShownTime < cooldownMs;
+}
+function getMcpPromotionLastShownAt() {
+    return getStateValue(STATE_FLAGS.MCP_PROMOTION_LAST_SHOWN_AT);
+}
+export async function shouldShowMcpPromotion() {
+    if (isScriptSafeSuppressed()) {
+        return false;
+    }
+    try {
+        const mcpTotalToolCalls = getStateValue(STATE_FLAGS.MCP_TOTAL_TOOL_CALLS);
+        if (typeof mcpTotalToolCalls === 'number' && mcpTotalToolCalls > 0) {
+            return false;
+        }
+        if (detectConfiguredMcpClients().length > 0) {
+            return false;
+        }
+        return !hasRecentPromotion(getMcpPromotionLastShownAt(), new Date(), ONE_WEEK_IN_MS);
+    }
+    catch (e) {
+        debugError(e);
+        return false;
+    }
+}
+function setMcpPromotionShownAt() {
+    setStateValue(STATE_FLAGS.MCP_PROMOTION_LAST_SHOWN_AT, new Date().toISOString());
+}
+export async function showMcpPromotionNudge(commandName) {
+    try {
+        if (!(await shouldShowMcpPromotion())) {
+            return;
+        }
+        setMcpPromotionShownAt();
+        uiLogger.info(commands.mcp.promotion.activeNudge);
+        await trackMcpPromotionShown(commandName || undefined);
+    }
+    catch (e) {
+        debugError(e);
+    }
+}

package/lib/mcp/setup.d.ts

@@ -1,13 +1,14 @@
+import { McpClientId } from './clients.js';
 export declare const supportedTools: {
     name: string;
-    value: string;
+    value: McpClientId;
 }[];
 interface McpCommand {
     command: string;
     args: string[];
     env?: Record<string, string>;
 }
-export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
+export declare function configureMcpServer(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupCursor(mcpCommand?: McpCommand): boolean;

package/lib/mcp/setup.js

@@ -4,30 +4,35 @@ import { promptUser } from '../prompts/promptUtils.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError, getErrorMessage } from '../errorHandlers/index.js';
 import { execAsync } from '../../mcp-server/utils/command.js';
+import { MCP_CLIENTS, MCP_SERVER_NAME, getMcpClientPathSegments, } from './clients.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { existsSync } from 'fs';
-const mcpServerName = 'HubSpotDev';
+const mcpServerName = MCP_SERVER_NAME;
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
 const vscode = 'vscode';
 const codex = 'codex';
 const gemini = 'gemini';
-export const supportedTools = [
-    { name: commands.mcp.setup.codex, value: codex },
-    { name: commands.mcp.setup.claudeCode, value: claudeCode },
-    { name: commands.mcp.setup.cursor, value: cursor },
-    { name: commands.mcp.setup.gemini, value: gemini },
-    { name: commands.mcp.setup.vsCode, value: vscode },
-    { name: commands.mcp.setup.windsurf, value: windsurf },
-];
+const clientLabels = {
+    codex: commands.mcp.setup.codex,
+    claude: commands.mcp.setup.claudeCode,
+    cursor: commands.mcp.setup.cursor,
+    gemini: commands.mcp.setup.gemini,
+    vscode: commands.mcp.setup.vsCode,
+    windsurf: commands.mcp.setup.windsurf,
+};
+export const supportedTools = MCP_CLIENTS.map(client => ({
+    name: clientLabels[client.id],
+    value: client.id,
+}));
 const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
 };
-export async function addMcpServerToConfig(targets) {
+export async function configureMcpServer(targets) {
     try {
         let derivedTargets = [];
         if (!targets || targets.length === 0) {
@@ -247,7 +252,7 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     }
 }
 export function setupCursor(mcpCommand = defaultMcpCommand) {
-    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    const cursorConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(cursor));
     return setupMcpConfigFile({
         configPath: cursorConfigPath,
         configuringMessage: commands.mcp.setup.spinners.configuringCursor,
@@ -257,7 +262,7 @@ export function setupCursor(mcpCommand = defaultMcpCommand) {
     });
 }
 export function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    const windsurfConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(windsurf));
     return setupMcpConfigFile({
         configPath: windsurfConfigPath,
         configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,

package/lib/projects/installApp.d.ts

@@ -0,0 +1,58 @@
+import type { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import type { AppInstallationState, AppIRNode } from '../../types/ProjectComponents.js';
+import type { ProjectConfig } from '../../types/Projects.js';
+import { type ScopeGroup } from '../app/install.js';
+export type AppInstallationData = {
+    appId?: number;
+    isInstalledWithScopeGroups: boolean;
+    previouslyAuthorizedScopeGroups: ScopeGroup[];
+};
+export type AppMetadata = {
+    appId: number;
+    scopeGroupIds: number[];
+    ownerPortalId: number;
+};
+type ConfirmInstallAppOptions = {
+    appName: string;
+    targetAccountId: number;
+    force: boolean;
+    needsReinstall: boolean;
+};
+type InstallStaticAuthAppOptions = {
+    appId: number;
+    appNode: AppIRNode;
+    appName: string;
+    targetAccountId: number;
+    targetAccountConfig?: HubSpotConfigAccount;
+    projectId: number;
+    projectName: string;
+    scopeGroupIds: number[];
+    ownerPortalId: number;
+    installationState: AppInstallationState;
+    formatOutputAsJson: boolean;
+};
+type UploadAndDeployOptions = {
+    accountId: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    profile: string | undefined;
+    force: boolean;
+    formatOutputAsJson: boolean;
+};
+export declare function resolveProjectAccountId(derivedAccountId: number, projectConfig: ProjectConfig, projectDir: string, profileOption: string | undefined, useEnvOption: boolean): Promise<{
+    accountId: number;
+    profileName?: string;
+} | null>;
+export declare function loadInstallableAppNode(projectConfig: ProjectConfig, projectDir: string, accountId: number, force?: boolean): Promise<AppIRNode | null>;
+export declare function resolveValidInstallAccount(targetAccountId: number, force: boolean, formatOutputAsJson: boolean): Promise<number | null>;
+export declare function resolveProjectId(options: UploadAndDeployOptions): Promise<number | null>;
+export declare function resolveAppMetadata(options: UploadAndDeployOptions & {
+    appId: number | undefined;
+    projectId: number;
+    appUid: string;
+    appName: string;
+}): Promise<AppMetadata | null>;
+export declare function fetchProjectAppInstallationData(targetAccountId: number, projectId: number, appNode: AppIRNode, projectConfig: ProjectConfig): Promise<AppInstallationData | null>;
+export declare function confirmInstallAppAction({ appName, targetAccountId, force, needsReinstall, }: ConfirmInstallAppOptions): Promise<boolean>;
+export declare function installStaticAuthAppForAccount({ appId, appNode, appName, targetAccountId, targetAccountConfig, projectId, projectName, scopeGroupIds, ownerPortalId, installationState, formatOutputAsJson, }: InstallStaticAuthAppOptions): Promise<boolean>;
+export {};

package/lib/projects/installApp.js

@@ -0,0 +1,283 @@
+import path from 'path';
+import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { fetchAppMetadataBySourceId, fetchPublicAppMetadata, installStaticAuthAppOnCurrentAccount, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { getAllConfigAccounts, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { translateForLocalDev } from '@hubspot/project-parsing-lib/translate';
+import { commands } from '../../lang/en.js';
+import { warnAboutSkippedHsMetaFiles } from './ui.js';
+import { isAppDeveloperAccount } from '../accountTypes.js';
+import { ApiErrorContext, debugError, logError, } from '../errorHandlers/index.js';
+import { confirmPrompt, listPrompt } from '../prompts/promptUtils.js';
+import { projectProfilePrompt } from '../prompts/projectProfilePrompt.js';
+import { loadProfile } from './projectProfiles.js';
+import { handleProjectUpload } from './upload.js';
+import { pollProjectBuildAndDeploy } from './pollProjectBuildAndDeploy.js';
+import { getAppNodeFromProjectNodes, canUseStaticAuthTestAccountInstall, isPrivateApp, isStaticAuthApp, } from '../app/install.js';
+import { uiLogger } from '../ui/logger.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { getStaticAuthAppInstallUrl } from '../app/urls.js';
+export async function resolveProjectAccountId(derivedAccountId, projectConfig, projectDir, profileOption, useEnvOption) {
+    try {
+        const profileName = await projectProfilePrompt(projectDir, projectConfig, profileOption, useEnvOption);
+        if (profileName) {
+            const profile = loadProfile(projectConfig, projectDir, profileName);
+            uiLogger.log(commands.project.installApp.profileMessage(profileName, profile.accountId));
+            uiLogger.log('');
+            return { accountId: profile.accountId, profileName };
+        }
+        return { accountId: derivedAccountId };
+    }
+    catch (error) {
+        logError(error);
+        return null;
+    }
+}
+export async function loadInstallableAppNode(projectConfig, projectDir, accountId, force = false) {
+    let appNode;
+    try {
+        const { intermediateRepresentation, skippedHsMetaFiles } = await translateForLocalDev({
+            projectSourceDir: path.join(projectDir, projectConfig.srcDir),
+            platformVersion: projectConfig.platformVersion,
+            accountId,
+        }, { skipValidation: true });
+        const shouldContinue = await warnAboutSkippedHsMetaFiles(skippedHsMetaFiles, force, false);
+        if (!shouldContinue) {
+            return null;
+        }
+        appNode = getAppNodeFromProjectNodes(intermediateRepresentation.intermediateNodesIndexedByUid);
+    }
+    catch (error) {
+        debugError(error);
+        uiLogger.error(commands.project.installApp.errors.failedToParseProject);
+        return null;
+    }
+    if (!appNode) {
+        uiLogger.error(commands.project.installApp.errors.noAppInProject);
+        return null;
+    }
+    if (!isStaticAuthApp(appNode)) {
+        uiLogger.error(commands.project.installApp.errors.unsupportedAuthType(appNode.config.auth.type));
+        return null;
+    }
+    if (!isPrivateApp(appNode)) {
+        uiLogger.error(commands.project.installApp.errors.unsupportedDistribution(appNode.config.distribution || 'unknown'));
+        return null;
+    }
+    return appNode;
+}
+// App developer accounts can't host app installs.
+export async function resolveValidInstallAccount(targetAccountId, force, formatOutputAsJson) {
+    const accountConfig = getConfigAccountIfExists(targetAccountId);
+    if (!accountConfig || !isAppDeveloperAccount(accountConfig)) {
+        return targetAccountId;
+    }
+    const validAccounts = getAllConfigAccounts().filter(account => !isAppDeveloperAccount(account));
+    if (force || formatOutputAsJson || validAccounts.length === 0) {
+        uiLogger.error(commands.project.installApp.errors.invalidAppDeveloperAccount(targetAccountId));
+        return null;
+    }
+    uiLogger.log(commands.project.installApp.appDeveloperAccountNotice(targetAccountId));
+    return listPrompt(commands.project.installApp.selectInstallAccountPrompt, {
+        choices: validAccounts.map(account => ({
+            name: uiAccountDescription(account.accountId, false),
+            value: account.accountId,
+        })),
+    });
+}
+async function offerUploadAndDeploy(options) {
+    const { accountId, projectConfig, projectDir, profile, force } = options;
+    if (!force) {
+        if (options.formatOutputAsJson) {
+            return false;
+        }
+        const shouldUpload = await confirmPrompt(commands.project.installApp.uploadAndDeployPrompt(accountId));
+        if (!shouldUpload) {
+            return false;
+        }
+    }
+    try {
+        const { result, uploadError } = await handleProjectUpload({
+            accountId,
+            projectConfig,
+            projectDir,
+            callbackFunc: pollProjectBuildAndDeploy,
+            isUploadCommand: true,
+            sendIR: true,
+            forceCreate: true,
+            profile,
+        });
+        if (uploadError) {
+            logError(uploadError, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return false;
+        }
+        return Boolean(result && result.succeeded);
+    }
+    catch (error) {
+        logError(error, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+        return false;
+    }
+}
+export async function resolveProjectId(options) {
+    const { accountId, projectConfig } = options;
+    try {
+        const response = await fetchProject(accountId, projectConfig.name);
+        return response.data.id;
+    }
+    catch (error) {
+        if (!isHubSpotHttpError(error) || error.status !== 404) {
+            logError(error, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+        const uploaded = await offerUploadAndDeploy(options);
+        if (!uploaded) {
+            uiLogger.error(commands.project.installApp.errors.projectNotFound(accountId, projectConfig.name));
+            return null;
+        }
+        try {
+            const response = await fetchProject(accountId, projectConfig.name);
+            return response.data.id;
+        }
+        catch (retryError) {
+            logError(retryError, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+    }
+}
+export async function resolveAppMetadata(options) {
+    const { appId, projectId, appUid, appName, accountId, projectConfig } = options;
+    const fetchMetadata = (forceSourceIdLookup = false) => appId && !forceSourceIdLookup
+        ? fetchPublicAppMetadata(appId, accountId)
+        : fetchAppMetadataBySourceId(projectId, appUid, accountId);
+    try {
+        const { data } = await fetchMetadata();
+        return {
+            appId: appId ?? data.id,
+            scopeGroupIds: data.scopeGroupIds,
+            ownerPortalId: data.portalId,
+        };
+    }
+    catch (error) {
+        if (!isHubSpotHttpError(error) || error.status !== 404) {
+            logError(error, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+        const uploaded = await offerUploadAndDeploy(options);
+        if (!uploaded) {
+            uiLogger.error(commands.project.installApp.errors.appNotDeployed(appName, accountId));
+            return null;
+        }
+        try {
+            const { data } = await fetchMetadata(true);
+            return {
+                appId: data.id,
+                scopeGroupIds: data.scopeGroupIds,
+                ownerPortalId: data.portalId,
+            };
+        }
+        catch (retryError) {
+            logError(retryError, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            return null;
+        }
+    }
+}
+export async function fetchProjectAppInstallationData(targetAccountId, projectId, appNode, projectConfig) {
+    try {
+        const response = await fetchAppInstallationData(targetAccountId, projectId, appNode.uid, appNode.config.auth.requiredScopes, appNode.config.auth.optionalScopes);
+        return {
+            appId: response.data.appId,
+            isInstalledWithScopeGroups: response.data.isInstalledWithScopeGroups,
+            previouslyAuthorizedScopeGroups: response.data.previouslyAuthorizedScopeGroups,
+        };
+    }
+    catch (error) {
+        if (isHubSpotHttpError(error) && error.status === 404) {
+            return {
+                isInstalledWithScopeGroups: false,
+                previouslyAuthorizedScopeGroups: [],
+            };
+        }
+        logError(error, new ApiErrorContext({
+            accountId: targetAccountId,
+            projectName: projectConfig.name,
+        }));
+        return null;
+    }
+}
+export async function confirmInstallAppAction({ appName, targetAccountId, force, needsReinstall, }) {
+    if (force) {
+        return true;
+    }
+    if (needsReinstall) {
+        uiLogger.log(commands.project.installApp.outdatedScopes(appName, targetAccountId));
+        return confirmPrompt(commands.project.installApp.reinstallPrompt);
+    }
+    return confirmPrompt(commands.project.installApp.installPrompt(appName, targetAccountId));
+}
+export async function installStaticAuthAppForAccount({ appId, appNode, appName, targetAccountId, targetAccountConfig, projectId, projectName, scopeGroupIds, ownerPortalId, installationState, formatOutputAsJson, }) {
+    const installingIntoOwnerAccount = ownerPortalId === targetAccountId;
+    const useTestAccountInstall = !installingIntoOwnerAccount &&
+        canUseStaticAuthTestAccountInstall({
+            accountConfig: targetAccountConfig,
+            appNode,
+        });
+    if (!installingIntoOwnerAccount && !useTestAccountInstall) {
+        const installUrl = getStaticAuthAppInstallUrl({
+            targetAccountId,
+            env: (targetAccountConfig?.env || 'prod'),
+            appId,
+        });
+        if (formatOutputAsJson) {
+            uiLogger.json({
+                appId,
+                appUid: appNode.uid,
+                accountId: targetAccountId,
+                projectId,
+                installationState,
+                installed: false,
+                reinstalled: false,
+                installUrl,
+                error: commands.project.installApp.jsonErrors.automaticInstallUnavailable,
+            });
+        }
+        else {
+            uiLogger.error(commands.project.installApp.errors.automaticInstallUnavailable(appName, targetAccountId));
+            uiLogger.log(commands.project.installApp.installFromBrowser(installUrl));
+        }
+        return false;
+    }
+    try {
+        if (useTestAccountInstall) {
+            await installStaticAuthAppOnTestAccount(appId, targetAccountId, scopeGroupIds);
+        }
+        else {
+            await installStaticAuthAppOnCurrentAccount(appId, targetAccountId, scopeGroupIds);
+        }
+        return true;
+    }
+    catch (error) {
+        if (formatOutputAsJson) {
+            uiLogger.json({
+                appId,
+                appUid: appNode.uid,
+                accountId: targetAccountId,
+                projectId,
+                installationState,
+                installed: false,
+                reinstalled: false,
+                error: isHubSpotHttpError(error)
+                    ? error.message
+                    : commands.project.installApp.jsonErrors.installFailed(appName, targetAccountId),
+            });
+        }
+        else {
+            uiLogger.error(commands.project.installApp.errors.installFailed(appName, targetAccountId));
+            logError(error, new ApiErrorContext({
+                accountId: targetAccountId,
+                projectName,
+            }));
+        }
+        return false;
+    }
+}

package/lib/projects/localDev/AppDevModeInterface.d.ts

@@ -12,12 +12,9 @@ declare class AppDevModeInterface {
     marketplaceAppInstalls?: number;
     private appInstallResolve?;
     constructor(options: AppDevModeInterfaceConstructorOptions);
-    private getAppNodeFromProjectNodes;
     private get appNode();
     private get appData();
     private set appData(value);
-    private isStaticAuthApp;
-    private isOAuthApp;
     private isAutomaticallyInstallable;
     private getAppInstallUrl;
     private fetchAppData;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -3,7 +3,6 @@ import { fetchAppMetadataBySourceId, fetchPublicAppProductionInstallCounts, inst
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { isAppIRNode } from '../../projects/structure.js';
 import { uiLine } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
 import { isPromptExitError } from '../../errors/PromptExitError.js';
@@ -12,9 +11,9 @@ import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { lib } from '../../../lang/en.js';
 import { uiLogger } from '../../ui/logger.js';
 import { getOauthAppInstallUrl, getStaticAuthAppInstallUrl, } from '../../app/urls.js';
-import { isDeveloperTestAccount, isSandbox } from '../../accountTypes.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
 import { isServerRunningAtUrl } from '../../http.js';
+import { canUseStaticAuthTestAccountInstall, getAppInstallationState, getAppNodeFromProjectNodes, isMarketplaceApp, isOAuthApp, } from '../../app/install.js';
 class AppDevModeInterface {
     localDevState;
     localDevLogger;
@@ -31,13 +30,10 @@ class AppDevModeInterface {
             throw new Error(lib.LocalDevManager.failedToInitialize);
         }
     }
-    getAppNodeFromProjectNodes(projectNodes) {
-        return Object.values(projectNodes).find(isAppIRNode) || null;
-    }
     // Assumes only one app per project
     get appNode() {
         if (this._appNode === undefined) {
-            this._appNode = this.getAppNodeFromProjectNodes(this.localDevState.projectNodes);
+            this._appNode = getAppNodeFromProjectNodes(this.localDevState.projectNodes);
         }
         return this._appNode;
     }
@@ -61,25 +57,16 @@ class AppDevModeInterface {
         }
         this.localDevState.setAppDataForUid(this.appNode.uid, appData);
     }
-    isStaticAuthApp() {
-        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.STATIC);
-    }
-    isOAuthApp() {
-        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH);
-    }
     isAutomaticallyInstallable() {
         const targetTestingAccount = getConfigAccountById(this.localDevState.targetTestingAccountId);
-        if (!targetTestingAccount) {
-            return false;
-        }
-        const isTestAccount = isDeveloperTestAccount(targetTestingAccount) ||
-            isSandbox(targetTestingAccount);
-        const hasCorrectParent = targetTestingAccount.parentAccountId ===
-            this.localDevState.targetProjectAccountId;
-        return isTestAccount && hasCorrectParent && this.isStaticAuthApp();
+        return canUseStaticAuthTestAccountInstall({
+            accountConfig: targetTestingAccount,
+            appNode: this.appNode,
+            parentAccountId: this.localDevState.targetProjectAccountId,
+        });
     }
     async getAppInstallUrl() {
-        if (this.appNode && this.isOAuthApp()) {
+        if (this.appNode && isOAuthApp(this.appNode)) {
             return getOauthAppInstallUrl({
                 targetAccountId: this.localDevState.targetTestingAccountId,
                 env: this.localDevState.env,
@@ -195,26 +182,17 @@ class AppDevModeInterface {
             return {};
         }
         const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await fetchAppInstallationData(this.localDevState.targetTestingAccountId, this.localDevState.projectId, this.appNode.uid, this.appNode.config.auth.requiredScopes, this.appNode.config.auth.optionalScopes);
-        const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
-        if (isInstalledWithScopeGroups) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED,
-            };
-        }
-        else if (isReinstall) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
-            };
-        }
-        else {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
-            };
-        }
-        return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
+        const installationState = getAppInstallationState(isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups);
+        const isReinstall = installationState ===
+            APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES;
+        this.appData = {
+            ...this.appData,
+            installationState,
+        };
+        return {
+            needsInstall: installationState !== APP_INSTALLATION_STATES.INSTALLED,
+            isReinstall,
+        };
     }
     async validateOauthAppRedirectUrl() {
         const redirectUrl = this.appNode?.config.auth.redirectUrls[0];
@@ -263,7 +241,7 @@ class AppDevModeInterface {
         }
     };
     onChangeProjectNodes = (nodes) => {
-        const newAppNode = this.getAppNodeFromProjectNodes(nodes);
+        const newAppNode = getAppNodeFromProjectNodes(nodes);
         const oldDistribution = this.appNode?.config.distribution;
         const newDistribution = newAppNode?.config.distribution;
         const oldAuthType = this.appNode?.config.auth.type;
@@ -287,7 +265,7 @@ class AppDevModeInterface {
         }
         try {
             await this.fetchAppData();
-            if (this.appNode.config.distribution === APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+            if (isMarketplaceApp(this.appNode)) {
                 await this.checkMarketplaceAppInstalls();
             }
             const { needsInstall, isReinstall } = await this.checkTestAccountAppInstallation();
@@ -298,7 +276,7 @@ class AppDevModeInterface {
                         failColor: 'white',
                     });
                 }
-                if (this.isOAuthApp()) {
+                if (isOAuthApp(this.appNode)) {
                     await this.validateOauthAppRedirectUrl();
                 }
                 this.localDevState.addListener('devServerMessage', this.onDevServerMessage);