@hubspot/cli 7.4.8 → 7.4.9-beta.1

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;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -0,0 +1,56 @@
+"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,
+            ignored: ['**/dist'],
+        });
+        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,17 @@
+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 sendMessage;
+    private setupMessageHandlers;
+    private setupStateListeners;
+    start(): Promise<void>;
+    shutdown(): void;
+}
+export default LocalDevWebsocketServer;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -0,0 +1,92 @@
+"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);
+        }
+    }
+    sendMessage(message) {
+        this.websocket().send(JSON.stringify(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()));
+            }
+        });
+    }
+    setupStateListeners() {
+        this.localDevProcess.addStateListener('projectNodes', nodes => {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.UPDATE_PROJECT_NODES,
+                data: nodes,
+            });
+        });
+    }
+    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();
+            this.setupStateListeners();
+        });
+    }
+    shutdown() {
+        this.server?.close();
+        this.server = undefined;
+        this._websocket = undefined;
+    }
+}
+exports.default = LocalDevWebsocketServer;

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

@@ -14,6 +14,6 @@ export declare function createSandboxForLocalDev(accountId: number, accountConfi
 export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
 export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
-export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean): Promise<Build>;
+export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
 export declare function getAccountHomeUrl(accountId: number): string;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;

package/lib/projects/localDev/helpers.js

@@ -253,7 +253,7 @@ function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
 }
 // Create an initial build if the project was newly created in the account
 // Return the newly deployed build
-async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR) {
+async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
     const { result: initialUploadResult, uploadError } = await (0, upload_1.handleProjectUpload)({
         accountId: targetAccountId,
         projectConfig,
@@ -264,6 +264,7 @@ async function createInitialBuildForNewProject(projectConfig, projectDir, target
         forceCreate: true,
         skipValidation: true,
         sendIR,
+        profile,
     });
     if (uploadError) {
         if ((0, index_1.isSpecifiedError)(uploadError, {

package/lib/projects/upload.d.ts

@@ -15,6 +15,7 @@ type HandleProjectUploadArg<T> = {
     isUploadCommand?: boolean;
     sendIR?: boolean;
     skipValidation?: boolean;
+    profile?: string;
 };
-export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
+export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
 export {};

package/lib/projects/upload.js

@@ -46,7 +46,7 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
     }
     return { buildId, error };
 }
-async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, }) {
+async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, }) {
     const srcDir = path_1.default.resolve(projectDir, projectConfig.srcDir);
     const filenames = fs_extra_1.default.readdirSync(srcDir);
     if (!filenames || filenames.length === 0) {
@@ -66,7 +66,7 @@ async function handleProjectUpload({ accountId, projectConfig, projectDir, callb
                     projectSourceDir: path_1.default.join(projectDir, projectConfig.srcDir),
                     platformVersion: projectConfig.platformVersion,
                     accountId,
-                }, { skipValidation });
+                }, { skipValidation, profile });
                 logger_1.uiLogger.debug(node_util_1.default.inspect(intermediateRepresentation, false, null, true));
             }
             catch (e) {

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/testUtils.d.ts

@@ -1,4 +1,4 @@
-import { AxiosResponse } from 'axios';
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
 import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
 type MockErrorResponse = {
     status: number;
@@ -9,6 +9,6 @@ type MockErrorResponse = {
         subCategory?: string;
     };
 };
-export declare const mockHubSpotHttpResponse: (data: any) => AxiosResponse;
-export declare const mockHubSpotHttpError: (message: string, response: MockErrorResponse) => HubSpotHttpError;
+export declare function mockHubSpotHttpResponse<T>(data?: any): HubSpotPromise<T>;
+export declare function mockHubSpotHttpError(message: string, response: MockErrorResponse): HubSpotHttpError;
 export {};

package/lib/testUtils.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockHubSpotHttpError = exports.mockHubSpotHttpResponse = void 0;
+exports.mockHubSpotHttpResponse = mockHubSpotHttpResponse;
+exports.mockHubSpotHttpError = mockHubSpotHttpError;
 const axios_1 = require("axios");
 const HubSpotHttpError_1 = require("@hubspot/local-dev-lib/models/HubSpotHttpError");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const mockHubSpotHttpResponse = (data) => {
-    return {
+function mockHubSpotHttpResponse(data) {
+    return Promise.resolve({
         data,
         status: 200,
         statusText: 'OK',
@@ -13,12 +14,10 @@ const mockHubSpotHttpResponse = (data) => {
         config: {
             headers: new axios_1.AxiosHeaders(),
         },
-    };
-};
-exports.mockHubSpotHttpResponse = mockHubSpotHttpResponse;
-const mockHubSpotHttpError = (message, response) => {
+    });
+}
+function mockHubSpotHttpError(message, response) {
     return new HubSpotHttpError_1.HubSpotHttpError(message, {
         cause: { isAxiosError: true, response },
     });
-};
-exports.mockHubSpotHttpError = mockHubSpotHttpError;
+}

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/validation.js

@@ -145,28 +145,27 @@ function validateCmsPublishMode(options) {
     return false;
 }
 function fileExists(_path) {
-    let isFile;
     try {
         const absoluteSrcPath = path.resolve((0, path_1.getCwd)(), _path);
         if (!absoluteSrcPath)
             return false;
         const stats = fs.statSync(absoluteSrcPath);
-        isFile = stats.isFile();
+        const isFile = stats.isFile();
         if (!isFile) {
-            logger_1.logger.error(`The path "${_path}" is not a path to a file`);
             return false;
         }
     }
     catch (e) {
-        logger_1.logger.error(`The path "${_path}" is not a path to a file`);
         return false;
     }
     return true;
 }
 function checkAndConvertToJson(_path) {
     const filePath = (0, path_1.getAbsoluteFilePath)(_path);
-    if (!fileExists(filePath))
+    if (!fileExists(filePath)) {
+        logger_1.logger.error(`The path "${_path}" is not a path to a file`);
         return null;
+    }
     if ((0, path_1.getExt)(_path) !== 'json') {
         logger_1.logger.error(`The file "${_path}" must be a valid JSON file`);
         return null;

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.1",
     "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.6.0",
+        "@hubspot/project-parsing-lib": "0.2.0",
         "@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,24 @@
+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';
+import LocalDevState from '../lib/projects/localDev/LocalDevState';
+export type LocalDevStateConstructorOptions = {
+    targetProjectAccountId: number;
+    targetTestingAccountId: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    projectId: number;
+    debug?: boolean;
+    deployedBuild?: Build;
+    isGithubLinked: boolean;
+    initialProjectNodes: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    env: Environment;
+};
+export type LocalDevWebsocketMessage = {
+    type: string;
+    data: unknown;
+};
+export type LocalDevStateListener<K extends keyof LocalDevState> = (value: LocalDevState[K]) => void;

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;
@@ -23,10 +24,16 @@ export type OverwriteArgs = Options & {
 export type StringArgType = Options & {
     type: 'string';
 };
-export type ProjectDevArgs = CommonArgs & ConfigArgs & EnvironmentArgs;
+export type ProjectDevArgs = CommonArgs & ConfigArgs & EnvironmentArgs & {
+    profile?: string;
+};
 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>>;
 }