@hubspot/cli 8.2.0 → 8.2.1-experimental.0

package/lib/projects/delete.js

@@ -0,0 +1,193 @@
+import { fetchProjects, fetchProject, stageProjectForDeletion, getDeployStatus, deleteProject, } from '@hubspot/local-dev-lib/api/projects';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { debugError, getErrorMessage } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { commands } from '../../lang/en.js';
+import { confirmPrompt, listPrompt } from '../prompts/promptUtils.js';
+import { poll, DEFAULT_POLLING_STATES, DEFAULT_POLLING_STATUS_LOOKUP, } from '../polling.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
+import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { COMPONENT_TYPES, SUBCOMPONENT_TYPES, } from '@hubspot/local-dev-lib/enums/build';
+export const DELETION_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+export const DELETION_DEPLOY_SUCCESS_STATES = [
+    DEFAULT_POLLING_STATES.SUCCESS,
+    'FINISHED',
+];
+export const DELETION_DEPLOY_ERROR_STATES = DEFAULT_POLLING_STATUS_LOOKUP.errorStates;
+const LEGACY_COMPONENTS_TO_FILTER = [
+    SUBCOMPONENT_TYPES.SERVERLESS_PKG,
+    SUBCOMPONENT_TYPES.REACT_EXTENSION,
+    SUBCOMPONENT_TYPES.PACKAGE_LOCK_FILE,
+    COMPONENT_TYPES.PRIVATE_APP,
+    COMPONENT_TYPES.PUBLIC_APP,
+];
+const legacyComponentFriendlyNames = {
+    [SUBCOMPONENT_TYPES.APP_ID]: 'Private App',
+    [SUBCOMPONENT_TYPES.PUBLIC_APP_ID]: 'Public App',
+    [SUBCOMPONENT_TYPES.CRM_CARD_V2]: 'Card',
+    [SUBCOMPONENT_TYPES.CARD_V2]: 'Card',
+    [SUBCOMPONENT_TYPES.SERVERLESS_FUNCTION]: 'Serverless Function',
+    [SUBCOMPONENT_TYPES.APP_FUNCTION]: 'App Function',
+    [SUBCOMPONENT_TYPES.AUTOMATION_ACTION]: 'Automation Action',
+    [SUBCOMPONENT_TYPES.WEBHOOKS]: 'Webhooks',
+    [COMPONENT_TYPES.THEME]: 'Theme',
+    [COMPONENT_TYPES.REACT_THEME]: 'React Theme',
+};
+function mapLegacyComponentToUserFriendlyName(type) {
+    return legacyComponentFriendlyNames[type] || 'unknown';
+}
+export async function resolveProjectName(accountId, projectArg) {
+    const { data } = await fetchProjects(accountId);
+    const projects = data.results;
+    if (projectArg) {
+        if (!projects.some(p => p.name === projectArg)) {
+            throw new Error(commands.project.delete.errors.projectNotFound(projectArg, accountId));
+        }
+        return projectArg;
+    }
+    if (projects.length === 0) {
+        throw new Error(commands.project.delete.errors.noProjectsFound(accountId));
+    }
+    const selected = await listPrompt(commands.project.delete.prompts.selectProject(accountId), {
+        choices: projects.map(p => ({ name: p.name, value: p.name })),
+        validate: value => !!value || commands.project.delete.prompts.validation.projectRequired,
+    });
+    if (!selected) {
+        throw new Error(commands.project.delete.prompts.validation.projectRequired);
+    }
+    return selected;
+}
+export async function fetchProjectInstallCount(accountId, projectId) {
+    try {
+        const { data } = await fetchPublicAppsForPortal(accountId);
+        return data.results
+            .filter(app => app.projectId === projectId)
+            .reduce((sum, app) => sum + app.publicApplicationInstallCounts.uniquePortalInstallCount, 0);
+    }
+    catch (e) {
+        debugError(e);
+        uiLogger.warn(commands.project.delete.logs.installCountUnknown);
+        return 0;
+    }
+}
+export async function checkDeployedComponents(accountId, projectName) {
+    const { data: projectData } = await fetchProject(accountId, projectName);
+    const platformVersion = projectData.deployedBuild?.platformVersion ||
+        projectData.latestBuild?.platformVersion;
+    if (!platformVersion) {
+        throw new Error(commands.project.delete.errors.noPlatformVersion);
+    }
+    if (isLegacyProject(platformVersion)) {
+        const userVisibleComponents = [];
+        projectData.deployedBuild?.subbuildStatuses?.forEach(item => {
+            if (LEGACY_COMPONENTS_TO_FILTER.includes(item.buildType)) {
+                return;
+            }
+            userVisibleComponents.push(`${item.buildName} - (${mapLegacyComponentToUserFriendlyName(item.buildType)})`);
+        });
+        if (userVisibleComponents.length > 0) {
+            uiLogger.log(commands.project.delete.logs.componentsToDeleteLegacy(userVisibleComponents));
+        }
+        return {
+            platformVersion,
+            hasUnifiedComponents: false,
+            projectId: projectData.id,
+        };
+    }
+    try {
+        const { data } = await stageProjectForDeletion(accountId, projectName, true);
+        if (data.hasDeployedComponents) {
+            const userVisibleComponents = data.componentsToRemove.filter(item => !AUTO_GENERATED_COMPONENT_TYPES.includes(mapToUserFacingType(item.componentType)));
+            uiLogger.log(commands.project.delete.logs.componentsToDeleteUnified(userVisibleComponents));
+        }
+        return {
+            hasUnifiedComponents: data.hasDeployedComponents,
+            platformVersion,
+            projectId: projectData.id,
+        };
+    }
+    catch (e) {
+        debugError(e);
+        throw new Error(commands.project.delete.errors.cannotDelete(projectName, getErrorMessage(e)));
+    }
+}
+export async function deleteDeployedComponents(accountId, projectName) {
+    SpinniesManager.add('removeComponents', {
+        text: commands.project.delete.logs.deletingComponents(projectName),
+    });
+    let projectDeletionResponse;
+    try {
+        const { data } = await stageProjectForDeletion(accountId, projectName, false);
+        projectDeletionResponse = data;
+    }
+    catch (e) {
+        debugError(e);
+        SpinniesManager.fail('removeComponents', {
+            text: commands.project.delete.errors.componentDeletionFailed(projectName),
+        });
+        throw new Error(commands.project.delete.errors.componentDeletionFailed(projectName));
+    }
+    const { deployId, hasDeployedComponents } = projectDeletionResponse;
+    if (deployId === undefined) {
+        if (hasDeployedComponents) {
+            SpinniesManager.fail('removeComponents', {
+                text: commands.project.delete.logs.unableToDetermineIfComponentsWereDeleted(projectName),
+            });
+            throw new Error(commands.project.delete.logs.unableToDetermineIfComponentsWereDeleted(projectName));
+        }
+        else {
+            SpinniesManager.succeed('removeComponents', {
+                text: commands.project.delete.logs.componentsDeleted(projectName),
+            });
+        }
+        return;
+    }
+    try {
+        await poll(() => getDeployStatus(accountId, projectName, deployId), {
+            successStates: DELETION_DEPLOY_SUCCESS_STATES,
+            errorStates: DELETION_DEPLOY_ERROR_STATES,
+        }, DELETION_POLL_TIMEOUT_MS);
+        SpinniesManager.succeed('removeComponents', {
+            text: commands.project.delete.logs.componentsDeleted(projectName),
+        });
+    }
+    catch (e) {
+        debugError(e);
+        SpinniesManager.fail('removeComponents', {
+            text: commands.project.delete.errors.componentDeletionFailed(projectName),
+        });
+        throw new Error(commands.project.delete.errors.componentDeletionFailed(projectName));
+    }
+}
+export async function handleProjectDeletion(accountId, projectName) {
+    try {
+        SpinniesManager.add('deleteProject', {
+            text: commands.project.delete.logs.deleting(projectName),
+        });
+        await deleteProject(accountId, projectName);
+        SpinniesManager.succeed('deleteProject', {
+            text: commands.project.delete.logs.deleted(projectName, accountId),
+        });
+    }
+    catch (e) {
+        SpinniesManager.fail('deleteProject', {
+            text: commands.project.delete.errors.deleteFailed(projectName),
+        });
+        throw e;
+    }
+}
+export async function confirmDeletion(projectName, accountId, projectId) {
+    const installCount = await fetchProjectInstallCount(accountId, projectId);
+    if (installCount > 0) {
+        uiLogger.warn(commands.project.delete.logs.installWarning(installCount));
+    }
+    const confirmed = await confirmPrompt(commands.project.delete.prompts.confirmDelete(projectName, accountId), { defaultAnswer: false });
+    if (!confirmed) {
+        uiLogger.log(commands.project.delete.logs.cancelled);
+        throw new PromptExitError(commands.project.delete.logs.cancelled, EXIT_CODES.SUCCESS);
+    }
+}

package/lib/projects/deploy.d.ts

@@ -10,4 +10,4 @@ export declare function logDeployErrors(errorData: {
         };
     }>;
 }): void;
-export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isV2Project: boolean, force: boolean): Promise<Deploy | undefined>;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isLegacyProject: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -47,9 +47,9 @@ function handleBlockedDeploy(deployResp) {
         uiLogger.log('');
     });
 }
-export async function handleProjectDeploy(targetAccountId, projectName, buildId, isV2Project, force) {
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, isLegacyProject, force) {
     let deployId;
-    if (isV2Project) {
+    if (!isLegacyProject) {
         const { data: deployResp } = await deployProjectV2(targetAccountId, projectName, buildId, force);
         if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
             if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {

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;