@hubspot/cli 7.4.8 → 7.4.9-beta.0

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

@@ -0,0 +1,41 @@
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { ProjectConfig } from '../../../types/Projects';
+import LocalDevLogger from './LocalDevLogger';
+type LocalDevProcessConstructorOptions = {
+    targetProjectAccountId: number;
+    targetTestingAccountId: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    projectId: number;
+    debug?: boolean;
+    deployedBuild?: Build;
+    isGithubLinked: boolean;
+    initialProjectNodes: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    env: Environment;
+};
+declare class LocalDevProcess {
+    private state;
+    private _logger;
+    private devServerManager;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevProcessConstructorOptions);
+    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>;
+}
+export default LocalDevProcess;

package/lib/projects/localDev/LocalDevProcess.js

@@ -0,0 +1,178 @@
+"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 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({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
+        this.state = {
+            targetProjectAccountId,
+            targetTestingAccountId,
+            projectConfig,
+            projectDir,
+            projectId,
+            debug: debug || false,
+            deployedBuild,
+            isGithubLinked,
+            projectNodes: initialProjectNodes,
+            env,
+        };
+        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();
+        }
+    }
+}
+exports.default = LocalDevProcess;

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;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const constants_1 = require("../../constants");
+const WATCH_EVENTS = {
+    add: 'add',
+    change: 'change',
+    unlink: 'unlink',
+    unlinkDir: 'unlinkDir',
+};
+class LocalDevWatcher {
+    localDevProcess;
+    watcher;
+    constructor(localDevProcess) {
+        this.localDevProcess = localDevProcess;
+        this.watcher = null;
+    }
+    async handleWatchEvent(filePath, event, configPaths) {
+        await this.localDevProcess.updateProjectNodes();
+        if (configPaths.includes(filePath)) {
+            this.localDevProcess.logger.uploadWarning();
+        }
+        else {
+            this.localDevProcess.handleFileChange(filePath, event);
+        }
+    }
+    start() {
+        this.watcher = chokidar_1.default.watch(this.localDevProcess.projectDir, {
+            ignoreInitial: true,
+        });
+        const configPaths = Object.values(this.localDevProcess.projectNodes).map(component => component.localDev.componentConfigPath);
+        const projectConfigPath = path_1.default.join(this.localDevProcess.projectDir, constants_1.PROJECT_CONFIG_FILE);
+        configPaths.push(projectConfigPath);
+        this.watcher.on('add', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.add, configPaths);
+        });
+        this.watcher.on('change', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.change, configPaths);
+        });
+        this.watcher.on('unlink', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.unlink, configPaths);
+        });
+        this.watcher.on('unlinkDir', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.unlinkDir, configPaths);
+        });
+    }
+    async stop() {
+        await this.watcher?.close();
+    }
+}
+exports.default = LocalDevWatcher;

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

@@ -0,0 +1,15 @@
+import LocalDevProcess from './LocalDevProcess';
+declare class LocalDevWebsocketServer {
+    private server?;
+    private _websocket?;
+    private debug?;
+    private localDevProcess;
+    constructor(localDevProcess: LocalDevProcess, debug?: boolean);
+    private websocket;
+    private log;
+    private logError;
+    private setupMessageHandlers;
+    start(): Promise<void>;
+    shutdown(): void;
+}
+export default LocalDevWebsocketServer;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = require("ws");
+const portManager_1 = require("@hubspot/local-dev-lib/portManager");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const constants_1 = require("../../constants");
+const en_1 = require("../../../lang/en");
+const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
+const LOG_PREFIX = '[LocalDevWebsocketServer]';
+class LocalDevWebsocketServer {
+    server;
+    _websocket;
+    debug;
+    localDevProcess;
+    constructor(localDevProcess, debug) {
+        this.localDevProcess = localDevProcess;
+        this.debug = debug;
+    }
+    websocket() {
+        if (!this._websocket) {
+            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.notInitialized(LOG_PREFIX));
+        }
+        return this._websocket;
+    }
+    log(message) {
+        if (this.debug) {
+            logger_1.logger.log(LOG_PREFIX, message);
+        }
+    }
+    logError(message) {
+        if (this.debug) {
+            logger_1.logger.error(LOG_PREFIX, message);
+        }
+    }
+    setupMessageHandlers() {
+        this.websocket().on('message', data => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (!message.type) {
+                    this.logError(en_1.lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
+                    return;
+                }
+                switch (message.type) {
+                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.UPLOAD:
+                        this.localDevProcess.uploadProject();
+                        break;
+                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.INSTALL_DEPS:
+                        break;
+                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.APP_INSTALLED:
+                        break;
+                    default:
+                        this.logError(en_1.lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
+                }
+            }
+            catch (e) {
+                this.logError(en_1.lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
+            }
+        });
+    }
+    async start() {
+        const portManagerIsRunning = await (0, portManager_1.isPortManagerServerRunning)();
+        if (!portManagerIsRunning) {
+            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
+        }
+        const portData = await (0, portManager_1.requestPorts)([{ instanceId: SERVER_INSTANCE_ID }]);
+        const port = portData[SERVER_INSTANCE_ID];
+        this.server = new ws_1.WebSocketServer({ port });
+        this.log(en_1.lib.LocalDevWebsocketServer.logs.startup(port));
+        this.server.on('connection', ws => {
+            this._websocket = ws;
+            this.setupMessageHandlers();
+        });
+    }
+    shutdown() {
+        this.server?.close();
+        this.server = undefined;
+        this._websocket = undefined;
+    }
+}
+exports.default = LocalDevWebsocketServer;

