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

package/lib/projects/localDev/DevServerManagerV2.js

@@ -1,56 +1,61 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("@hubspot/local-dev-lib/logger");
 const promptUtils_1 = require("../../prompts/promptUtils");
-const ui_extensions_dev_server_1 = require("@hubspot/ui-extensions-dev-server");
 const portManager_1 = require("@hubspot/local-dev-lib/portManager");
 const urls_1 = require("@hubspot/local-dev-lib/urls");
 const config_1 = require("@hubspot/local-dev-lib/config");
+const AppDevModeInterface_1 = __importDefault(require("./AppDevModeInterface"));
 const en_1 = require("../../../lang/en");
 class DevServerManagerV2 {
     initialized;
     started;
     devServers;
-    constructor() {
+    localDevState;
+    constructor(options) {
         this.initialized = false;
         this.started = false;
-        this.devServers = [ui_extensions_dev_server_1.DevModeUnifiedInterface];
+        this.localDevState = options.localDevState;
+        const AppsDevServer = new AppDevModeInterface_1.default({
+            localDevState: options.localDevState,
+            localDevLogger: options.logger,
+        });
+        this.devServers = [AppsDevServer];
     }
     async iterateDevServers(callback) {
         await Promise.all(this.devServers.map(devServer => callback(devServer)));
     }
-    async setup({ projectNodes, accountId, setActiveApp, }) {
+    async setup() {
         let env;
-        const accountConfig = (0, config_1.getAccountConfig)(accountId);
+        const accountConfig = (0, config_1.getAccountConfig)(this.localDevState.targetTestingAccountId);
         if (accountConfig) {
             env = accountConfig.env;
         }
         await (0, portManager_1.startPortManagerServer)();
         await this.iterateDevServers(async (serverInterface) => {
             if (serverInterface.setup) {
+                // @TODO: In the future, update UIE Dev Server to use LocalDevState
                 await serverInterface.setup({
-                    components: projectNodes,
+                    components: this.localDevState.projectNodes,
                     promptUser: promptUtils_1.promptUser,
                     logger: logger_1.logger,
                     urls: {
                         api: (0, urls_1.getHubSpotApiOrigin)(env),
                         web: (0, urls_1.getHubSpotWebsiteOrigin)(env),
                     },
-                    setActiveApp,
                 });
             }
         });
         this.initialized = true;
     }
-    async start({ accountId, projectConfig, }) {
+    async start() {
         if (this.initialized) {
             await this.iterateDevServers(async (serverInterface) => {
                 if (serverInterface.start) {
-                    await serverInterface.start({
-                        accountId,
-                        projectConfig,
-                        requestPorts: portManager_1.requestPorts,
-                    });
+                    await serverInterface.start();
                 }
             });
         }
@@ -79,5 +84,4 @@ class DevServerManagerV2 {
         }
     }
 }
-const Manager = new DevServerManagerV2();
-exports.default = Manager;
+exports.default = DevServerManagerV2;

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

@@ -0,0 +1,30 @@
+import LocalDevState from './LocalDevState';
+declare class LocalDevLogger {
+    private state;
+    private mostRecentUploadWarning;
+    private uploadWarnings;
+    constructor(state: LocalDevState);
+    private logUploadInstructions;
+    private handleError;
+    getUploadCommand(): string;
+    uploadWarning(): void;
+    addUploadWarning(warning: string): void;
+    clearUploadWarnings(): void;
+    missingComponentsWarning(components: string[]): void;
+    fileChangeError(e: unknown): void;
+    devServerSetupError(e: unknown): void;
+    devServerStartError(e: unknown): void;
+    devServerCleanupError(e: unknown): void;
+    noDeployedBuild(): void;
+    resetSpinnies(): void;
+    startupMessage(): void;
+    cleanupStart(): void;
+    cleanupError(): void;
+    cleanupSuccess(): void;
+    uploadInitiated(): void;
+    projectConfigMismatch(): void;
+    uploadError(error: unknown): void;
+    uploadSuccess(): void;
+    monitorConsoleOutput(): void;
+}
+export default LocalDevLogger;

package/lib/projects/localDev/LocalDevLogger.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 });
+const config_1 = require("@hubspot/local-dev-lib/config");
+const config_2 = require("@hubspot/local-dev-lib/config");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const logger_2 = require("../../ui/logger");
+const ui_1 = require("../../ui");
+const en_1 = require("../../../lang/en");
+const SpinniesManager_1 = __importDefault(require("../../ui/SpinniesManager"));
+const errorHandlers_1 = require("../../errorHandlers");
+class LocalDevLogger {
+    state;
+    mostRecentUploadWarning;
+    uploadWarnings;
+    constructor(state) {
+        this.state = state;
+        this.mostRecentUploadWarning = null;
+        this.uploadWarnings = new Set();
+    }
+    logUploadInstructions(warning) {
+        logger_2.uiLogger.log('');
+        logger_2.uiLogger.warn(warning);
+        logger_2.uiLogger.log('');
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.uploadWarning.instructionsHeader);
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.uploadWarning.stopDev);
+        if (this.state.isGithubLinked) {
+            logger_2.uiLogger.log(en_1.lib.LocalDevManager.uploadWarning.pushToGithub);
+        }
+        else {
+            logger_2.uiLogger.log(en_1.lib.LocalDevManager.uploadWarning.runUpload(this.getUploadCommand()));
+        }
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.uploadWarning.restartDev);
+    }
+    handleError(e, langFunction) {
+        if (this.state.debug) {
+            logger_1.logger.error(e);
+        }
+        logger_2.uiLogger.error(langFunction(e instanceof Error ? e.message : ''));
+    }
+    getUploadCommand() {
+        const currentDefaultAccount = (0, config_2.getConfigDefaultAccount)() || undefined;
+        return this.state.targetProjectAccountId !==
+            (0, config_1.getAccountId)(currentDefaultAccount)
+            ? (0, ui_1.uiCommandReference)(`hs project upload --account=${this.state.targetProjectAccountId}`)
+            : (0, ui_1.uiCommandReference)('hs project upload');
+    }
+    uploadWarning() {
+        // At the moment, there is only one additional warning. We may need to do this in a
+        // more robust way in the future
+        const additionalWarnings = Array.from(this.uploadWarnings).join('\n\n');
+        const warning = `${en_1.lib.LocalDevManager.uploadWarning.defaultWarning} ${additionalWarnings}`;
+        // Avoid logging the warning to the console if it is currently the most
+        // recently logged warning. We do not want to spam the console with the same message.
+        if (warning !== this.mostRecentUploadWarning) {
+            this.logUploadInstructions(warning);
+            this.mostRecentUploadWarning = warning;
+        }
+    }
+    addUploadWarning(warning) {
+        this.uploadWarnings.add(warning);
+    }
+    clearUploadWarnings() {
+        this.uploadWarnings.clear();
+    }
+    missingComponentsWarning(components) {
+        const warning = en_1.lib.LocalDevManager.uploadWarning.missingComponents(components.join(', '));
+        if (warning !== this.mostRecentUploadWarning) {
+            this.logUploadInstructions(warning);
+            this.mostRecentUploadWarning = warning;
+        }
+    }
+    fileChangeError(e) {
+        this.handleError(e, en_1.lib.LocalDevManager.devServer.fileChangeError);
+    }
+    devServerSetupError(e) {
+        this.handleError(e, en_1.lib.LocalDevManager.devServer.setupError);
+    }
+    devServerStartError(e) {
+        this.handleError(e, en_1.lib.LocalDevManager.devServer.startError);
+    }
+    devServerCleanupError(e) {
+        this.handleError(e, en_1.lib.LocalDevManager.devServer.cleanupError);
+    }
+    noDeployedBuild() {
+        logger_2.uiLogger.error(en_1.lib.LocalDevManager.noDeployedBuild(this.state.projectConfig.name, (0, ui_1.uiAccountDescription)(this.state.targetProjectAccountId), this.getUploadCommand()));
+        logger_2.uiLogger.log('');
+    }
+    resetSpinnies() {
+        SpinniesManager_1.default.stopAll();
+        SpinniesManager_1.default.init();
+    }
+    startupMessage() {
+        if (!this.state.debug) {
+            console.clear();
+        }
+        (0, ui_1.uiBetaTag)(en_1.lib.LocalDevManager.betaMessage);
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.learnMoreLocalDevServer);
+        logger_2.uiLogger.log('');
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.running(this.state.projectConfig.name, (0, ui_1.uiAccountDescription)(this.state.targetProjectAccountId)));
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.viewProjectLink(this.state.projectConfig.name, this.state.targetProjectAccountId));
+        logger_2.uiLogger.log('');
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.quitHelper);
+        (0, ui_1.uiLine)();
+        logger_2.uiLogger.log('');
+    }
+    cleanupStart() {
+        SpinniesManager_1.default.add('cleanupMessage', {
+            text: en_1.lib.LocalDevManager.exitingStart,
+        });
+    }
+    cleanupError() {
+        SpinniesManager_1.default.fail('cleanupMessage', {
+            text: en_1.lib.LocalDevManager.exitingFail,
+        });
+    }
+    cleanupSuccess() {
+        SpinniesManager_1.default.succeed('cleanupMessage', {
+            text: en_1.lib.LocalDevManager.exitingSucceed,
+        });
+    }
+    uploadInitiated() {
+        logger_2.uiLogger.log(en_1.lib.LocalDevProcess.uploadInitiated);
+    }
+    projectConfigMismatch() {
+        logger_2.uiLogger.log(en_1.lib.LocalDevProcess.projectConfigMismatch);
+    }
+    uploadError(error) {
+        logger_1.logger.log('');
+        (0, errorHandlers_1.logError)(error);
+        logger_2.uiLogger.log(en_1.lib.LocalDevProcess.uploadFailed);
+        logger_1.logger.log('');
+    }
+    uploadSuccess() {
+        logger_1.logger.log('');
+        logger_2.uiLogger.log(en_1.lib.LocalDevProcess.uploadSuccess);
+        (0, ui_1.uiLine)();
+        logger_1.logger.log('');
+    }
+    monitorConsoleOutput() {
+        const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+        function customStdoutWrite(chunk, encoding, callback) {
+            // Reset the most recently logged warning
+            if (this.mostRecentUploadWarning) {
+                this.mostRecentUploadWarning = null;
+            }
+            if (typeof encoding === 'function') {
+                return originalStdoutWrite(chunk, callback);
+            }
+            return originalStdoutWrite(chunk, encoding, callback);
+        }
+        customStdoutWrite.bind(this);
+        process.stdout.write = customStdoutWrite;
+    }
+}
+exports.default = LocalDevLogger;

