@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/projects/create/index.d.ts

@@ -0,0 +1,24 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { ProjectTemplateRepoConfig } from '../../../types/Projects.js';
+import { SelectProjectTemplatePromptResponse, ProjectNameAndDestPromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs.js';
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+export type ProjectCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    dest?: string;
+    templateSource?: RepoPath;
+    template?: string;
+    features?: string[];
+    platformVersion: string;
+    projectBase?: string;
+    auth?: string;
+    distribution?: string;
+};
+export declare function handleProjectCreationFlow(args: ArgumentsCamelCase<ProjectCreateArgs>): Promise<{
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
+    projectNameAndDestPromptResponse: ProjectNameAndDestPromptResponse;
+}>;

package/lib/projects/create/index.js

@@ -0,0 +1,36 @@
+import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
+import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
+import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
+import { useV3Api } from '../platformVersion.js';
+import { v3ComponentFlow } from './v3.js';
+import { getProjectTemplateListFromRepo } from './legacy.js';
+import { uiLogger } from '../../ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+export async function handleProjectCreationFlow(args) {
+    const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
+    const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+    const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
+    if (useV3Api(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
+        const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
+        return {
+            authType,
+            distribution,
+            repoConfig,
+            projectContents,
+            selectProjectTemplatePromptResponse,
+            projectNameAndDestPromptResponse,
+        };
+    }
+    const projectTemplates = await getProjectTemplateListFromRepo(repo, DEFAULT_PROJECT_TEMPLATE_BRANCH);
+    if (!projectTemplates.length) {
+        uiLogger.error(commands.project.create.errors.failedToFetchProjectList);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, projectTemplates);
+    return {
+        selectProjectTemplatePromptResponse,
+        projectNameAndDestPromptResponse,
+    };
+}

package/lib/projects/create/legacy.d.ts

@@ -0,0 +1,6 @@
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+import { ProjectTemplate, ComponentTemplate, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
+export declare const EMPTY_PROJECT_TEMPLATE_NAME = "no-template";
+export declare function getConfigForPlatformVersion(platformVersion: string): Promise<ProjectTemplateRepoConfig> | never;
+export declare function getProjectComponentListFromRepo(platformVersion: string): Promise<ComponentTemplate[]>;
+export declare function getProjectTemplateListFromRepo(templateSource: RepoPath, githubRef: string): Promise<ProjectTemplate[]>;

package/lib/projects/create/legacy.js

@@ -0,0 +1,53 @@
+import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
+import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { debugError } from '../../errorHandlers/index.js';
+import { uiLogger } from '../../ui/logger.js';
+import { useV3Api } from '../platformVersion.js';
+import { lib } from '../../../lang/en.js';
+const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
+export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
+export async function getConfigForPlatformVersion(platformVersion) {
+    let path = '';
+    if (useV3Api(platformVersion)) {
+        path = `${platformVersion}/`;
+    }
+    const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, DEFAULT_PROJECT_TEMPLATE_BRANCH);
+    return data;
+}
+export async function getProjectComponentListFromRepo(platformVersion) {
+    let config;
+    try {
+        config = await getConfigForPlatformVersion(platformVersion);
+    }
+    catch (err) {
+        debugError(err);
+    }
+    if (config) {
+        return config[PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
+    }
+    return [];
+}
+export async function getProjectTemplateListFromRepo(templateSource, githubRef) {
+    let config;
+    try {
+        const { data } = await fetchRepoFile(templateSource, 'config.json', githubRef);
+        config = data;
+    }
+    catch (e) {
+        debugError(e);
+        uiLogger.error(lib.projects.create.errors.missingConfigFileTemplateSource);
+        return process.exit(EXIT_CODES.ERROR);
+    }
+    if (!config || !config[PROJECT_COMPONENT_TYPES.PROJECTS]) {
+        uiLogger.error(lib.projects.create.errors.noProjectsInConfig);
+        return process.exit(EXIT_CODES.ERROR);
+    }
+    const templates = config[PROJECT_COMPONENT_TYPES.PROJECTS];
+    const templatesContainAllProperties = templates.every(config => PROJECT_TEMPLATE_PROPERTIES.every(p => Object.prototype.hasOwnProperty.call(config, p)));
+    if (!templatesContainAllProperties) {
+        uiLogger.error(lib.projects.create.errors.missingPropertiesInConfig);
+        return process.exit(EXIT_CODES.ERROR);
+    }
+    return templates;
+}

package/lib/projects/create/v3.d.ts

@@ -0,0 +1,26 @@
+import { Separator } from '@inquirer/prompts';
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
+import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
+export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
+    authType: string;
+    distribution: string;
+}>;
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, accountId: number, projectMetadata?: ProjectMetadata): Promise<(ComponentTemplateChoice | Separator)[]>;
+type V3ComponentInfo = {
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
+};
+export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V3ComponentInfo>;
+export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
+    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
+    platformVersion: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    authType?: string;
+    distribution?: string;
+}): string[];
+export {};