package/lib/prompts/createApiSamplePrompt.d.ts

@@ -1,12 +1,4 @@
-type SampleChoice = {
-    name: string;
-    description: string;
-    id: string;
-    languages: string[];
-};
-type SampleConfig = {
-    samples: SampleChoice[];
-};
+import { ApiSampleConfig } from '../../types/Cms';
 type SampleTypePromptResponse = {
     sampleType?: string;
 };
@@ -14,5 +6,5 @@ type LanguagePromptResponse = {
     sampleLanguage?: string;
 };
 type CreateApiSamplePromptResponse = SampleTypePromptResponse & LanguagePromptResponse;
-export declare function createApiSamplePrompt(samplesConfig: SampleConfig): Promise<CreateApiSamplePromptResponse>;
+export declare function createApiSamplePrompt(samplesConfig: ApiSampleConfig): Promise<CreateApiSamplePromptResponse>;
 export {};

package/lib/prompts/createTemplatePrompt.d.ts

@@ -1,7 +1,25 @@
-declare const templateTypeChoices: {
-    name: string;
-    value: string;
-}[];
+declare const templateTypeChoices: [{
+    readonly name: "page";
+    readonly value: "page-template";
+}, {
+    readonly name: "email";
+    readonly value: "email-template";
+}, {
+    readonly name: "partial";
+    readonly value: "partial";
+}, {
+    readonly name: "global partial";
+    readonly value: "global-partial";
+}, {
+    readonly name: "blog listing";
+    readonly value: "blog-listing-template";
+}, {
+    readonly name: "blog post";
+    readonly value: "blog-post-template";
+}, {
+    readonly name: "search results";
+    readonly value: "search-template";
+}];
 interface CreateTemplatePromptResponse {
     templateType: (typeof templateTypeChoices)[number]['value'];
 }

package/lib/upload.d.ts

@@ -1 +1 @@
-export declare function getUploadableFileList(src: string, convertFields: boolean): Promise<string[]>;
+export declare function getUploadableFileList(src: string, convertFields?: boolean): Promise<string[]>;

package/lib/yargsUtils.d.ts

@@ -6,4 +6,8 @@ export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>,
     useConfigOptions?: boolean;
     useEnvironmentOptions?: boolean;
     useTestingOptions?: boolean;
+    useCmsPublishModeOptions?: boolean | {
+        read?: boolean;
+        write?: boolean;
+    };
 }): (yargs: Argv) => Promise<Argv<T>>;

package/lib/yargsUtils.js

@@ -32,6 +32,12 @@ function makeYargsBuilder(callback, command, describe, options = {}) {
         if (options.useTestingOptions) {
             (0, commonOpts_1.addTestingOptions)(yargs);
         }
+        if (options.useCmsPublishModeOptions) {
+            const opts = typeof options.useCmsPublishModeOptions === 'object'
+                ? options.useCmsPublishModeOptions
+                : { write: true };
+            (0, commonOpts_1.addCmsPublishModeOptions)(yargs, opts);
+        }
         const result = callback(yargs);
         // Must go last to pick up available options
         await (0, commonOpts_1.addCustomHelpOutput)(result, command, describe);

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.4.8",
+    "version": "7.4.9-beta.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "dependencies": {
-        "@hubspot/local-dev-lib": "3.5.5",
-        "@hubspot/project-parsing-lib": "0.1.7",
+        "@hubspot/local-dev-lib": "3.5.6",
+        "@hubspot/project-parsing-lib": "0.1.11",
         "@hubspot/serverless-dev-runtime": "7.0.2",
         "@hubspot/theme-preview-dev-server": "0.0.10",
         "@hubspot/ui-extensions-dev-server": "0.8.52",
@@ -28,6 +28,7 @@
         "table": "6.9.0",
         "tmp": "0.2.3",
         "update-notifier": "5.1.0",
+        "ws": "^8.18.2",
         "yargs": "17.7.2",
         "yargs-parser": "21.1.1"
     },
@@ -41,6 +42,7 @@
         "@types/js-yaml": "^4.0.9",
         "@types/semver": "^7.5.8",
         "@types/tmp": "^0.2.6",
