@hubspot/cli 8.2.0 → 8.2.1-experimental.1

package/commands/project/dev/unifiedFlow.js

@@ -3,13 +3,14 @@ import util from 'util';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { startPortManagerServer, stopPortManagerServer, } from '@hubspot/local-dev-lib/portManager';
 import { isTranslationError, translateForLocalDev, } from '@hubspot/project-parsing-lib/translate';
-import { getConfigAccountEnvironment, getAllConfigAccounts, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountEnvironment, getLinkedOrAllConfigAccounts, getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { logError } from '../../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { warnAboutSkippedHsMetaFiles } from '../../../lib/projects/ui.js';
 import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
 import { createInitialBuildForNewProject, createNewProjectForLocalDev, compareLocalProjectToDeployed, checkAndInstallDependencies, } from '../../../lib/projects/localDev/helpers/project.js';
 import { useExistingDevTestAccount, createDeveloperTestAccountForLocalDev, selectAccountTypePrompt, createSandboxForLocalDev, } from '../../../lib/projects/localDev/helpers/account.js';
-import { selectDeveloperTestTargetAccountPrompt, selectSandboxTargetAccountPrompt, } from '../../../lib/prompts/projectDevTargetAccountPrompt.js';
+import { selectDeveloperTestTargetAccountPrompt, selectSandboxTargetAccountPrompt, confirmLinkExistingDeveloperTestAccountPrompt, } from '../../../lib/prompts/projectDevTargetAccountPrompt.js';
 import LocalDevProcess from '../../../lib/projects/localDev/LocalDevProcess.js';
 import LocalDevWatcher from '../../../lib/projects/localDev/LocalDevWatcher.js';
 import { handleExit, handleKeypress } from '../../../lib/process.js';
@@ -17,15 +18,21 @@ import { isTestAccountOrSandbox, isUnifiedAccount, } from '../../../lib/accountT
 import { uiLogger } from '../../../lib/ui/logger.js';
 import { commands } from '../../../lang/en.js';
 import LocalDevWebsocketServer from '../../../lib/projects/localDev/LocalDevWebsocketServer.js';
-import { confirmLocalDevIsNotRunning } from '../../../lib/projects/localDev/helpers/process.js';
+import { isLocalDevRunning } from '../../../lib/projects/localDev/helpers/process.js';
+import { getHsSettingsFileIfExists, getHsSettingsFilePath, } from '@hubspot/local-dev-lib/config/hsSettings';
+import { isDirectoryLinked, addAccountToLinkedSettings, } from '../../../lib/link/linkUtils.js';
 export async function unifiedProjectDevFlow({ args, targetProjectAccountId, providedTargetTestingAccountId, projectConfig, projectDir, }) {
-    await confirmLocalDevIsNotRunning();
+    const { exit } = args;
+    if (await isLocalDevRunning()) {
+        uiLogger.error(commands.project.dev.errors.localDevAlreadyRunning);
+        return exit(EXIT_CODES.ERROR);
+    }
     const env = getConfigAccountEnvironment(targetProjectAccountId);
     let projectNodes;
     let projectProfileData;
     // Get IR
     try {
-        const intermediateRepresentation = await translateForLocalDev({
+        const { intermediateRepresentation, skippedHsMetaFiles } = await translateForLocalDev({
             projectSourceDir: path.join(projectDir, projectConfig.srcDir),
             platformVersion: projectConfig.platformVersion,
             accountId: targetProjectAccountId,
@@ -33,6 +40,7 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         projectNodes = intermediateRepresentation.intermediateNodesIndexedByUid;
         projectProfileData = intermediateRepresentation.profileData;
         uiLogger.debug(util.inspect(projectNodes, false, null, true));
+        await warnAboutSkippedHsMetaFiles(skippedHsMetaFiles, true, false);
     }
     catch (e) {
         if (isTranslationError(e)) {
@@ -41,23 +49,29 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         else {
             logError(e);
         }
-        return process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     if (!Object.keys(projectNodes).length) {
         uiLogger.error(commands.project.dev.errors.noRunnableComponents);
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     const targetProjectAccountConfig = getConfigAccountById(targetProjectAccountId);
     if (!targetProjectAccountConfig) {
         uiLogger.error(commands.project.dev.errors.noAccount(targetProjectAccountId));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    const accounts = getAllConfigAccounts();
+    const hsSettings = getHsSettingsFileIfExists();
+    const directoryIsLinked = isDirectoryLinked(hsSettings);
+    const accounts = getLinkedOrAllConfigAccounts();
     const accountIsCombined = await isUnifiedAccount(targetProjectAccountConfig);
     const targetProjectAccountIsTestAccountOrSandbox = isTestAccountOrSandbox(targetProjectAccountConfig);
     if (!accountIsCombined) {
         uiLogger.error(commands.project.dev.errors.accountNotCombined);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
+    }
+    if (directoryIsLinked && !providedTargetTestingAccountId) {
+        uiLogger.log('');
+        uiLogger.info(commands.account.subcommands.link.shared.usingLinkedAccounts(getHsSettingsFilePath()));
     }
     let targetTestingAccountId = providedTargetTestingAccountId;
     // Temporarily removing logic to use profile account as testing account
@@ -77,16 +91,39 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         const accountType = await selectAccountTypePrompt(targetProjectAccountConfig);
         if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST) {
             const devAccountPromptResponse = await selectDeveloperTestTargetAccountPrompt(accounts, targetProjectAccountConfig);
+            const { notInConfigAccount } = devAccountPromptResponse;
             targetTestingAccountId =
                 devAccountPromptResponse.targetAccountId || undefined;
-            if (!!devAccountPromptResponse.notInConfigAccount) {
-                // When the developer test account isn't configured in the CLI config yet
-                // Walk the user through adding the account's PAK to the config
-                await useExistingDevTestAccount(env, devAccountPromptResponse.notInConfigAccount);
+            if (notInConfigAccount) {
+                const existingGlobalConfig = getConfigAccountIfExists(notInConfigAccount.id);
+                if (directoryIsLinked && existingGlobalConfig) {
+                    const shouldLink = await confirmLinkExistingDeveloperTestAccountPrompt(notInConfigAccount.accountName);
+                    if (!shouldLink) {
+                        return exit(EXIT_CODES.SUCCESS);
+                    }
+                    addAccountToLinkedSettings(notInConfigAccount.id);
+                }
+                else {
+                    const accountAdded = await useExistingDevTestAccount(env, notInConfigAccount);
+                    if (!accountAdded) {
+                        return exit(EXIT_CODES.SUCCESS);
+                    }
+                    if (directoryIsLinked) {
+                        addAccountToLinkedSettings(notInConfigAccount.id);
+                    }
+                }
             }
             else if (devAccountPromptResponse.createNestedAccount) {
                 // Create a new developer test account and automatically add it to the CLI config
-                targetTestingAccountId = await createDeveloperTestAccountForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env, true);
+                try {
+                    targetTestingAccountId = await createDeveloperTestAccountForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env, true);
+                }
+                catch {
+                    return exit(EXIT_CODES.ERROR);
+                }
+                if (directoryIsLinked) {
+                    addAccountToLinkedSettings(targetTestingAccountId);
+                }
             }
         }
         else if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
@@ -94,7 +131,15 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
             targetTestingAccountId =
                 sandboxAccountPromptResponse.targetAccountId || undefined;
             if (sandboxAccountPromptResponse.createNestedAccount) {
-                targetTestingAccountId = await createSandboxForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env);
+                try {
+                    targetTestingAccountId = await createSandboxForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env);
+                }
+                catch {
+                    return exit(EXIT_CODES.ERROR);
+                }
+                if (directoryIsLinked) {
+                    addAccountToLinkedSettings(targetTestingAccountId);
+                }
             }
         }
         else {
@@ -110,22 +155,34 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         noLogs: true,
     });
     let project = uploadedProject;
+    // Fail fast before the slower project checks below.
+    const autoDeployEnabled = (project?.deployedBuild ?? project?.latestBuild)?.isAutoDeployEnabled ??
+        true;
+    if (args.autoUpload && !autoDeployEnabled) {
+        uiLogger.error(commands.project.dev.errors.autoUploadRequiresAutoDeploy);
+        return exit(EXIT_CODES.ERROR);
+    }
     if (projectExists && project) {
-        await compareLocalProjectToDeployed(projectConfig, targetProjectAccountId, project.deployedBuild?.buildId, projectNodes, args.profile);
+        await compareLocalProjectToDeployed(projectConfig, targetProjectAccountId, project.deployedBuild?.buildId, projectNodes, exit, args.profile);
     }
     else {
-        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, false, false);
-        await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId, true, args.profile);
+        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, false, false, exit);
+        await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId, exit, true, args.profile);
     }
     // Check for missing/outdated dependencies