package/lib/projects/localDev/LocalDevManager.js

@@ -14,17 +14,17 @@ const constants_1 = require("../../constants");
 const SpinniesManager_1 = __importDefault(require("../../ui/SpinniesManager"));
 const DevServerManager_1 = __importDefault(require("./DevServerManager"));
 const exitCodes_1 = require("../../enums/exitCodes");
-const urls_1 = require("../../projects/urls");
 const helpers_1 = require("./helpers");
 const structure_1 = require("../../projects/structure");
 const Projects_1 = require("../../../types/Projects");
 const ui_1 = require("../../ui");
 const index_1 = require("../../errorHandlers/index");
-const installPublicAppPrompt_1 = require("../../prompts/installPublicAppPrompt");
+const installAppPrompt_1 = require("../../prompts/installAppPrompt");
 const promptUtils_1 = require("../../prompts/promptUtils");
 const process_1 = require("../../process");
 const en_1 = require("../../../lang/en");
 const logger_2 = require("../../ui/logger");
+const urls_1 = require("../../app/urls");
 const WATCH_EVENTS = {
     add: 'add',
     change: 'change',
@@ -113,7 +113,7 @@ class LocalDevManager {
             return;
         }
         (0, ui_1.uiLine)();
-        logger_2.uiLogger.warn(en_1.lib.LocalDevManager.activeInstallWarning.installCount(this.activePublicAppData.name, this.publicAppActiveInstalls, this.publicAppActiveInstalls === 1 ? 'account' : 'accounts'));
+        logger_2.uiLogger.warn(en_1.lib.LocalDevManager.activeInstallWarning.installCount(this.activePublicAppData.name, this.publicAppActiveInstalls));
         logger_2.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 });
