@hubspot/cli 7.5.1-experimental.0 → 7.5.2-beta.1

package/lib/projects/config.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeProjectConfig = writeProjectConfig;
+exports.getIsInProject = getIsInProject;
+exports.getProjectConfig = getProjectConfig;
+exports.validateProjectConfig = validateProjectConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const path_2 = require("@hubspot/local-dev-lib/path");
+const constants_1 = require("../constants");
+const en_1 = require("../../lang/en");
+const exitCodes_1 = require("../enums/exitCodes");
+const logger_1 = require("../ui/logger");
+function writeProjectConfig(configPath, config) {
+    try {
+        fs_extra_1.default.ensureFileSync(configPath);
+        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        logger_1.uiLogger.debug(`Wrote project config at ${configPath}`);
+    }
+    catch (e) {
+        logger_1.uiLogger.debug(e);
+        return false;
+    }
+    return true;
+}
+function getIsInProject(dir) {
+    const configPath = getProjectConfigPath(dir);
+    return !!configPath;
+}
+function getProjectConfigPath(dir) {
+    const projectDir = dir ? (0, path_2.getAbsoluteFilePath)(dir) : (0, path_2.getCwd)();
+    const configPath = (0, findup_sync_1.default)(constants_1.PROJECT_CONFIG_FILE, {
+        cwd: projectDir,
+        nocase: true,
+    });
+    return configPath;
+}
+async function getProjectConfig(dir) {
+    const configPath = getProjectConfigPath(dir);
+    if (!configPath) {
+        return { projectConfig: null, projectDir: null };
+    }
+    try {
+        const config = fs_extra_1.default.readFileSync(configPath);
+        const projectConfig = JSON.parse(config.toString());
+        return {
+            projectDir: path_1.default.dirname(configPath),
+            projectConfig,
+        };
+    }
+    catch (e) {
+        logger_1.uiLogger.error(en_1.lib.projects.getProjectConfig.error);
+        return { projectConfig: null, projectDir: null };
+    }
+}
+function validateProjectConfig(projectConfig, projectDir) {
+    if (!projectConfig || !projectDir) {
+        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.configNotFound);
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    if (!projectConfig.name || !projectConfig.srcDir) {
+        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.configMissingFields);
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const resolvedPath = path_1.default.resolve(projectDir, projectConfig.srcDir);
+    if (!resolvedPath.startsWith(projectDir)) {
+        const projectConfigFile = path_1.default.relative('.', path_1.default.join(projectDir, constants_1.PROJECT_CONFIG_FILE));
+        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    if (!fs_extra_1.default.existsSync(resolvedPath)) {
+        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs';
+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;
+    createProjectPromptResponse: CreateProjectPromptResponse;
+}>;

package/lib/projects/create/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProjectCreationFlow = handleProjectCreationFlow;
+const createProjectPrompt_1 = require("../../prompts/createProjectPrompt");
+const constants_1 = require("../../constants");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const v3_1 = require("./v3");
+const legacy_1 = require("./legacy");
+const logger_1 = require("../../ui/logger");
+const en_1 = require("../../../lang/en");
+const exitCodes_1 = require("../../enums/exitCodes");
+async function handleProjectCreationFlow(args) {
+    const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
+    const repo = templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await (0, v3_1.v3ComponentFlow)(platformVersion, projectBase, providedAuth, providedDistribution);
+        const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, undefined, projectContents !== v3_1.EMPTY_PROJECT ? componentTemplateChoices : undefined);
+        return {
+            authType,
+            distribution,
+            repoConfig,
+            projectContents,
+            createProjectPromptResponse,
+        };
+    }
+    const projectTemplates = await (0, legacy_1.getProjectTemplateListFromRepo)(repo, 'main');
+    if (!projectTemplates.length) {
+        logger_1.uiLogger.error(en_1.commands.project.create.errors.failedToFetchProjectList);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, projectTemplates);
+    return { createProjectPromptResponse };
+}

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';
+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.js → create/legacy.js}