-    await checkAndInstallDependencies();
+    try {
+        await checkAndInstallDependencies();
+    }
+    catch {
+        return exit(EXIT_CODES.ERROR);
+    }
     // End setup, start local dev process
     try {
-        await startPortManagerServer();
+        await startPortManagerServer(args.port);
     }
     catch (e) {
         logError(e);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     const localDevProcess = new LocalDevProcess({
         initialProjectNodes: projectNodes,
@@ -138,6 +195,8 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         projectDir,
         projectData: project,
         env,
+        actions: { exit },
+        autoUploadEnabled: Boolean(args.autoUpload) && autoDeployEnabled,
     });
     const websocketServer = new LocalDevWebsocketServer(localDevProcess, args.debug);
     const watcher = new LocalDevWatcher(localDevProcess);

package/commands/project/download.js

@@ -3,26 +3,26 @@ import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
 import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
 import { downloadProject, fetchProjectBuilds, } from '@hubspot/local-dev-lib/api/projects';
 import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
-import { getProjectConfig } from '../../lib/projects/config.js';
+import { isPromptExitError } from '../../lib/errors/PromptExitError.js';
+import { getIsInProject } from '../../lib/projects/config.js';
 import { downloadProjectPrompt } from '../../lib/prompts/downloadProjectPrompt.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 const command = 'download';
 const describe = commands.project.download.describe;
 async function handler(args) {
-    const { projectConfig } = await getProjectConfig();
-    if (projectConfig) {
+    const { dest, build, derivedAccountId, exit } = args;
+    const isInProjectDir = getIsInProject();
+    if (isInProjectDir) {
         uiLogger.error(commands.project.download.warnings.cannotDownloadWithinProject);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    const { dest, build, derivedAccountId } = args;
-    const { project: projectName } = await downloadProjectPrompt(args);
     let buildNumberToDownload = build;
-    trackCommandUsage('project-download', undefined, derivedAccountId);
     try {
+        const { project: projectName } = await downloadProjectPrompt(args);
         if (!buildNumberToDownload) {
             const { data: projectBuildsResult } = await fetchProjectBuilds(derivedAccountId, projectName);
             const { results: projectBuilds } = projectBuildsResult;
@@ -33,7 +33,7 @@ async function handler(args) {
         }
         if (!buildNumberToDownload) {
             uiLogger.error(commands.project.download.errors.noBuildIdToDownload);
-            process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
         const sanitizedProjectName = sanitizeFileName(projectName);
         const absoluteDestPath = dest
@@ -42,14 +42,17 @@ async function handler(args) {
         const { data: zippedProject } = await downloadProject(derivedAccountId, projectName, buildNumberToDownload);
         await extractZipArchive(zippedProject, sanitizeFileName(projectName), path.resolve(absoluteDestPath));
         uiLogger.log(commands.project.download.logs.downloadSucceeded(buildNumberToDownload, projectName));
-        process.exit(EXIT_CODES.SUCCESS);
+        return exit(EXIT_CODES.SUCCESS);
     }
     catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
         logError(e, new ApiErrorContext({
             accountId: derivedAccountId,
             request: 'project download',
         }));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
 }
 function projectDownloadBuilder(yargs) {
@@ -85,7 +88,7 @@ const builder = makeYargsBuilder(projectDownloadBuilder, command, describe, {
 const projectDownloadCommand = {
     command,
     describe,
-    handler,
+    handler: makeWrappedYargsHandler('project-download', handler),
     builder,
 };
 export default projectDownloadCommand;

package/commands/project/info.d.ts

@@ -0,0 +1,5 @@
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+import { ProjectInfoJsonOutput } from '../../lib/jsonOutput.js';
+export type ProjectInfoArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs<ProjectInfoJsonOutput>;
+declare const projectInfoCommand: YargsCommandModule<unknown, ProjectInfoArgs>;
+export default projectInfoCommand;

package/commands/project/info.js

@@ -0,0 +1,73 @@
+import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import { debugError, logError } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { getProjectConfig } from '../../lib/projects/config.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { getProjectInfo, logProjectInfo, } from '../../lib/projects/projectInfo.js';
+import { ProjectInfoSchema, } from '../../lib/jsonOutput.js';
+const command = 'info';
+const describe = commands.project.info.describe;
+const verboseDescribe = commands.project.info.verboseDescribe;
+async function handler(args) {
+    const { derivedAccountId, formatOutputAsJson, exit, addJsonOutput } = args;
+    let projectConfig;
+    try {
+        ({ projectConfig } = getProjectConfig());
+    }
+    catch (error) {
+        logError(error);
+        return exit(EXIT_CODES.ERROR);
+    }
+    if (isLegacyProject(projectConfig.platformVersion)) {
+        uiLogger.error(commands.project.info.errors.unsupportedPlatformVersion(projectConfig.platformVersion));
+        return exit(EXIT_CODES.ERROR);
+    }
+    const projectName = projectConfig.name;
+    let project;
+    try {
+        const response = await fetchProject(derivedAccountId, projectName);
+        project = response.data;
+    }
+    catch (error) {
+        debugError(error);
+        uiLogger.error(commands.project.info.errors.projectNotFound(projectName, derivedAccountId));
+        return exit(EXIT_CODES.ERROR);
+    }
+    const deployedBuild = project.deployedBuild;
+    if (!deployedBuild) {
+        uiLogger.error(commands.project.info.errors.noDeployedBuild);
+        return exit(EXIT_CODES.ERROR);
+    }
+    const projectInfo = await getProjectInfo(project, projectConfig.platformVersion, derivedAccountId);
+    addJsonOutput(projectInfo);
+    if (!formatOutputAsJson) {
+        logProjectInfo(projectInfo);
+    }
+}
+function projectInfoBuilder(yargs) {
+    yargs.example([
+        ['$0 project info', commands.project.info.examples.default],
+        ['$0 project info --json', commands.project.info.examples.json],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectInfoBuilder, command, verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useJSONOutputOptions: true,
+});
+const projectInfoCommand = {
+    command,
+    describe,
+    handler: makeWrappedYargsHandler('project-info', handler, {
+        jsonOutputSchema: ProjectInfoSchema,
+    }),
+    builder,
+};
+export default projectInfoCommand;

package/commands/project/installApp.d.ts

@@ -0,0 +1,8 @@
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+import { InstallAppJsonOutput } from '../../lib/jsonOutput.js';
+export type ProjectInstallAppArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs<InstallAppJsonOutput> & {
+    force: boolean;
+    profile?: string;
+};
+declare const projectInstallAppCommand: YargsCommandModule<unknown, ProjectInstallAppArgs>;
+export default projectInstallAppCommand;

package/commands/project/installApp.js

@@ -0,0 +1,185 @@
+import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
+import { InstallAppSchema, } from '../../lib/jsonOutput.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { commands } from '../../lang/en.js';
+import { getProjectConfig } from '../../lib/projects/config.js';
+import { APP_INSTALLATION_STATES } from '../../lib/constants.js';
+import { getAppInstallationState } from '../../lib/app/install.js';
+import { confirmInstallAppAction, fetchProjectAppInstallationData, installStaticAuthAppForAccount, loadInstallableAppNode, resolveAppMetadata, resolveProjectId, resolveProjectAccountId, resolveValidInstallAccount, } from '../../lib/projects/installApp.js';
+const command = 'install-app';
+const describe = commands.project.installApp.describe;
+const verboseDescribe = commands.project.installApp.verboseDescribe;
+async function handler(args) {
+    const { derivedAccountId, formatOutputAsJson, force, profile: profileOption, useEnv: useEnvOption, exit, addJsonOutput, } = args;
+    let projectConfig;
+    let projectDir;
+    try {
+        ({ projectConfig, projectDir } = getProjectConfig());
+    }
+    catch (error) {
+        logError(error);
+        return exit(EXIT_CODES.ERROR);
+    }
+    if (isLegacyProject(projectConfig.platformVersion)) {
+        uiLogger.error(commands.project.installApp.errors.unsupportedPlatformVersion(projectConfig.platformVersion));
+        return exit(EXIT_CODES.ERROR);
+    }
+    const resolvedProjectAccount = await resolveProjectAccountId(derivedAccountId, projectConfig, projectDir, profileOption, !!useEnvOption);
+    if (resolvedProjectAccount === null) {
+        return exit(EXIT_CODES.ERROR);
+    }
+    const appNode = await loadInstallableAppNode(projectConfig, projectDir, resolvedProjectAccount.accountId, force);
+    if (!appNode) {
+        return exit(EXIT_CODES.ERROR);
+    }
+    const installAccountId = await resolveValidInstallAccount(resolvedProjectAccount.accountId, force, Boolean(formatOutputAsJson));
+    if (installAccountId === null) {
+        return exit(EXIT_CODES.ERROR);
+    }
+    const targetAccountConfig = getConfigAccountIfExists(installAccountId);
+    // A profile only applies if we didn't switch away from its account.
+    const uploadProfile = installAccountId === resolvedProjectAccount.accountId
+        ? resolvedProjectAccount.profileName
+        : undefined;
+    const projectId = await resolveProjectId({
+        accountId: installAccountId,
+        projectConfig,
+        projectDir,
+        profile: uploadProfile,
+        force,
+        formatOutputAsJson: Boolean(formatOutputAsJson),
+    });
+    if (projectId === null) {
+        return exit(EXIT_CODES.ERROR);
+    }
+    const installationData = await fetchProjectAppInstallationData(installAccountId, projectId, appNode, projectConfig);
+    if (installationData === null) {
+        return exit(EXIT_CODES.ERROR);
+    }
+    let appId = installationData.appId;
+    const { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups } = installationData;
+    const needsReinstall = !isInstalledWithScopeGroups && previouslyAuthorizedScopeGroups.length > 0;
+    const installationState = getAppInstallationState(isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups);
+    if (isInstalledWithScopeGroups) {
+        addJsonOutput({
+            appId,
+            appUid: appNode.uid,
+            accountId: installAccountId,
+            projectId,
+            installationState,
+            installed: true,
+            reinstalled: false,
+        });
+        if (!formatOutputAsJson) {
+            uiLogger.success(commands.project.installApp.alreadyInstalled(appNode.config.name, installAccountId));
+        }
+        return exit(EXIT_CODES.SUCCESS);
+    }
+    const shouldInstall = await confirmInstallAppAction({
+        appName: appNode.config.name,
+        targetAccountId: installAccountId,
+        force,
+        needsReinstall,
+    });
+    if (!shouldInstall) {
+        return exit(EXIT_CODES.SUCCESS);
+    }
+    const metadata = await resolveAppMetadata({
+        appId,
+        projectId,
+        appUid: appNode.uid,
+        appName: appNode.config.name,
+        accountId: installAccountId,
+        projectConfig,
+        projectDir,
+        profile: uploadProfile,
+        force,
+        formatOutputAsJson: Boolean(formatOutputAsJson),
+    });
+    if (metadata === null) {
+        return exit(EXIT_CODES.ERROR);
+    }
+    appId = metadata.appId;
+    const installed = await installStaticAuthAppForAccount({
+        appId,
+        appNode,
+        appName: appNode.config.name,
+        targetAccountId: installAccountId,
+        targetAccountConfig,
+        projectId,
+        projectName: projectConfig.name,
+        scopeGroupIds: metadata.scopeGroupIds,
+        ownerPortalId: metadata.ownerPortalId,
+        installationState,
+        formatOutputAsJson: Boolean(formatOutputAsJson),
+    });
+    if (!installed) {
+        return exit(EXIT_CODES.ERROR);
+    }
+    addJsonOutput({
+        appId,
+        appUid: appNode.uid,
+        accountId: installAccountId,
+        projectId,
+        installationState: APP_INSTALLATION_STATES.INSTALLED,
+        installed: true,
+        reinstalled: needsReinstall,
+    });
+    if (!formatOutputAsJson) {
+        uiLogger.success(commands.project.installApp.success(appNode.config.name, installAccountId));
+    }
+    return exit(EXIT_CODES.SUCCESS);
+}
+function projectInstallAppBuilder(yargs) {
+    yargs.options({
+        force: {
+            alias: ['f'],
+            describe: commands.project.installApp.options.force,
+            default: false,
+            type: 'boolean',
+        },
+        profile: {
+            alias: 'p',
+            describe: commands.project.installApp.options.profile,
+            type: 'string',
+        },
+    });
+    yargs.conflicts('profile', 'account');
+    yargs.example([
+        ['$0 project install-app', commands.project.installApp.examples.default],
+        [
+            '$0 project install-app --account=12345678',
+            commands.project.installApp.examples.withAccount,
+        ],
+        [
+            '$0 project install-app --profile=qa',
+            commands.project.installApp.examples.withProfile,
+        ],
+        [
+            '$0 project install-app --json',
+            commands.project.installApp.examples.json,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectInstallAppBuilder, command, verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useJSONOutputOptions: true,
+});
+const projectInstallAppCommand = {
+    command,
+    describe,
+    handler: makeWrappedYargsHandler('project-install-app', handler, {
+        jsonOutputSchema: InstallAppSchema,
+    }),
+    builder,
+};
+export default projectInstallAppCommand;

package/commands/project/installDeps.js

@@ -1,25 +1,27 @@
 import { installPackages, getProjectPackageJsonLocations, } from '../../lib/dependencyManagement.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { isPromptExitError } from '../../lib/errors/PromptExitError.js';
 import { getProjectConfig } from '../../lib/projects/config.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import path from 'path';
 import { commands } from '../../lang/en.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { showMcpPromotionNudge } from '../../lib/mcp/promotion.js';
 const command = 'install-deps [packages..]';
 const describe = commands.project.installDeps.help.describe;
 async function handler(args) {
-    const { derivedAccountId, packages } = args;
+    const { packages, exit } = args;
     try {
-        trackCommandUsage('project-install-deps', undefined, derivedAccountId);
-        const projectConfig = await getProjectConfig();
-        if (!projectConfig || !projectConfig.projectDir) {
-            uiLogger.error(commands.project.installDeps.noProjectConfig);
-            return process.exit(EXIT_CODES.ERROR);
+        let projectDir;
+        try {
+            ({ projectDir } = getProjectConfig());
+        }
+        catch (error) {
+            logError(error);
+            return exit(EXIT_CODES.ERROR);
         }
-        const { projectDir } = projectConfig;
         let installLocations = await getProjectPackageJsonLocations();
         if (packages) {
             const { selectedInstallLocations } = await promptUser([
@@ -48,10 +50,14 @@ async function handler(args) {
             packages,
             installLocations,
         });
+        await showMcpPromotionNudge(args._.join(' '));
     }
     catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
         logError(e);
-        return process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
 }
 function projectInstallDepsBuilder(yargs) {
@@ -74,7 +80,7 @@ const builder = makeYargsBuilder(projectInstallDepsBuilder, command, describe, {
 const projectInstallDepsCommand = {
     command,
     describe,
-    handler,
+    handler: makeWrappedYargsHandler('project-install-deps', handler),
     builder,
 };
 export default projectInstallDepsCommand;