@@ -141,7 +141,7 @@ class LocalDevManager {
         logger_2.uiLogger.log((0, ui_1.uiLink)(en_1.lib.LocalDevManager.learnMoreLocalDevServer, 'https://developers.hubspot.com/docs/platform/project-cli-commands#start-a-local-development-server'));
         logger_2.uiLogger.log('');
         logger_2.uiLogger.log(chalk_1.default.hex(ui_1.UI_COLORS.SORBET)(en_1.lib.LocalDevManager.running(this.projectConfig.name, (0, ui_1.uiAccountDescription)(this.targetAccountId))));
-        logger_2.uiLogger.log((0, ui_1.uiLink)(en_1.lib.LocalDevManager.viewProjectLink, (0, urls_1.getProjectDetailUrl)(this.projectConfig.name, this.targetProjectAccountId) || ''));
+        logger_2.uiLogger.log(en_1.lib.LocalDevManager.viewProjectLink(this.projectConfig.name, this.targetProjectAccountId));
         if (this.activeApp?.type === Projects_1.ComponentTypes.PublicApp) {
             logger_2.uiLogger.log((0, ui_1.uiLink)(en_1.lib.LocalDevManager.viewTestAccountLink, (0, helpers_1.getAccountHomeUrl)(this.targetAccountId)));
         }
@@ -188,7 +188,14 @@ class LocalDevManager {
         const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await (0, localDevAuth_1.fetchAppInstallationData)(this.targetAccountId, this.projectId, this.activeApp.config.uid, this.activeApp.config.auth.requiredScopes, this.activeApp.config.auth.optionalScopes);
         const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
         if (!isInstalledWithScopeGroups) {
-            await (0, installPublicAppPrompt_1.installPublicAppPrompt)(this.env, this.targetAccountId, this.activePublicAppData.clientId, this.activeApp.config.auth.requiredScopes, this.activeApp.config.auth.redirectUrls, isReinstall);
+            const installUrl = (0, urls_1.getOauthAppInstallUrl)({
+                targetAccountId: this.targetAccountId,
+                env: this.env,
+                clientId: this.activePublicAppData.clientId,
+                scopes: this.activeApp.config.auth.requiredScopes,
+                redirectUrls: this.activeApp.config.auth.redirectUrls,
+            });
+            await (0, installAppPrompt_1.installAppPrompt)(installUrl, isReinstall);
         }
     }
     updateKeypressListeners() {

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

@@ -0,0 +1,27 @@
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import LocalDevState from './LocalDevState';
+import LocalDevLogger from './LocalDevLogger';
+import { LocalDevStateConstructorOptions, LocalDevStateListener } from '../../../types/LocalDev';
+declare class LocalDevProcess {
+    private state;
+    private _logger;
+    private devServerManager;
+    constructor(options: LocalDevStateConstructorOptions);
+    get projectDir(): string;
+    get projectNodes(): {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    get logger(): LocalDevLogger;
+    private setupDevServers;
+    private startDevServers;
+    private cleanupDevServers;
+    private compareLocalProjectToDeployed;
+    private projectConfigValidForUpload;
+    handleFileChange(filePath: string, event: string): void;
+    start(): Promise<void>;
+    stop(showProgress?: boolean): Promise<void>;
+    updateProjectNodes(): Promise<void>;
+    uploadProject(): Promise<void>;
+    addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+}
+export default LocalDevProcess;

package/lib/projects/localDev/LocalDevProcess.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const path_1 = __importDefault(require("path"));
+const LocalDevState_1 = __importDefault(require("./LocalDevState"));
+const LocalDevLogger_1 = __importDefault(require("./LocalDevLogger"));
+const DevServerManagerV2_1 = __importDefault(require("./DevServerManagerV2"));
+const exitCodes_1 = require("../../enums/exitCodes");
+const transform_1 = require("@hubspot/project-parsing-lib/src/lib/transform");
+const config_1 = require("../config");
+const upload_1 = require("../upload");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+class LocalDevProcess {
+    state;
+    _logger;
+    devServerManager;
+    constructor(options) {
+        this.state = new LocalDevState_1.default(options);
+        this._logger = new LocalDevLogger_1.default(this.state);
+        this.devServerManager = new DevServerManagerV2_1.default({
+            localDevState: this.state,
+            logger: this._logger,
+        });
+    }
+    get projectDir() {
+        return this.state.projectDir;
+    }
+    get projectNodes() {
+        return this.state.projectNodes;
+    }
+    get logger() {
+        return this._logger;
+    }
+    async setupDevServers() {
+        try {
+            await this.devServerManager.setup();
+            return true;
+        }
+        catch (e) {
+            this.logger.devServerSetupError(e);
+            return false;
+        }
+    }
+    async startDevServers() {
+        try {
+            await this.devServerManager.start();
+        }
+        catch (e) {
+            this.logger.devServerStartError(e);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+    async cleanupDevServers() {
+        try {
+            await this.devServerManager.cleanup();
+            return true;
+        }
+        catch (e) {
+            this.logger.devServerCleanupError(e);
+            return false;
+        }
+    }
+    compareLocalProjectToDeployed() {
+        const deployedComponentNames = this.state.deployedBuild.subbuildStatuses.map(subbuildStatus => subbuildStatus.buildName);
+        const missingProjectNodes = [];
+        Object.values(this.projectNodes).forEach(node => {
+            if (!deployedComponentNames.includes(node.uid)) {
+                const userFriendlyName = (0, transform_1.mapToUserFriendlyName)(node.componentType);
+                const label = userFriendlyName ? `[${userFriendlyName}] ` : '';
+                missingProjectNodes.push(`${label}${node.uid}`);
+            }
+        });
+        if (missingProjectNodes.length) {
+            this.logger.missingComponentsWarning(missingProjectNodes);
+        }
+    }
+    async projectConfigValidForUpload() {
+        const { projectConfig } = await (0, config_1.getProjectConfig)();
+        if (!projectConfig) {
+            return false;
+        }
+        Object.keys(projectConfig).forEach(key => {
+            const field = key;
+            if (projectConfig[field] !== this.state.projectConfig[field]) {
+                return false;
+            }
+        });
+        return true;
+    }
+    handleFileChange(filePath, event) {
+        try {
+            this.devServerManager.fileChange({ filePath, event });
+        }
+        catch (e) {
+            this.logger.fileChangeError(e);
+        }
+    }
+    async start() {
+        this.logger.resetSpinnies();
+        // Local dev currently relies on the existence of a deployed build in the target account
+        if (!this.state.deployedBuild) {
+            this.logger.noDeployedBuild();
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        }
+        const setupSucceeded = await this.setupDevServers();
+        if (!setupSucceeded) {
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        this.logger.startupMessage();
+        await this.startDevServers();
+        this.logger.monitorConsoleOutput();
+        // Verify that there are no mismatches between components in the local project
+        // and components in the deployed build of the project.
+        this.compareLocalProjectToDeployed();
+    }
+    async stop(showProgress = true) {
+        if (showProgress) {
+            this.logger.cleanupStart();
+        }
+        const cleanupSucceeded = await this.cleanupDevServers();
+        if (!cleanupSucceeded) {
+            if (showProgress) {
+                this.logger.cleanupError();
+            }
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        if (showProgress) {
+            this.logger.cleanupSuccess();
+        }
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    async updateProjectNodes() {
+        const intermediateRepresentation = await (0, project_parsing_lib_1.translateForLocalDev)({
+            projectSourceDir: path_1.default.join(this.state.projectDir, this.state.projectConfig.srcDir),
+            platformVersion: this.state.projectConfig.platformVersion,
+            accountId: this.state.targetProjectAccountId,
+        });
+        this.state.projectNodes =
+            intermediateRepresentation.intermediateNodesIndexedByUid;
+    }
+    async uploadProject() {
+        this.logger.uploadInitiated();
+        const isUploadable = await this.projectConfigValidForUpload();
+        if (!isUploadable) {
+            this.logger.projectConfigMismatch();
+            return;
+        }
+        const { uploadError } = await (0, upload_1.handleProjectUpload)({
+            accountId: this.state.targetProjectAccountId,
+            projectConfig: this.state.projectConfig,
+            projectDir: this.state.projectDir,
+            callbackFunc: buildAndDeploy_1.pollProjectBuildAndDeploy,
+            sendIR: true,
+            skipValidation: true,
+        });
+        if (uploadError) {
+            this.logger.uploadError(uploadError);
+        }
+        else {
+            this.logger.uploadSuccess();
+            this.logger.clearUploadWarnings();
+        }
+    }
+    addStateListener(key, listener) {
+        this.state.addListener(key, listener);
+    }
+}
+exports.default = LocalDevProcess;

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

@@ -0,0 +1,37 @@
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { ProjectConfig } from '../../../types/Projects';
+import { LocalDevStateConstructorOptions, LocalDevStateListener } from '../../../types/LocalDev';
+declare class LocalDevState {
+    private _targetProjectAccountId;
+    private _targetTestingAccountId;
+    private _projectConfig;
+    private _projectDir;
+    private _projectId;
+    private _debug;
+    private _deployedBuild?;
+    private _isGithubLinked;
+    private _projectNodes;
+    private _env;
+    private _listeners;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevStateConstructorOptions);
+    private runListeners;
+    get targetProjectAccountId(): number;
+    get targetTestingAccountId(): number;
+    get projectConfig(): ProjectConfig;
+    get projectDir(): string;
+    get projectId(): number;
+    get debug(): boolean;
+    get deployedBuild(): Build | undefined;
+    get isGithubLinked(): boolean;
+    get projectNodes(): {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    set projectNodes(nodes: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    });
+    get env(): Environment;
+    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+}
+export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class LocalDevState {
+    _targetProjectAccountId;
+    _targetTestingAccountId;
+    _projectConfig;
+    _projectDir;
+    _projectId;
+    _debug;
+    _deployedBuild;
+    _isGithubLinked;
+    _projectNodes;
+    _env;
+    _listeners;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
+        this._targetProjectAccountId = targetProjectAccountId;
+        this._targetTestingAccountId = targetTestingAccountId;
+        this._projectConfig = projectConfig;
+        this._projectDir = projectDir;
+        this._projectId = projectId;
+        this._debug = debug || false;
+        this._deployedBuild = deployedBuild;
+        this._isGithubLinked = isGithubLinked;
+        this._projectNodes = initialProjectNodes;
+        this._env = env;
+        this._listeners = {};
+    }
+    runListeners(key) {
+        if (this._listeners[key] && this._listeners[key].length) {
+            this._listeners[key].forEach(listener => listener(this[key]));
+        }
+    }
+    get targetProjectAccountId() {
+        return this._targetProjectAccountId;
+    }
+    get targetTestingAccountId() {
+        return this._targetTestingAccountId;
+    }
+    get projectConfig() {
+        return {
+            ...this._projectConfig,
+        };
+    }
+    get projectDir() {
+        return this._projectDir;
+    }
+    get projectId() {
+        return this._projectId;
+    }
+    get debug() {
+        return this._debug;
+    }
+    get deployedBuild() {
+        return (this._deployedBuild && {
+            ...this._deployedBuild,
+        });
+    }
+    get isGithubLinked() {
+        return this._isGithubLinked;
+    }
+    get projectNodes() {
+        return { ...this._projectNodes };
+    }
+    set projectNodes(nodes) {
+        this._projectNodes = nodes;
+        this.runListeners('projectNodes');
+    }
+    get env() {
+        return this._env;
+    }
+    addListener(key, listener) {
+        if (!this._listeners[key]) {
+            this._listeners[key] = [];
+        }
+        this._listeners[key].push(listener);
+    }
+}
+exports.default = LocalDevState;

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

@@ -0,0 +1,10 @@
+import LocalDevProcess from './LocalDevProcess';
+declare class LocalDevWatcher {
+    private localDevProcess;
+    private watcher;
+    constructor(localDevProcess: LocalDevProcess);
+    private handleWatchEvent;
+    start(): void;
+    stop(): Promise<void>;
+}
+export default LocalDevWatcher;