@@ -1,25 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMPTY_PROJECT_TEMPLATE_NAME = void 0;
+exports.getConfigForPlatformVersion = getConfigForPlatformVersion;
 exports.getProjectComponentListFromRepo = getProjectComponentListFromRepo;
 exports.getProjectTemplateListFromRepo = getProjectTemplateListFromRepo;
-const logger_1 = require("@hubspot/local-dev-lib/logger");
 const github_1 = require("@hubspot/local-dev-lib/api/github");
-const constants_1 = require("../constants");
-const exitCodes_1 = require("../enums/exitCodes");
-const lang_1 = require("../lang");
-const index_1 = require("../errorHandlers/index");
-const i18nKey = 'lib.projects.create';
+const constants_1 = require("../../constants");
+const exitCodes_1 = require("../../enums/exitCodes");
+const errorHandlers_1 = require("../../errorHandlers");
+const logger_1 = require("../../ui/logger");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const en_1 = require("../../../lang/en");
+const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 exports.EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
-const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path', 'insertPath'];
-async function getProjectComponentListFromRepo(githubRef) {
+async function getConfigForPlatformVersion(platformVersion) {
+    let path = '';
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        path = `${platformVersion}/`;
+    }
+    const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, 'main');
+    return data;
+}
+async function getProjectComponentListFromRepo(platformVersion) {
     let config;
     try {
-        const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', githubRef);
-        config = data;
+        config = await getConfigForPlatformVersion(platformVersion);
     }
     catch (err) {
-        (0, index_1.debugError)(err);
+        (0, errorHandlers_1.debugError)(err);
     }
     if (config) {
         return config[constants_1.PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
@@ -33,18 +41,18 @@ async function getProjectTemplateListFromRepo(templateSource, githubRef) {
         config = data;
     }
     catch (e) {
-        (0, index_1.debugError)(e);
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.missingConfigFileTemplateSource`));
+        (0, errorHandlers_1.debugError)(e);
+        logger_1.uiLogger.error(en_1.lib.projects.create.errors.missingConfigFileTemplateSource);
         return process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     if (!config || !config[constants_1.PROJECT_COMPONENT_TYPES.PROJECTS]) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectsInConfig`));
+        logger_1.uiLogger.error(en_1.lib.projects.create.errors.noProjectsInConfig);
         return process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     const templates = config[constants_1.PROJECT_COMPONENT_TYPES.PROJECTS];
     const templatesContainAllProperties = templates.every(config => PROJECT_TEMPLATE_PROPERTIES.every(p => Object.prototype.hasOwnProperty.call(config, p)));
     if (!templatesContainAllProperties) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.missingPropertiesInConfig`));
+        logger_1.uiLogger.error(en_1.lib.projects.create.errors.missingPropertiesInConfig);
         return process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     return templates;

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

@@ -0,0 +1,27 @@
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+export declare const EMPTY_PROJECT = "empty";
+export declare const PROJECT_WITH_APP = "app";
+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, projectMetadata?: ProjectMetadata): ComponentTemplateChoice[];
+type V3ComponentInfo = {
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    componentTemplateChoices?: ComponentTemplateChoice[];
+};
+export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined): Promise<V3ComponentInfo>;
+export declare function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
+    createProjectPromptResponse: CreateProjectPromptResponse;
+    platformVersion: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    authType?: string;
+    distribution?: string;
+}): string[];
+export {};

package/lib/projects/create/v3.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJECT_WITH_APP = exports.EMPTY_PROJECT = void 0;
+exports.createV3App = createV3App;
+exports.calculateComponentTemplateChoices = calculateComponentTemplateChoices;
+exports.v3ComponentFlow = v3ComponentFlow;
+exports.generateComponentPaths = generateComponentPaths;
+const constants_1 = require("../../constants");
+const en_1 = require("../../../lang/en");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const chalk_1 = __importDefault(require("chalk"));
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const path_1 = __importDefault(require("path"));
+const legacy_1 = require("./legacy");
+const errorHandlers_1 = require("../../errorHandlers");
+const exitCodes_1 = require("../../enums/exitCodes");
+const inquirer = require('inquirer');
+exports.EMPTY_PROJECT = 'empty';
+exports.PROJECT_WITH_APP = 'app';
+async function createV3App(providedAuth, providedDistribution) {
+    let authType;
+    if (providedAuth &&
+        providedDistribution === constants_1.marketplaceDistribution &&
+        providedAuth !== constants_1.oAuth) {
+        throw new Error(en_1.lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
+    }
+    const distribution = providedDistribution ||
+        (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.distribution, {
+            choices: [
+                {
+                    name: en_1.lib.projects.create.prompt.marketPlaceDistribution,
+                    value: constants_1.marketplaceDistribution,
+                },
+                {
+                    name: en_1.lib.projects.create.prompt.privateDistribution,
+                    value: constants_1.privateDistribution,
+                },
+            ],
+        }));
+    if (distribution === constants_1.marketplaceDistribution) {
+        // This is the only valid auth type for marketplace
+        authType = constants_1.oAuth;
+    }
+    else {
+        authType =
+            providedAuth ||
+                (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.auth, {
+                    choices: [
+                        { name: en_1.lib.projects.create.prompt.staticAuth, value: constants_1.staticAuth },
+                        { name: en_1.lib.projects.create.prompt.oauth, value: constants_1.oAuth },
+                    ],
+                }));
+    }
+    return {
+        distribution,
+        authType,
+    };
+}
+function calculateComponentTemplateChoices(components, authType, distribution, projectMetadata) {
+    const enabledComponents = [];
+    const disabledComponents = [];
+    components.forEach(template => {
+        const { supportedAuthTypes, supportedDistributions } = template;
+        const disabledReasons = [];
+        if (projectMetadata) {
+            const { count, maxCount } = projectMetadata.components[template.type];
+            if (count >= maxCount) {
+                disabledReasons.push(en_1.commands.project.add.error.maxExceeded(maxCount));
+            }
+        }
+        if (Array.isArray(supportedAuthTypes) &&
+            authType &&
+            !supportedAuthTypes.includes(authType)) {
+            disabledReasons.push(en_1.commands.project.add.error.authTypeNotAllowed(authType));
+        }
+        if (Array.isArray(supportedDistributions) &&
+            distribution &&
+            !supportedDistributions.includes(distribution)) {
+            disabledReasons.push(en_1.commands.project.add.error.distributionNotAllowed(distribution));
+        }
+        if (disabledReasons.length > 0) {
+            disabledComponents.push({
+                name: `[${chalk_1.default.yellow('DISABLED')}] ${template.label}`,
+                value: template,
+                disabled: disabledReasons.join(' '),
+            });
+        }
+        else {
+            enabledComponents.push({
+                name: template.label,
+                value: template,
+            });
+        }
+    });
+    return disabledComponents.length
+        ? [...enabledComponents, new inquirer.Separator(), ...disabledComponents]
+        : [...enabledComponents];
+}
+async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution) {
+    let repoConfig = undefined;
+    let authType;
+    let distribution;
+    try {
+        repoConfig = await (0, legacy_1.getConfigForPlatformVersion)(platformVersion);
+    }
+    catch (error) {
+        (0, errorHandlers_1.logError)(error);
+        return process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    const projectContentsChoice = projectBase ||
+        (await (0, promptUtils_1.listPrompt)(en_1.commands.project.create.prompts.parentComponents, {
+            choices: [
+                {
+                    name: en_1.commands.project.create.prompts.emptyProject,
+                    value: exports.EMPTY_PROJECT,
+                },
+                { name: en_1.commands.project.create.prompts.app, value: exports.PROJECT_WITH_APP },
+            ],
+        }));
+    if (projectContentsChoice === exports.PROJECT_WITH_APP) {
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
+        authType = selectedAuthType;
+        distribution = selectedDistribution;
+    }
+    const componentTemplateChoices = calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution);
+    return {
+        componentTemplateChoices,
+        authType,
+        distribution,
+        projectContents: projectContentsChoice,
+        repoConfig,
+    };
+}
+function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
+    if (!(0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        return [];
+    }
+    const components = createProjectPromptResponse.componentTemplates?.map((componentTemplate) => {
+        return path_1.default.join(platformVersion, componentTemplate.path);
+    }) || [];
+    if (projectContents && projectContents !== exports.EMPTY_PROJECT) {
+        const parentComponent = repoConfig?.parentComponents?.find(possibleParent => {
+            return (possibleParent.type === projectContents &&
+                possibleParent.authType === authType &&
+                possibleParent.distribution === distribution);
+        });
+        if (parentComponent) {
+            components.push(path_1.default.join(platformVersion, parentComponent.path));
+        }
+    }
+    if (repoConfig?.defaultFiles) {
+        components.push(path_1.default.join(platformVersion, repoConfig?.defaultFiles));
+    }
+    return components;
+}

package/lib/projects/ensureProjectExists.d.ts

@@ -0,0 +1,11 @@
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+export declare function ensureProjectExists(accountId: number, projectName: string, { forceCreate, allowCreate, noLogs, withPolling, uploadCommand, }?: {
+    forceCreate?: boolean | undefined;
+    allowCreate?: boolean | undefined;
+    noLogs?: boolean | undefined;
+    withPolling?: boolean | undefined;
+    uploadCommand?: boolean | undefined;
+}): Promise<{
+    projectExists: boolean;
+    project?: Project;
+}>;

package/lib/projects/ensureProjectExists.js

@@ -0,0 +1,97 @@
+"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");
+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)),
+        });
+        const pollInterval = setInterval(async () => {
+            try {
+                const response = await (0, projects_1.fetchProject)(accountId, projectName);
+                if (response && response.data) {
+                    SpinniesManager_1.default.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    resolve(response);
+                }
+            }
+            catch (err) {
+                if ((0, index_1.isSpecifiedError)(err, {
+                    statusCode: 403,
+                    category: 'GATED',
+                    subCategory: 'BuildPipelineErrorType.PORTAL_GATED',
+                }) &&
+                    pollCount < 15) {
+                    pollCount += 1;
+                }
+                else {
+                    SpinniesManager_1.default.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    reject(err);
+                }
+            }
+        }, constants_1.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);
+    try {
+        const { data: project } = withPolling
+            ? await pollFetchProject(accountId, projectName)
+            : await (0, projects_1.fetchProject)(accountId, projectName);
+        return { projectExists: !!project, project };
+    }
+    catch (err) {
+        if ((0, index_1.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)([
+                    {
+                        name: 'shouldCreateProject',
+                        message: promptLangFunction(projectName, accountIdentifier),
+                        type: 'confirm',
+                    },
+                ]);
+                shouldCreateProject = promptResult.shouldCreateProject;
+            }
+            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));
+                    return { projectExists: true, project };
+                }
+                catch (err) {
+                    (0, index_2.logError)(err, new index_2.ApiErrorContext({ accountId }));
+                    return { projectExists: false };
+                }
+            }
+            else {
+                if (!noLogs) {
+                    logger_1.uiLogger.log(en_1.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);
+    }
+}

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

@@ -0,0 +1,27 @@
+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;
+    marketplaceAppInstalls?: number;
+    constructor(options: AppDevModeInterfaceConstructorOptions);
+    private get appNode();
+    private get appData();
+    private set appData(value);
+    private getAppInstallUrl;
+    private fetchAppData;
+    private checkMarketplaceAppInstalls;
+    private checkTestAccountAppInstallation;
+    private setUpLocalDevServerMessageListeners;
+    setup(args: any): Promise<void>;
+    start(): Promise<void>;
+    fileChange(filePath: string, event: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export default AppDevModeInterface;