@hubspot/cli 7.5.11-experimental.0 → 7.7.0-experimental.0

package/lib/dependencyManagement.js

@@ -3,23 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGloballyInstalled = isGloballyInstalled;
-exports.getLatestCliVersion = getLatestCliVersion;
 exports.installPackages = installPackages;
 exports.getProjectPackageJsonLocations = getProjectPackageJsonLocations;
 exports.hasMissingPackages = hasMissingPackages;
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const config_1 = require("./projects/config");
-const child_process_1 = require("child_process");
-const fs_1 = require("@hubspot/local-dev-lib/fs");
+const fs_1 = __importDefault(require("fs"));
+const util_1 = __importDefault(require("util"));
 const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const fs_2 = require("@hubspot/local-dev-lib/fs");
+const config_1 = require("./projects/config");
 const ui_1 = require("./ui");
-const util_1 = __importDefault(require("util"));
 const lang_1 = require("./lang");
 const SpinniesManager_1 = __importDefault(require("./ui/SpinniesManager"));
-const fs_2 = __importDefault(require("fs"));
-const package_json_1 = __importDefault(require("../package.json"));
-const DEFAULT_PACKAGE_MANAGER = 'npm';
+const npm_1 = require("./npm");
 class NoPackageJsonFilesError extends Error {
     constructor(projectName) {
         super((0, lang_1.i18n)(`commands.project.subcommands.installDeps.noPackageJsonInProject`, {
@@ -28,22 +24,6 @@ class NoPackageJsonFilesError extends Error {
         }));
     }
 }
-async function isGloballyInstalled(command) {
-    const exec = util_1.default.promisify(child_process_1.exec);
-    try {
-        await exec(`${command} --version`);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-}
-async function getLatestCliVersion() {
-    const exec = util_1.default.promisify(child_process_1.exec);
-    const { stdout } = await exec(`npm info ${package_json_1.default.name} dist-tags --json`);
-    const { latest, next } = JSON.parse(stdout);
-    return { latest, next };
-}
 async function installPackages({ packages, installLocations, }) {
     const installDirs = installLocations || (await getProjectPackageJsonLocations());
     await Promise.all(installDirs.map(async (dir) => {
@@ -64,14 +44,8 @@ async function installPackagesInDirectory(directory, packages) {
                 directory: relativeDir,
             }),
     });
-    let installCommand = `${DEFAULT_PACKAGE_MANAGER} install`;
-    if (packages) {
-        installCommand = `${installCommand} ${packages.join(' ')}`;
-    }
-    logger_1.logger.debug(`Running ${installCommand}`);
     try {
-        const exec = util_1.default.promisify(child_process_1.exec);
-        await exec(installCommand, { cwd: directory });
+        await (0, npm_1.executeInstall)(packages, null, { cwd: directory });
         SpinniesManager_1.default.succeed(spinner, {
             text: (0, lang_1.i18n)(`commands.project.subcommands.installDeps.installationSuccessful`, {
                 directory: relativeDir,
@@ -99,17 +73,17 @@ async function getProjectPackageJsonLocations() {
         throw new Error((0, lang_1.i18n)(`commands.project.subcommands.installDeps.noProjectConfig`));
     }
     const { projectDir, projectConfig: { srcDir, name }, } = projectConfig;
-    if (!(await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER))) {
+    if (!(await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER))) {
         throw new Error((0, lang_1.i18n)(`commands.project.subcommands.installDeps.packageManagerNotInstalled`, {
-            packageManager: DEFAULT_PACKAGE_MANAGER,
-            link: (0, ui_1.uiLink)(DEFAULT_PACKAGE_MANAGER, 'https://docs.npmjs.com/downloading-and-installing-node-js-and-npm'),
+            packageManager: npm_1.DEFAULT_PACKAGE_MANAGER,
+            link: (0, ui_1.uiLink)(npm_1.DEFAULT_PACKAGE_MANAGER, 'https://docs.npmjs.com/downloading-and-installing-node-js-and-npm'),
         }));
     }
-    if (!fs_2.default.existsSync(projectConfig.projectDir) ||
-        !fs_2.default.existsSync(path_1.default.join(projectDir, srcDir))) {
+    if (!fs_1.default.existsSync(projectConfig.projectDir) ||
+        !fs_1.default.existsSync(path_1.default.join(projectDir, srcDir))) {
         throw new NoPackageJsonFilesError(name);
     }
-    const packageJsonFiles = (await (0, fs_1.walk)(path_1.default.join(projectDir, srcDir))).filter(file => file.includes('package.json') &&
+    const packageJsonFiles = (await (0, fs_2.walk)(path_1.default.join(projectDir, srcDir))).filter(file => file.includes('package.json') &&
         !file.includes('node_modules') &&
         !file.includes('.vite'));
     if (packageJsonFiles.length === 0) {

package/lib/doctor/Doctor.js

@@ -8,6 +8,7 @@ const logger_1 = require("@hubspot/local-dev-lib/logger");
 const config_1 = require("@hubspot/local-dev-lib/config");
 const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
 const dependencyManagement_1 = require("../dependencyManagement");
+const npm_1 = require("../npm");
 const util_1 = __importDefault(require("util"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -230,7 +231,7 @@ class Doctor {
         let latestCLIVersion;
         let nextCliVersion;
         try {
-            const { latest, next } = await (0, dependencyManagement_1.getLatestCliVersion)();
+            const { latest, next } = await (0, npm_1.getLatestCliVersion)();
             latestCLIVersion = latest;
             nextCliVersion = next;
         }

package/lib/filesystem.d.ts

@@ -1,2 +1,2 @@
-export declare function resolveLocalPath(filepath: string): string;
+export declare function resolveLocalPath(filepath?: string): string;
 export declare function isPathFolder(path: string): boolean;

package/lib/interpolation.d.ts

@@ -1,8 +1,7 @@
 export declare const helpers: {
     [key: string]: (stringValue: string) => string;
 };
-type InterpolationData = {
-    [identifier: string]: string | number;
+export type InterpolationData = {
+    [identifier: string]: string | undefined | null | number | boolean;
 };
 export declare function interpolate(stringValue: string, interpolationData: InterpolationData): string;
-export {};

package/lib/lang.d.ts

@@ -1,9 +1,8 @@
+import { InterpolationData } from './interpolation';
 export declare const MISSING_LANGUAGE_DATA_PREFIX = "[Missing language data]";
 type LanguageObject = {
     [key: string]: string | LanguageObject;
 };
-export declare function i18n(lookupDotNotation: string, options?: {
-    [identifier: string]: string | number;
-}): string;
+export declare function i18n(lookupDotNotation: string, options?: InterpolationData): string;
 export declare function setLangData(newLocale: string, newLangObj: LanguageObject): void;
 export {};

package/lib/middleware/autoUpdateMiddleware.d.ts

@@ -0,0 +1 @@
+export declare function autoUpdateCLI(): Promise<void>;

package/lib/middleware/autoUpdateMiddleware.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoUpdateCLI = autoUpdateCLI;
+// Update-notifier is CommonJS, so we need to use require
+const updateNotifier = require('update-notifier');
+const config_1 = require("@hubspot/local-dev-lib/config");
+const package_json_1 = __importDefault(require("../../package.json"));
+const ui_1 = require("../ui");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const en_1 = require("../../lang/en");
+const npm_1 = require("../npm");
+const errorHandlers_1 = require("../errorHandlers");
+const logger_1 = require("../ui/logger");
+// Default behavior is to check for notifications at most once per day
+// update-notifier stores the last checked date in the user's home directory
+const notifier = updateNotifier({
+    pkg: { ...package_json_1.default, name: '@hubspot/cli' },
+    distTag: 'latest',
+    shouldNotifyInNpmScript: true,
+});
+const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
+function updateNotification() {
+    notifier.notify({
+        message: package_json_1.default.name === CMS_CLI_PACKAGE_NAME
+            ? en_1.lib.middleware.updateNotification.cmsUpdateNotification(CMS_CLI_PACKAGE_NAME)
+            : en_1.lib.middleware.updateNotification.cliUpdateNotification,
+        defer: false,
+        boxenOptions: {
+            borderColor: ui_1.UI_COLORS.MARIGOLD_DARK,
+            margin: 1,
+            padding: 1,
+            textAlignment: 'center',
+            borderStyle: 'round',
+            title: package_json_1.default.name === CMS_CLI_PACKAGE_NAME
+                ? null
+                : en_1.lib.middleware.updateNotification.notifyTitle,
+        },
+    });
+}
+async function autoUpdateCLI() {
+    // This lets us back to default update-notifier behavior
+    let showManualInstallHelp = true;
+    if (notifier &&
+        notifier.update &&
+        !process.env.SKIP_HUBSPOT_CLI_AUTO_UPDATES &&
+        (0, config_1.isConfigFlagEnabled)('allowAutoUpdates')) {
+        // Ignore all update notifications if the current version is a pre-release
+        if (!notifier.update.current.includes('-')) {
+            // Attempt auto-update if the current version is not the latest version
+            // Never auto-update for major version updates b/c they are breaking
+            if (!['major', 'latest'].includes(notifier.update.type)) {
+                SpinniesManager_1.default.init({
+                    succeedColor: 'white',
+                });
+                SpinniesManager_1.default.add('cliAutoUpdate', {
+                    text: en_1.lib.middleware.autoUpdateCLI.updateAvailable(notifier.update.latest),
+                });
+                try {
+                    if ((await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER)) &&
+                        (await (0, npm_1.isGloballyInstalled)('hs'))) {
+                        await (0, npm_1.executeInstall)(['@hubspot/cli@latest'], '-g');
+                        showManualInstallHelp = false;
+                        SpinniesManager_1.default.succeed('cliAutoUpdate', {
+                            text: en_1.lib.middleware.autoUpdateCLI.updateSucceeded(notifier.update.latest),
+                        });
+                        logger_1.uiLogger.log('');
+                    }
+                    else {
+                        SpinniesManager_1.default.fail('cliAutoUpdate', {
+                            text: en_1.lib.middleware.autoUpdateCLI.notInstalledGlobally,
+                        });
+                    }
+                }
+                catch (e) {
+                    (0, errorHandlers_1.debugError)(e);
+                    SpinniesManager_1.default.fail('cliAutoUpdate', {
+                        text: en_1.lib.middleware.autoUpdateCLI.updateFailed(notifier.update.latest),
+                    });
+                }
+            }
+        }
+    }
+    if (showManualInstallHelp) {
+        updateNotification();
+    }
+}

package/lib/middleware/configMiddleware.js

@@ -55,6 +55,7 @@ async function loadConfigMiddleware(argv) {
     if (!(0, config_1.configFileExists)(true) &&
         (0, utils_1.isTargetedCommand)(argv._, {
             account: { target: false, subCommands: { auth: { target: true } } },
+            config: { target: false, subCommands: { migrate: { target: true } } },
         })) {
         return;
     }
@@ -94,6 +95,12 @@ const sandboxesSubCommands = {
         delete: { target: true },
     },
 };
+const configSubCommands = {
+    target: false,
+    subCommands: {
+        migrate: { target: true },
+    },
+};
 const SKIP_ACCOUNT_VALIDATION = {
     init: { target: true },
     auth: { target: true },
@@ -101,6 +108,7 @@ const SKIP_ACCOUNT_VALIDATION = {
     accounts: accountsSubCommands,
     sandbox: sandboxesSubCommands,
     sandboxes: sandboxesSubCommands,
+    config: configSubCommands,
 };
 async function validateAccountOptions(argv) {
     // Skip this when no command is provided

package/lib/npm.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_PACKAGE_MANAGER = "npm";
+export declare function isGloballyInstalled(packageName: string): Promise<boolean>;
+export declare function getLatestCliVersion(): Promise<{
+    latest: string;
+    next: string;
+}>;
+export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
+    cwd?: string;
+}): Promise<void>;

package/lib/npm.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PACKAGE_MANAGER = void 0;
+exports.isGloballyInstalled = isGloballyInstalled;
+exports.getLatestCliVersion = getLatestCliVersion;
+exports.executeInstall = executeInstall;
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const package_json_1 = __importDefault(require("../package.json"));
+exports.DEFAULT_PACKAGE_MANAGER = 'npm';
+async function isGloballyInstalled(packageName) {
+    const exec = util_1.default.promisify(child_process_1.exec);
+    try {
+        await exec(`${packageName} --version`);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+async function getLatestCliVersion() {
+    const exec = util_1.default.promisify(child_process_1.exec);
+    const { stdout } = await exec(`npm info ${package_json_1.default.name} dist-tags --json`);
+    const { latest, next } = JSON.parse(stdout);
+    return { latest, next };
+}
+async function executeInstall(packages = [], flags, options) {
+    const installCommand = `${exports.DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
+    logger_1.logger.debug('Running ', installCommand);
+    const exec = util_1.default.promisify(child_process_1.exec);
+    await exec(installCommand, options);
+}

package/lib/projectProfiles.d.ts

@@ -0,0 +1,6 @@
+import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types';
+import { ProjectConfig } from '../types/Projects';
+export declare function logProfileHeader(profileName: string): void;
+export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
+export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
+export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;

package/lib/projectProfiles.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logProfileHeader = logProfileHeader;
+exports.logProfileFooter = logProfileFooter;
+exports.loadProfile = loadProfile;
+exports.exitIfUsingProfiles = exitIfUsingProfiles;
+const path_1 = __importDefault(require("path"));
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const en_1 = require("../lang/en");
+const ui_1 = require("./ui");
+const logger_1 = require("./ui/logger");
+const exitCodes_1 = require("./enums/exitCodes");
+function logProfileHeader(profileName) {
+    (0, ui_1.uiLine)();
+    (0, ui_1.uiBetaTag)(en_1.lib.projectProfiles.logs.usingProfile((0, project_parsing_lib_1.getHsProfileFilename)(profileName)));
+    logger_1.uiLogger.log('');
+}
+function logProfileFooter(profile, includeVariables = false) {
+    logger_1.uiLogger.log(en_1.lib.projectProfiles.logs.profileTargetAccount(profile.accountId));
+    if (includeVariables) {
+        logger_1.uiLogger.log('');
+        logger_1.uiLogger.log(en_1.lib.projectProfiles.logs.profileVariables);
+        Object.entries(profile.variables ?? {}).forEach(([key, value]) => {
+            logger_1.uiLogger.log(`  ${key}: ${value}`);
+        });
+    }
+    (0, ui_1.uiLine)();
+    logger_1.uiLogger.log('');
+}
+function loadProfile(projectConfig, projectDir, profileName) {
+    if (!projectConfig || !projectDir) {
+        logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        return;
+    }
+    const projectSourceDir = path_1.default.join(projectDir, projectConfig.srcDir);
+    const profileFilename = (0, project_parsing_lib_1.getHsProfileFilename)(profileName);
+    try {
+        const profile = (0, project_parsing_lib_1.loadHsProfileFile)(projectSourceDir, profileName);
+        if (!profile) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
+            return;
+        }
+        if (!profile.accountId) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
+            return;
+        }
+        return profile;
+    }
+    catch (e) {
+        logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
+        return;
+    }
+}
+async function exitIfUsingProfiles(projectConfig, projectDir) {
+    if (projectConfig && projectDir) {
+        const existingProfiles = await (0, project_parsing_lib_1.getAllHsProfiles)(path_1.default.join(projectDir, projectConfig.srcDir));
+        if (existingProfiles.length > 0) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+}

package/lib/projects/buildAndDeploy.js

@@ -17,6 +17,8 @@ const urls_1 = require("./urls");
 const exitCodes_1 = require("../enums/exitCodes");
 const en_1 = require("../../lang/en");
 const logger_1 = require("../ui/logger");
+const constants_2 = require("@hubspot/project-parsing-lib/src/lib/constants");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
 const SPINNER_STATUS = {
     SPINNING: 'spinning',
 };
@@ -71,14 +73,27 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
             structureFn(accountId, taskName, taskId),
         ]);
         const subtasks = getSubtasks(initialTaskStatus);
-        const tasksById = subtasks.reduce((acc, subtask) => {
+        const hiddenComponentBuildIds = [];
+        const tasksById = subtasks
+            .filter(subtask => {
+            // TODO: Remove this filtering logic when visible=false for SERVERLESS_PACKAGE
+            const shouldBeVisible = getSubtaskType(subtask) !== (0, project_parsing_lib_1.mapToInternalType)(constants_2.AppFunctionsPackageKey);
+            if (!shouldBeVisible) {
+                hiddenComponentBuildIds.push(subtask.id);
+            }
+            return shouldBeVisible;
+        })
+            .reduce((acc, subtask) => {
             const { id, visible } = subtask;
             if (visible) {
                 acc[id] = subtask;
             }
             return acc;
         }, {});
-        const structuredTasks = Object.keys(taskStructure).map(key => {
+        const structuredTasks = Object.keys(taskStructure)
+            // TODO: Remove this filtering logic when visible=false for SERVERLESS_PACKAGE
+            .filter(buildId => !hiddenComponentBuildIds.includes(buildId))
+            .map(key => {
             return {
                 ...tasksById[key],
                 subtasks: taskStructure[key]

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

@@ -0,0 +1,26 @@
+import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
+import { AppIRNode } from '../../../types/ProjectComponents';
+import LocalDevState from './LocalDevState';
+import LocalDevLogger from './LocalDevLogger';
+type AppDevModeInterfaceConstructorOptions = {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+};
+declare class AppDevModeInterface {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+    _appNode?: AppIRNode | null;
+    appData?: PublicApp;
+    marketplaceAppInstalls?: number;
+    constructor(options: AppDevModeInterfaceConstructorOptions);
+    private get appNode();
+    private getAppInstallUrl;
+    private fetchAppData;
+    private checkMarketplaceAppInstalls;
+    private checkTestAccountAppInstallation;
+    setup(args: any): Promise<void>;
+    start(): Promise<void>;
+    fileChange(filePath: string, event: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export default AppDevModeInterface;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const localDevAuth_1 = require("@hubspot/local-dev-lib/api/localDevAuth");
+const appsDev_1 = require("@hubspot/local-dev-lib/api/appsDev");
+const ui_extensions_dev_server_1 = require("@hubspot/ui-extensions-dev-server");
+const portManager_1 = require("@hubspot/local-dev-lib/portManager");
+const constants_1 = require("../../constants");
+const exitCodes_1 = require("../../enums/exitCodes");
+const structure_1 = require("../../projects/structure");
+const ui_1 = require("../../ui");
+const index_1 = require("../../errorHandlers/index");
+const installAppPrompt_1 = require("../../prompts/installAppPrompt");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const en_1 = require("../../../lang/en");
+const logger_1 = require("../../ui/logger");
+const urls_1 = require("../../app/urls");
+class AppDevModeInterface {
+    localDevState;
+    localDevLogger;
+    _appNode;
+    appData;
+    marketplaceAppInstalls;
+    constructor(options) {
+        this.localDevState = options.localDevState;
+        this.localDevLogger = options.localDevLogger;
+        // Static auth apps are currently only installable in the portal that the project resides in
+        // This limitation will eventually be removed, but in the meantime we need this check or the install
+        // will always fail with a confusing message
+        if (this.appNode?.config.auth.type === constants_1.APP_AUTH_TYPES.STATIC &&
+            this.localDevState.targetTestingAccountId !==
+                this.localDevState.targetProjectAccountId) {
+            logger_1.uiLogger.error(en_1.lib.LocalDevManager.staticAuthAccountsMustMatch);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        if (!this.localDevState.targetProjectAccountId ||
+            !this.localDevState.projectConfig ||
+            !this.localDevState.projectDir) {
+            logger_1.uiLogger.error(en_1.lib.LocalDevManager.failedToInitialize);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+    // Assumes only one app per project
+    get appNode() {
+        if (this._appNode === undefined) {
+            this._appNode =
+                Object.values(this.localDevState.projectNodes).find(structure_1.isAppIRNode) ||
+                    null;
+        }
+        return this._appNode;
+    }
+    async getAppInstallUrl() {
+        if (this.appNode?.config.auth.type === constants_1.APP_AUTH_TYPES.OAUTH) {
+            return (0, urls_1.getOauthAppInstallUrl)({
+                targetAccountId: this.localDevState.targetTestingAccountId,
+                env: this.localDevState.env,
+                clientId: this.appData.clientId, // This is only called after checking that appData exists
+                scopes: this.appNode.config.auth.requiredScopes,
+                redirectUrls: this.appNode.config.auth.redirectUrls,
+            });
+        }
+        const { data: { results }, } = await (0, appsDev_1.fetchPublicAppsForPortal)(this.localDevState.targetProjectAccountId);
+        const app = results.find(app => app.sourceId === this.appNode?.uid);
+        if (!app) {
+            logger_1.uiLogger.error(en_1.lib.LocalDevManager.staticAuthAccountsMustMatch);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        return (0, urls_1.getStaticAuthAppInstallUrl)({
+            targetAccountId: this.localDevState.targetTestingAccountId,
+            env: this.localDevState.env,
+            appId: `${app.id}`,
+        });
+    }
+    async fetchAppData() {
+        const { data: { results: portalApps }, } = await (0, appsDev_1.fetchPublicAppsForPortal)(this.localDevState.targetProjectAccountId);
+        const appData = portalApps.find(({ sourceId }) => sourceId === this.appNode?.uid);
+        if (!appData) {
+            return;
+        }
+        const { data: { uniquePortalInstallCount }, } = await (0, appsDev_1.fetchPublicAppProductionInstallCounts)(appData.id, this.localDevState.targetProjectAccountId);
+        this.appData = appData;
+        this.marketplaceAppInstalls = uniquePortalInstallCount;
+    }
+    async checkMarketplaceAppInstalls() {
+        if (!this.appData || !this.marketplaceAppInstalls) {
+            return;
+        }
+        (0, ui_1.uiLine)();
+        logger_1.uiLogger.warn(en_1.lib.LocalDevManager.activeInstallWarning.installCount(this.appData.name, this.marketplaceAppInstalls));
+        logger_1.uiLogger.log(en_1.lib.LocalDevManager.activeInstallWarning.explanation);
+        (0, ui_1.uiLine)();
+        const proceed = await (0, promptUtils_1.confirmPrompt)(en_1.lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
+        if (!proceed) {
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        }
+        this.localDevLogger.addUploadWarning(en_1.lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
+    }
+    async checkTestAccountAppInstallation() {
+        if (!this.appNode || !this.appData) {
+            return;
+        }
+        // If the app is static auth, always prompt the user to install the app.
+        // We are currently going this because we have no method to determine if the static auth app
+        // is already installed in the portal
+        if (this.appNode.config.auth.type === constants_1.APP_AUTH_TYPES.STATIC) {
+            return (0, installAppPrompt_1.installAppPrompt)(await this.getAppInstallUrl(), false);
+        }
+        const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await (0, localDevAuth_1.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) {
+            const installUrl = await this.getAppInstallUrl();
+            await (0, installAppPrompt_1.installAppPrompt)(installUrl, isReinstall);
+        }
+    }
+    // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
+    // In the future, update UIE Dev Server to use LocalDevState
+    async setup(args) {
+        if (!this.appNode) {
+            return;
+        }
+        try {
+            await this.fetchAppData();
+            if (this.appNode.config.distribution === constants_1.APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+                await this.checkMarketplaceAppInstalls();
+            }
+            await this.checkTestAccountAppInstallation();
+        }
+        catch (e) {
+            (0, index_1.logError)(e);
+        }
+        return ui_extensions_dev_server_1.DevModeUnifiedInterface.setup(args);
+    }
+    async start() {
+        if (!this.appNode) {
+            return;
+        }
+        return ui_extensions_dev_server_1.DevModeUnifiedInterface.start({
+            accountId: this.localDevState.targetTestingAccountId,
+            // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
+            projectConfig: this.localDevState.projectConfig,
+            requestPorts: portManager_1.requestPorts,
+        });
+    }
+    async fileChange(filePath, event) {
+        if (!this.appNode) {
+            return;
+        }
+        return ui_extensions_dev_server_1.DevModeUnifiedInterface.fileChange(filePath, event);
+    }
+    async cleanup() {
+        if (!this.appNode) {
+            return;
+        }
+        return ui_extensions_dev_server_1.DevModeUnifiedInterface.cleanup();
+    }
+}
+exports.default = AppDevModeInterface;

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

@@ -1,33 +1,22 @@
-import { ProjectConfig } from '../../../types/Projects';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
-type DevServerInterface = {
-    setup?: Function;
-    start?: (options: object) => Promise<void>;
-    fileChange?: (filePath: string, event: string) => Promise<void>;
-    cleanup?: () => Promise<void>;
+import LocalDevState from './LocalDevState';
+import LocalDevLogger from './LocalDevLogger';
+type DevServerManagerV2ConstructorOptions = {
+    localDevState: LocalDevState;
+    logger: LocalDevLogger;
 };
 declare class DevServerManagerV2 {
     private initialized;
     private started;
     private devServers;
-    constructor();
-    iterateDevServers(callback: (serverInterface: DevServerInterface) => Promise<void>): Promise<void>;
-    setup({ projectNodes, accountId, setActiveApp, }: {
-        projectNodes: {
-            [key: string]: IntermediateRepresentationNodeLocalDev;
-        };
-        accountId: number;
-        setActiveApp: (appUid: string | undefined) => Promise<void>;
-    }): Promise<void>;
-    start({ accountId, projectConfig, }: {
-        accountId: number;
-        projectConfig: ProjectConfig;
-    }): Promise<void>;
+    private localDevState;
+    constructor(options: DevServerManagerV2ConstructorOptions);
+    private iterateDevServers;
+    setup(): Promise<void>;
+    start(): Promise<void>;
     fileChange({ filePath, event, }: {
         filePath: string;
         event: string;
     }): Promise<void>;
     cleanup(): Promise<void>;
 }
-declare const Manager: DevServerManagerV2;
-export default Manager;
+export default DevServerManagerV2;