package/lib/projects/create/v3.js

@@ -0,0 +1,171 @@
+import { Separator } from '@inquirer/prompts';
+import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, FEATURES, } from '../../constants.js';
+import { commands, lib } from '../../../lang/en.js';
+import { listPrompt } from '../../prompts/promptUtils.js';
+import chalk from 'chalk';
+import { useV3Api } from '../platformVersion.js';
+import path from 'path';
+import { getConfigForPlatformVersion } from './legacy.js';
+import { logError } from '../../errorHandlers/index.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { hasFeature } from '../../hasFeature.js';
+import { AppEventsKey, PagesKey, } from '@hubspot/project-parsing-lib/src/lib/constants.js';
+export async function createV3App(providedAuth, providedDistribution) {
+    let authType;
+    if (providedAuth &&
+        providedDistribution === marketplaceDistribution &&
+        providedAuth !== oAuth) {
+        throw new Error(lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
+    }
+    const distribution = providedDistribution ||
+        (await listPrompt(lib.projects.create.prompt.distribution, {
+            choices: [
+                {
+                    name: lib.projects.create.prompt.marketPlaceDistribution,
+                    value: marketplaceDistribution,
+                },
+                {
+                    name: lib.projects.create.prompt.privateDistribution,
+                    value: privateDistribution,
+                },
+            ],
+        }));
+    if (distribution === marketplaceDistribution) {
+        // This is the only valid auth type for marketplace
+        authType = oAuth;
+    }
+    else {
+        authType =
+            providedAuth ||
+                (await listPrompt(lib.projects.create.prompt.auth, {
+                    choices: [
+                        { name: lib.projects.create.prompt.staticAuth, value: staticAuth },
+                        { name: lib.projects.create.prompt.oauth, value: oAuth },
+                    ],
+                }));
+    }
+    return {
+        distribution: distribution,
+        authType: authType,
+    };
+}
+const componentTypeToGateMap = {
+    [AppEventsKey]: FEATURES.APP_EVENTS,
+    [PagesKey]: FEATURES.APPS_HOME,
+    'workflow-action-tool': FEATURES.AGENT_TOOLS,
+};
+export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
+    const enabledComponents = [];
+    const disabledComponents = [];
+    for (const template of components) {
+        const { supportedAuthTypes, supportedDistributions } = template;
+        const disabledReasons = [];
+        if (projectMetadata) {
+            const componentMetadata = projectMetadata.components[template.type];
+            if (!componentMetadata) {
+                disabledReasons.push(commands.project.add.error.invalidComponentType(template.type));
+            }
+            else {
+                const { count, maxCount } = componentMetadata;
+                if (count >= maxCount) {
+                    disabledReasons.push(commands.project.add.error.maxExceeded(maxCount));
+                }
+            }
+        }
+        if (Array.isArray(supportedAuthTypes) &&
+            authType &&
+            !supportedAuthTypes.includes(authType.toLowerCase())) {
+            disabledReasons.push(commands.project.add.error.authTypeNotAllowed(authType));
+        }
+        if (Array.isArray(supportedDistributions) &&
+            distribution &&
+            !supportedDistributions.includes(distribution.toLowerCase())) {
+            disabledReasons.push(commands.project.add.error.distributionNotAllowed(distribution));
+        }
+        const templateGate = componentTypeToGateMap[template.cliSelector || template.type];
+        if (templateGate) {
+            const isUngated = await hasFeature(accountId, templateGate);
+            if (!isUngated) {
+                disabledReasons.unshift(commands.project.add.error.portalDoesNotHaveAccessToThisFeature(accountId));
+            }
+        }
+        if (disabledReasons.length > 0) {
+            disabledComponents.push({
+                name: `[${chalk.yellow('DISABLED')}] ${template.label} -`,
+                value: template,
+                disabled: disabledReasons.join(' '),
+            });
+        }
+        else {
+            enabledComponents.push({
+                name: `${template.label} [${template.cliSelector || template.type}]`,
+                value: template,
+            });
+        }
+    }
+    return disabledComponents.length
+        ? [
+            ...enabledComponents,
+            new Separator(),
+            ...disabledComponents,
+            new Separator(),
+        ]
+        : [...enabledComponents];
+}
+export async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
+    let repoConfig = undefined;
+    let authType;
+    let distribution;
+    try {
+        repoConfig = await getConfigForPlatformVersion(platformVersion);
+    }
+    catch (error) {
+        logError(error);
+        return process.exit(EXIT_CODES.SUCCESS);
+    }
+    const projectContentsChoice = projectBase ||
+        (await listPrompt(commands.project.create.prompts.parentComponents, {
+            choices: [
+                {
+                    name: commands.project.create.prompts.emptyProject,
+                    value: EMPTY_PROJECT,
+                },
+                { name: commands.project.create.prompts.app, value: PROJECT_WITH_APP },
+            ],
+        }));
+    if (projectContentsChoice === PROJECT_WITH_APP) {
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
+        authType = selectedAuthType;
+        distribution = selectedDistribution;
+    }
+    const componentTemplateChoices = await calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution, accountId);
+    return {
+        componentTemplateChoices,
+        authType,
+        distribution,
+        projectContents: projectContentsChoice,
+        repoConfig,
+    };
+}
+export function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
+    if (!useV3Api(platformVersion)) {
+        return [];
+    }
+    const components = selectProjectTemplatePromptResponse.componentTemplates?.map((componentTemplate) => {
+        return path.join(platformVersion, componentTemplate.path);
+    }) || [];
+    if (projectContents && projectContents !== EMPTY_PROJECT) {
+        const parentComponent = repoConfig?.parentComponents?.find(possibleParent => {
+            return (possibleParent.type === projectContents &&
+                possibleParent.authType === authType &&
+                possibleParent.distribution === distribution);
+        });
+        if (parentComponent) {
+            components.push(path.join(platformVersion, parentComponent.path));
+        }
+    }
+    if (repoConfig?.defaultFiles) {
+        components.push(path.join(platformVersion, repoConfig?.defaultFiles));
+    }
+    return components;
+}