+        "@types/ws": "^8.18.1",
         "@types/yargs": "^17.0.33",
         "@typescript-eslint/eslint-plugin": "^8.30.1",
         "@typescript-eslint/parser": "^8.11.0",

package/types/Cms.d.ts

@@ -0,0 +1,30 @@
+import { CommonArgs, ConfigArgs } from './Yargs';
+export type CreateArgs = CommonArgs & ConfigArgs & {
+    branch?: string;
+    type: string;
+    dest: string;
+    name: string;
+    internal?: boolean;
+};
+export type CmsAssetOperationArgs = {
+    assetType: string;
+    name: string;
+    dest: string;
+    getInternalVersion: boolean;
+    commandArgs: CreateArgs;
+};
+export type CreatableCmsAsset = {
+    hidden: boolean;
+    dest: (args: CmsAssetOperationArgs) => string;
+    validate?: (args: CmsAssetOperationArgs) => boolean;
+    execute: (args: CmsAssetOperationArgs) => Promise<void>;
+};
+export type ApiSampleChoice = {
+    name: string;
+    description: string;
+    id: string;
+    languages: string[];
+};
+export type ApiSampleConfig = {
+    samples: ApiSampleChoice[];
+};

package/types/Cms.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/LocalDev.d.ts

@@ -0,0 +1,22 @@
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { ProjectConfig } from './Projects';
+export type LocalDevState = {
+    targetProjectAccountId: number;
+    targetTestingAccountId: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    projectId: number;
+    debug: boolean;
+    deployedBuild?: Build;
+    isGithubLinked: boolean;
+    projectNodes: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    env: Environment;
+};
+export type LocalDevWebsocketMessage = {
+    type: string;
+    data: unknown;
+};

package/types/LocalDev.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Yargs.d.ts

@@ -1,4 +1,5 @@
 import { Options, CommandModule, Argv } from 'yargs';
+import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
 export type CommonArgs = {
     derivedAccountId: number;
     providedAccountId?: number;
@@ -27,6 +28,10 @@ export type ProjectDevArgs = CommonArgs & ConfigArgs & EnvironmentArgs;
 export type TestingArgs = {
     qa?: boolean;
 };
+export type CmsPublishModeArgs = {
+    'cms-publish-mode'?: CmsPublishMode;
+    m?: CmsPublishMode;
+};
 export interface YargsCommandModule<T, U> extends CommandModule<T, U> {
     builder: (yargs: Argv) => Promise<Argv<U>>;
 }

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

@@ -1,64 +0,0 @@
-import { FSWatcher } from 'chokidar';
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
-import { Environment } from '@hubspot/local-dev-lib/types/Config';
-import { ProjectConfig } from '../../../types/Projects';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
-import { AppIRNode } from '../../../types/ProjectComponents';
-type LocalDevManagerConstructorOptions = {
-    targetProjectAccountId: number;
-    targetTestingAccountId: number;
-    projectConfig: ProjectConfig;
-    projectDir: string;
-    projectId: number;
-    debug?: boolean;
-    deployedBuild?: Build;
-    isGithubLinked: boolean;
-    projectNodes: {
-        [key: string]: IntermediateRepresentationNodeLocalDev;
-    };
-    env: Environment;
-};
-declare class LocalDevManagerV2 {
-    targetProjectAccountId: number;
-    targetTestingAccountId: number;
-    projectConfig: ProjectConfig;
-    projectDir: string;
-    projectId: number;
-    debug: boolean;
-    deployedBuild?: Build;
-    isGithubLinked: boolean;
-    watcher: FSWatcher | null;
-    uploadWarnings: {
-        [key: string]: boolean;
-    };
-    projectNodes: {
-        [key: string]: IntermediateRepresentationNodeLocalDev;
-    };
-    activeApp: AppIRNode | null;
-    activePublicAppData: PublicApp | null;
-    env: Environment;
-    publicAppActiveInstalls: number | null;
-    projectSourceDir: string;
-    mostRecentUploadWarning: string | null;
-    constructor(options: LocalDevManagerConstructorOptions);
-    setActiveApp(appUid?: string): Promise<void>;
-    setActivePublicAppData(): Promise<void>;
-    checkActivePublicAppInstalls(): Promise<void>;
-    start(): Promise<void>;
-    stop(showProgress?: boolean): Promise<void>;
-    checkPublicAppInstallation(): Promise<void>;
-    updateKeypressListeners(): void;
-    getUploadCommand(): string;
-    logUploadWarning(reason?: string): void;
-    monitorConsoleOutput(): void;
-    compareLocalProjectToDeployed(): void;
-    startWatching(): void;
-    stopWatching(): Promise<void>;
-    handleWatchEvent(filePath: string, event: string, configPaths: string[]): void;
-    devServerSetup(): Promise<boolean>;
-    devServerStart(): Promise<void>;
-    devServerFileChange(filePath: string, event: string): void;
-    devServerCleanup(): Promise<boolean>;
-}
-export default LocalDevManagerV2;