package/lib/projects/deploy.d.ts

@@ -0,0 +1,13 @@
+import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
+export declare function validateBuildIdForDeploy(buildId: number, deployedBuildId: number | undefined, latestBuildId: number, projectName: string | undefined, accountId: number): boolean | string;
+export declare function logDeployErrors(errorData: {
+    message: string;
+    errors: Array<{
+        message: string;
+        subCategory: string;
+        context: {
+            COMPONENT_NAME: string;
+        };
+    }>;
+}): void;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, useV3Api: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -0,0 +1,63 @@
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { PROJECT_ERROR_TYPES } from '../constants.js';
+import { deployProject } from '@hubspot/local-dev-lib/api/projects';
+import { pollDeployStatus } from './pollProjectBuildAndDeploy.js';
+export function validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId) {
+    if (Number(buildId) > latestBuildId) {
+        return commands.project.deploy.errors.buildIdDoesNotExist(accountId, buildId, projectName);
+    }
+    if (Number(buildId) === deployedBuildId) {
+        return commands.project.deploy.errors.buildAlreadyDeployed(accountId, buildId, projectName);
+    }
+    return true;
+}
+export function logDeployErrors(errorData) {
+    uiLogger.error(errorData.message);
+    errorData.errors.forEach(err => {
+        // This is how the pre-deploy check manifests itself in < 2025.2 projects
+        if (err.subCategory === PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS) {
+            uiLogger.log(commands.project.deploy.errors.deployContainsRemovals(err.context.COMPONENT_NAME));
+        }
+        else {
+            uiLogger.log(err.message);
+        }
+    });
+}
+function handleBlockedDeploy(deployResp) {
+    const deployCanBeForced = deployResp.issues.every(issue => issue.blockingMessages.every(message => message.isWarning));
+    uiLogger.log('');
+    if (deployCanBeForced) {
+        uiLogger.warn(commands.project.deploy.errors.deployWarningsHeader);
+        uiLogger.log('');
+    }
+    else {
+        uiLogger.error(commands.project.deploy.errors.deployBlockedHeader);
+        uiLogger.log('');
+    }
+    deployResp.issues.forEach(issue => {
+        if (issue.blockingMessages.length > 0) {
+            issue.blockingMessages.forEach(message => {
+                uiLogger.log(commands.project.deploy.errors.deployIssueComponentWarning(issue.uid, issue.componentTypeName, message.message));
+            });
+        }
+        else {
+            uiLogger.log(commands.project.deploy.errors.deployIssueComponentGeneric(issue.uid, issue.componentTypeName));
+        }
+        uiLogger.log('');
+    });
+}
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force) {
+    const { data: deployResp } = await deployProject(targetAccountId, projectName, buildId, useV3Api, force);
+    if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
+        if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {
+            handleBlockedDeploy(deployResp);
+        }
+        else {
+            uiLogger.error(commands.project.deploy.errors.deploy);
+        }
+        return;
+    }
+    const deployResult = await pollDeployStatus(targetAccountId, projectName, Number(deployResp.id), buildId);
+    return deployResult;
+}

package/lib/projects/ensureProjectExists.js

@@ -1,38 +1,32 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureProjectExists = ensureProjectExists;
-const projects_1 = require("@hubspot/local-dev-lib/api/projects");
-const index_1 = require("@hubspot/local-dev-lib/errors/index");
-const constants_1 = require("../constants");
-const promptUtils_1 = require("../prompts/promptUtils");
-const exitCodes_1 = require("../enums/exitCodes");
-const ui_1 = require("../ui");
-const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
-const index_2 = require("../errorHandlers/index");
-const en_1 = require("../../lang/en");
-const logger_1 = require("../ui/logger");
+import { createProject, fetchProject, } from '@hubspot/local-dev-lib/api/projects';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { DEFAULT_POLLING_DELAY } from '../constants.js';
+import { promptUser } from '../prompts/promptUtils.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { uiAccountDescription } from '../ui/index.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
 async function pollFetchProject(accountId, projectName) {
     // Temporary solution for gating slowness. Retry on 403 statusCode
     return new Promise((resolve, reject) => {
         let pollCount = 0;
-        SpinniesManager_1.default.init();
-        SpinniesManager_1.default.add('pollFetchProject', {
-            text: en_1.lib.projects.pollFetchProject.checkingProject((0, ui_1.uiAccountDescription)(accountId)),
+        SpinniesManager.init();
+        SpinniesManager.add('pollFetchProject', {
+            text: lib.projects.pollFetchProject.checkingProject(uiAccountDescription(accountId)),
         });
         const pollInterval = setInterval(async () => {
             try {
-                const response = await (0, projects_1.fetchProject)(accountId, projectName);
+                const response = await fetchProject(accountId, projectName);
                 if (response && response.data) {
-                    SpinniesManager_1.default.remove('pollFetchProject');
+                    SpinniesManager.remove('pollFetchProject');
                     clearInterval(pollInterval);
                     resolve(response);
                 }
             }
             catch (err) {
-                if ((0, index_1.isSpecifiedError)(err, {
+                if (isSpecifiedError(err, {
                     statusCode: 403,
                     category: 'GATED',
                     subCategory: 'BuildPipelineErrorType.PORTAL_GATED',
@@ -41,30 +35,30 @@ async function pollFetchProject(accountId, projectName) {
                     pollCount += 1;
                 }
                 else {
-                    SpinniesManager_1.default.remove('pollFetchProject');
+                    SpinniesManager.remove('pollFetchProject');
                     clearInterval(pollInterval);
                     reject(err);
                 }
             }
-        }, constants_1.DEFAULT_POLLING_DELAY);
+        }, DEFAULT_POLLING_DELAY);
     });
 }
-async function ensureProjectExists(accountId, projectName, { forceCreate = false, allowCreate = true, noLogs = false, withPolling = false, uploadCommand = false, } = {}) {
-    const accountIdentifier = (0, ui_1.uiAccountDescription)(accountId);
+export async function ensureProjectExists(accountId, projectName, { forceCreate = false, allowCreate = true, noLogs = false, withPolling = false, uploadCommand = false, } = {}) {
+    const accountIdentifier = uiAccountDescription(accountId);
     try {
         const { data: project } = withPolling
             ? await pollFetchProject(accountId, projectName)
-            : await (0, projects_1.fetchProject)(accountId, projectName);
+            : await fetchProject(accountId, projectName);
         return { projectExists: !!project, project };
     }
     catch (err) {
-        if ((0, index_1.isSpecifiedError)(err, { statusCode: 404 })) {
+        if (isSpecifiedError(err, { statusCode: 404 })) {
             let shouldCreateProject = forceCreate;
             if (allowCreate && !shouldCreateProject) {
                 const promptLangFunction = uploadCommand
-                    ? en_1.lib.projects.ensureProjectExists.createPromptUpload
-                    : en_1.lib.projects.ensureProjectExists.createPrompt;
-                const promptResult = await (0, promptUtils_1.promptUser)([
+                    ? lib.projects.ensureProjectExists.createPromptUpload
+                    : lib.projects.ensureProjectExists.createPrompt;
+                const promptResult = await promptUser([
                     {
                         name: 'shouldCreateProject',
                         message: promptLangFunction(projectName, accountIdentifier),
@@ -75,23 +69,23 @@ async function ensureProjectExists(accountId, projectName, { forceCreate = false
             }
             if (shouldCreateProject) {
                 try {
-                    const { data: project } = await (0, projects_1.createProject)(accountId, projectName);
-                    logger_1.uiLogger.success(en_1.lib.projects.ensureProjectExists.createSuccess(projectName, accountIdentifier));
+                    const { data: project } = await createProject(accountId, projectName);
+                    uiLogger.success(lib.projects.ensureProjectExists.createSuccess(projectName, accountIdentifier));
                     return { projectExists: true, project };
                 }
                 catch (err) {
-                    (0, index_2.logError)(err, new index_2.ApiErrorContext({ accountId }));
+                    logError(err, new ApiErrorContext({ accountId }));
                     return { projectExists: false };
                 }
             }
             else {
                 if (!noLogs) {
-                    logger_1.uiLogger.log(en_1.lib.projects.ensureProjectExists.notFound(projectName, accountIdentifier));
+                    uiLogger.log(lib.projects.ensureProjectExists.notFound(projectName, accountIdentifier));
                 }
                 return { projectExists: false };
             }
         }
-        (0, index_2.logError)(err, new index_2.ApiErrorContext({ accountId }));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        logError(err, new ApiErrorContext({ accountId }));
+        process.exit(EXIT_CODES.ERROR);
     }
 }

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

@@ -1,7 +1,6 @@
-import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
-import { AppIRNode } from '../../../types/ProjectComponents';
-import LocalDevState from './LocalDevState';
-import LocalDevLogger from './LocalDevLogger';
+import { AppIRNode } from '../../../types/ProjectComponents.js';
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
 type AppDevModeInterfaceConstructorOptions = {
     localDevState: LocalDevState;
     localDevLogger: LocalDevLogger;
@@ -10,14 +9,23 @@ declare class AppDevModeInterface {
     localDevState: LocalDevState;
     localDevLogger: LocalDevLogger;
     _appNode?: AppIRNode | null;
-    appData?: PublicApp;
     marketplaceAppInstalls?: number;
     constructor(options: AppDevModeInterfaceConstructorOptions);
+    private getAppNodeFromProjectNodes;
     private get appNode();
+    private get appData();
+    private set appData(value);
+    private isStaticAuthApp;
+    private isOAuthApp;
     private getAppInstallUrl;
     private fetchAppData;
     private checkMarketplaceAppInstalls;
+    private installAppOrOpenInstallUrl;
     private checkTestAccountAppInstallation;
+    private onDevServerMessage;
+    private onChangeProjectNodes;
+    private setUpStateListeners;
+    private removeStateListeners;
     setup(args: any): Promise<void>;
     start(): Promise<void>;
     fileChange(filePath: string, event: string): Promise<void>;