@hubspot/ui-extensions-dev-server 0.7.3 → 0.8.1

package/dist/lib/dev.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevMode = void 0;
+const vite_1 = require("vite");
+const path_1 = __importDefault(require("path"));
+const server_1 = __importDefault(require("./server"));
+const devBuildPlugin_1 = __importDefault(require("./plugins/devBuildPlugin"));
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+// @ts-expect-error no type defs
+const logger_1 = require("@hubspot/cli-lib/logger");
+// @ts-expect-error no type defs
+const detect_port_1 = __importDefault(require("detect-port"));
+function _createViteDevServer({ outputDir, extensionConfig, webSocketPort, baseMessage, root, cardConfigs, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, vite_1.createServer)({
+            root,
+            logLevel: 'silent',
+            appType: 'custom',
+            mode: 'development',
+            server: {
+                middlewareMode: true,
+                hmr: {
+                    port: webSocketPort,
+                },
+                watch: {
+                    ignored: [
+                        path_1.default.join(outputDir, '/**/*'),
+                        '**/src/app/app.functions/**/*',
+                        '**/app.json',
+                        '**/package.json',
+                        '**/package-lock.json',
+                    ],
+                },
+            },
+            build: {
+                rollupOptions: {
+                    input: extensionConfig.data.module.file,
+                    output: { file: (0, utils_1.getUrlSafeFileName)(extensionConfig.data.module.file) },
+                },
+            },
+            plugins: [
+                (0, devBuildPlugin_1.default)({
+                    extensionConfig,
+                    outputDir,
+                    baseMessage,
+                    cardConfigs,
+                }),
+            ],
+            clearScreen: false,
+        });
+    });
+}
+function throwIfPortTaken(port) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // detect takes a port and returns the next available port
+        // so a mismatch means the requested port was not available
+        if ((yield (0, detect_port_1.default)(port)) !== port) {
+            throw new Error(`Unable to start because port ${port} is already in use`);
+        }
+    });
+}
+function startDevMode({ extensionConfig, functionsConfig, outputDir = constants_1.OUTPUT_DIR, expressPort = constants_1.VITE_DEFAULT_PORT, webSocketPort = constants_1.WEBSOCKET_PORT, root = process.cwd(), cardConfigs, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!extensionConfig) {
+            throw new Error('Unable to determine which extension to run');
+        }
+        yield throwIfPortTaken(expressPort);
+        const actualWebSocketPort = yield (0, detect_port_1.default)(webSocketPort);
+        if (actualWebSocketPort !== webSocketPort) {
+            logger_1.logger.debug(`WebSocket port ${webSocketPort} is in use; using next available port ${actualWebSocketPort}`);
+        }
+        const { appName, title, sourceId } = extensionConfig.data;
+        const baseMessage = Object.freeze({
+            appName,
+            title,
+            sourceId,
+            callback: `http://hslocal.net:${expressPort}/${extensionConfig.output}`,
+            portalId: functionsConfig.accountId,
+        });
+        const viteDevServer = yield _createViteDevServer({
+            outputDir,
+            extensionConfig,
+            webSocketPort: actualWebSocketPort,
+            baseMessage,
+            root,
+            cardConfigs,
+        });
+        const shutdownServer = yield (0, server_1.default)({
+            outputDir,
+            expressPort,
+            webSocketPort: actualWebSocketPort,
+            baseMessage,
+            viteDevServer,
+            functionsConfig,
+        });
+        return shutdownServer;
+    });
+}
+exports.startDevMode = startDevMode;

package/dist/lib/extensionsService.d.ts

@@ -0,0 +1,12 @@
+import { BaseMessage } from './types';
+import { Response } from 'express/lib/response';
+import { Request } from 'express/lib/request';
+import { Application } from 'express/lib/application';
+declare class ExtensionsService {
+    endpoint: string;
+    constructor();
+    add(server: Application, webSocketPort: number, outputDir: string, baseMessage: BaseMessage, capabilities: string[]): string[];
+    generateExtensionsHandler(baseMessage: BaseMessage, webSocketPort: number, outputDir: string, capabilities?: string[]): (_req: Request, res: Response) => void;
+}
+declare const _default: ExtensionsService;
+export default _default;

package/dist/lib/extensionsService.js

@@ -0,0 +1,40 @@
+"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 constants_1 = require("./constants");
+const utils_1 = require("./utils");
+class ExtensionsService {
+    constructor() {
+        this.endpoint = '/extensions';
+    }
+    add(server, webSocketPort, outputDir, baseMessage, capabilities) {
+        server.get(this.endpoint, this.generateExtensionsHandler(baseMessage, webSocketPort, outputDir, capabilities));
+        return [this.endpoint];
+    }
+    generateExtensionsHandler(baseMessage, webSocketPort, outputDir, capabilities = []) {
+        return function extensionsHandler(_req, res) {
+            try {
+                const output = path_1.default.parse(baseMessage.callback).name;
+                const response = {
+                    websocket: `ws://localhost:${webSocketPort}`,
+                    version: constants_1.EXTENSIONS_MESSAGE_VERSION,
+                    capabilities,
+                    portalId: baseMessage.portalId,
+                    extensions: [
+                        Object.assign(Object.assign({}, baseMessage), { manifest: (0, utils_1.loadManifest)(outputDir, output) }),
+                    ],
+                };
+                res.status(200).json(response);
+            }
+            catch (e) {
+                res.status(500).json({
+                    message: 'Unable to determine which extensions are running',
+                });
+            }
+        };
+    }
+}
+exports.default = new ExtensionsService();

package/dist/lib/plugins/codeCheckingPlugin.d.ts

@@ -0,0 +1,7 @@
+import { Rollup } from 'vite';
+export interface CodeCheckingPluginOptions {
+    output: string;
+}
+export type CodeCheckingPlugin = (options: CodeCheckingPluginOptions) => Rollup.Plugin;
+declare const codeCheckingPlugin: CodeCheckingPlugin;
+export default codeCheckingPlugin;

package/dist/lib/plugins/codeCheckingPlugin.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+// @ts-expect-error no type defs for the logger
+const logger_1 = require("@hubspot/cli-lib/logger");
+const codeCheckingPlugin = options => {
+    const { output } = options;
+    return {
+        name: 'ui-extensions-code-checking-plugin',
+        enforce: 'post',
+        writeBundle(__options, __bundle) {
+            try {
+                const code = fs_1.default.readFileSync(output).toString();
+                if (!code.includes('const extend = (...args) => self.extend(...args);')) {
+                    logger_1.logger.warn('Unable to determine if your extension entry point is calling hubspot.extend, this may prevent it from rendering as expected');
+                }
+            }
+            catch (e) {
+                logger_1.logger.error('Unable to load bundle for code checking');
+            }
+        },
+    };
+};
+exports.default = codeCheckingPlugin;

package/dist/lib/plugins/codeInjectionPlugin.d.ts

@@ -0,0 +1,8 @@
+import { Rollup } from 'vite';
+export interface CodeInjectionPluginOptions {
+    file: string;
+    root?: string;
+}
+export type CodeInjectionPlugin = (options: CodeInjectionPluginOptions) => Rollup.Plugin;
+declare const codeInjectionPlugin: CodeInjectionPlugin;
+export default codeInjectionPlugin;

package/dist/lib/plugins/codeInjectionPlugin.js

@@ -0,0 +1,30 @@
+"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 codeInjectionPlugin = options => {
+    const { file, root = process.cwd() } = options;
+    return {
+        name: 'ui-extensions-code-injection-plugin',
+        enforce: 'post',
+        transform(code, fileBeingTransformed) {
+            const absoluteFilePath = path_1.default.isAbsolute(file)
+                ? file
+                : path_1.default.join(root, file);
+            if (fileBeingTransformed !== absoluteFilePath) {
+                return { code, map: null }; // Not the file we care about, return the same code
+            }
+            // Update the code to import the self script which houses our overrides
+            // This needs to be the first line in the source file so that the overrides get hoisted
+            // to the top of the generated source file
+            const updatedCode = `import "@hubspot/ui-extensions-dev-server/self"; ${code}`;
+            // Return the updated source code.  We don't need to include the new code in the
+            // sourcemap because we don't want it to show up in the users code when they
+            // view the source mapped code in the browser
+            return { code: updatedCode, map: null };
+        },
+    };
+};
+exports.default = codeInjectionPlugin;

package/dist/lib/plugins/devBuildPlugin.d.ts

@@ -0,0 +1,11 @@
+import Vite from 'vite';
+import { ExtensionConfig, BaseMessage } from '../types';
+export interface DevBuildPluginOptions {
+    extensionConfig: ExtensionConfig;
+    outputDir: string;
+    baseMessage: BaseMessage;
+    cardConfigs: string[];
+}
+export type DevBuildPlugin = (options: DevBuildPluginOptions) => Vite.Plugin;
+declare const devBuildPlugin: DevBuildPlugin;
+export default devBuildPlugin;

package/dist/lib/plugins/devBuildPlugin.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const vite_1 = require("vite");
+const manifestPlugin_1 = __importDefault(require("./manifestPlugin"));
+const utils_1 = require("../utils");
+const codeCheckingPlugin_1 = __importDefault(require("./codeCheckingPlugin"));
+const path_1 = __importDefault(require("path"));
+// @ts-expect-error no type defs
+const logger_1 = require("@hubspot/cli-lib/logger");
+const friendlyLoggingPlugin_1 = __importDefault(require("./friendlyLoggingPlugin"));
+const devBuildPlugin = options => {
+    let lastBuildError;
+    const { extensionConfig, outputDir, baseMessage, cardConfigs } = options;
+    const versionedBaseMessage = Object.assign(Object.assign({}, baseMessage), { version: constants_1.WEBSOCKET_MESSAGE_VERSION });
+    const handleBuildError = (error, server) => {
+        const { plugin, errors, frame, loc, id } = error;
+        // Filter out our custom plugins, but send everything else
+        if (!(plugin === null || plugin === void 0 ? void 0 : plugin.startsWith('ui-extensions'))) {
+            // @ts-expect-error Our websocket messages don't match Vite format
+            server.ws.send(Object.assign(Object.assign({}, versionedBaseMessage), { event: 'error', error: {
+                    details: {
+                        errors,
+                        formattedError: (0, utils_1.stripAnsiColorCodes)(frame),
+                        location: loc,
+                        file: id,
+                    },
+                } }));
+        }
+    };
+    const devBuild = (server) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield (0, vite_1.build)({
+                logLevel: 'warn',
+                mode: 'development',
+                define: {
+                    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development'),
+                },
+                esbuild: {
+                    tsconfigRaw: {
+                        compilerOptions: {
+                            preserveValueImports: true,
+                        },
+                    },
+                },
+                build: {
+                    lib: {
+                        entry: extensionConfig.data.module.file,
+                        name: extensionConfig.output,
+                        formats: ['iife'],
+                        fileName: () => extensionConfig.output,
+                    },
+                    rollupOptions: Object.assign(Object.assign({}, constants_1.ROLLUP_OPTIONS), { plugins: [
+                            (0, manifestPlugin_1.default)({
+                                minify: false,
+                                output: extensionConfig.output,
+                                extensionPath: extensionConfig.extensionPath,
+                            }),
+                            (0, codeCheckingPlugin_1.default)({
+                                output: path_1.default.join(outputDir, extensionConfig.output),
+                            }),
+                            (0, friendlyLoggingPlugin_1.default)(),
+                        ], output: Object.assign(Object.assign({}, constants_1.ROLLUP_OPTIONS.output), { sourcemap: 'inline' }) }),
+                    outDir: outputDir,
+                    emptyOutDir: true,
+                    minify: false,
+                },
+                clearScreen: false,
+            });
+            lastBuildError = null;
+            return true;
+        }
+        catch (error) {
+            lastBuildError = error;
+            logger_1.logger.debug(error);
+            handleBuildError(lastBuildError, server);
+            return false;
+        }
+    });
+    let localServer;
+    return {
+        name: 'ui-extensions-dev-build-plugin',
+        enforce: 'pre',
+        configureServer: (server) => __awaiter(void 0, void 0, void 0, function* () {
+            // Store a reference to the server to be used in hooks that don't get the server injected
+            // See https://vitejs.dev/guide/api-plugin.html#configureserver for information on this pattern
+            localServer = server;
+            localServer.ws.on('connection', () => {
+                logger_1.logger.info('Browser connected and listening for bundle updates');
+                // @ts-expect-error Our websocket messages don't match Vite format
+                localServer.ws.send(Object.assign(Object.assign({}, versionedBaseMessage), { event: 'start' }));
+                if (lastBuildError) {
+                    handleBuildError(lastBuildError, server);
+                }
+            });
+            yield devBuild(localServer);
+        }),
+        handleHotUpdate: ({ file, server }) => __awaiter(void 0, void 0, void 0, function* () {
+            if (cardConfigs.includes(file)) {
+                return [];
+            }
+            const successful = yield devBuild(server);
+            if (!successful) {
+                return [];
+            }
+            logger_1.logger.info(`Extension ${extensionConfig.data.title} updated, compiled`);
+            if (server.ws.clients.size === 0) {
+                logger_1.logger.debug('Bundle updated, no browsers connected to notify');
+                return [];
+            }
+            logger_1.logger.debug('Bundle updated, notifying connected browsers');
+            // @ts-expect-error Our websocket messages don't match Vite format
+            server.ws.send(Object.assign(Object.assign({}, versionedBaseMessage), { event: 'update' }));
+            return [];
+        }),
+        buildEnd(error) {
+            if (error) {
+                logger_1.logger.error(error);
+            }
+            logger_1.logger.debug('Sending shutdown message to connected browsers');
+            if (localServer && localServer.ws) {
+                // @ts-expect-error Our websocket messages don't match Vite format
+                localServer.ws.send(Object.assign(Object.assign({}, versionedBaseMessage), { event: 'shutdown' }));
+            }
+        },
+    };
+};
+exports.default = devBuildPlugin;

package/dist/lib/plugins/friendlyLoggingPlugin.d.ts

@@ -0,0 +1,11 @@
+import { RollupLog } from 'rollup';
+import Vite from 'vite';
+export interface MappedLog {
+    message?: string;
+    level?: 'error' | 'info' | 'warning' | 'debug';
+}
+export interface CodeToLogMapper {
+    [key: string]: (loggable: RollupLog) => MappedLog;
+}
+declare function friendlyLoggingPlugin(): Vite.Plugin;
+export default friendlyLoggingPlugin;

package/dist/lib/plugins/friendlyLoggingPlugin.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-expect-error no type defs
+const logger_1 = require("@hubspot/cli-lib/logger");
+const path_1 = __importDefault(require("path"));
+const unfriendlyCodeMapper = Object.freeze({
+    UNRESOLVED_IMPORT: (loggable) => {
+        const { exporter, id } = loggable;
+        const { base: extension } = path_1.default.parse(id);
+        return {
+            message: `${exporter} is imported by ${extension}, but ${exporter} cannot be resolved. Make sure ${exporter} is installed.`,
+            level: 'error',
+        };
+    },
+    MISSING_GLOBAL_NAME: () => {
+        return {};
+    },
+});
+const unfriendlyCodeList = Object.freeze(Object.keys(unfriendlyCodeMapper));
+function friendlyLoggingPlugin() {
+    return {
+        name: 'ui-extensions-friendly-logging-plugin',
+        enforce: 'post',
+        onLog(_level, log) {
+            if (unfriendlyCodeList.includes(log.code || '')) {
+                const { message, level } = _mapMessageToFriendlyVersion(log);
+                if (message && level) {
+                    logger_1.logger[level](message);
+                }
+                return false; // Filter the log message
+            }
+            return true; // We don't have a friendly log message, let it through
+        },
+    };
+}
+function _mapMessageToFriendlyVersion(loggable) {
+    var _a, _b;
+    const { code } = loggable;
+    return (_b = (_a = unfriendlyCodeMapper[code]) === null || _a === void 0 ? void 0 : _a.call(unfriendlyCodeMapper, loggable)) !== null && _b !== void 0 ? _b : {};
+}
+exports.default = friendlyLoggingPlugin;

package/dist/lib/plugins/manifestPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Rollup } from 'vite';
+export interface ManifestPluginOptions {
+    output: string;
+    minify?: boolean;
+    extensionPath?: string;
+}
+export type ManifestPlugin = (options: ManifestPluginOptions) => Rollup.Plugin;
+declare const manifestPlugin: ManifestPlugin;
+export default manifestPlugin;

package/dist/lib/plugins/manifestPlugin.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const path_2 = __importDefault(require("path"));
+// @ts-expect-error no type defs for the logger
+const logger_1 = require("@hubspot/cli-lib/logger");
+const PACKAGE_LOCK_FILE = 'package-lock.json';
+const PACKAGE_FILE = 'package.json';
+const EXTENSIONS_PATH = 'src/app/extensions/';
+const manifestPlugin = options => {
+    return {
+        name: 'ui-extensions-manifest-generation-plugin',
+        enforce: 'post',
+        generateBundle(_rollupOptions, bundle) {
+            const { output, minify = false, extensionPath = process.cwd() } = options;
+            try {
+                const filename = path_2.default.parse(output).name;
+                const manifest = _generateManifestContents(bundle, extensionPath);
+                this.emitFile({
+                    type: 'asset',
+                    source: minify
+                        ? JSON.stringify(manifest)
+                        : JSON.stringify(manifest, null, 2),
+                    fileName: (0, path_1.normalize)(`${filename}-${constants_1.MANIFEST_FILE}`),
+                });
+            }
+            catch (e) {
+                logger_1.logger.warn(`\nUnable to write manifest file in ${output}, ${e}`);
+            }
+        },
+    };
+};
+function _generateManifestContents(bundle, extensionPath) {
+    const baseManifest = {
+        package: _loadPackageFile(extensionPath),
+    };
+    // The keys to bundle are the filename without any path information
+    const bundles = Object.keys(bundle).filter(cur => cur.endsWith('.js'));
+    if (bundles.length === 1) {
+        return Object.assign(Object.assign({}, _generateManifestEntry(bundle[bundles[0]])), baseManifest);
+    }
+    const manifest = bundles.reduce((acc, current) => {
+        return Object.assign(Object.assign({}, acc), { [current]: _generateManifestEntry(bundle[current]) });
+    }, {});
+    return Object.assign(Object.assign({}, manifest), baseManifest);
+}
+function _generateManifestEntry(subBundle) {
+    const { facadeModuleId, moduleIds, modules } = subBundle;
+    return {
+        entry: _stripPathPriorToExtDir(facadeModuleId),
+        modules: _buildModulesInfo(moduleIds, modules),
+    };
+}
+function _loadJsonFileSafely(extensionPath, filename) {
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(path_2.default.join(extensionPath, filename)).toString());
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+function _loadPackageFile(extensionPath) {
+    // Look for package-lock.json then fallback to package.json
+    return (_loadJsonFileSafely(extensionPath, PACKAGE_LOCK_FILE) ||
+        _loadJsonFileSafely(extensionPath, PACKAGE_FILE));
+}
+function _stripPathPriorToExtDir(filepath) {
+    return filepath === null || filepath === void 0 ? void 0 : filepath.split(EXTENSIONS_PATH).pop();
+}
+function _buildModulesInfo(moduleIds, modules) {
+    const accumulator = {
+        internal: [],
+        external: [],
+    };
+    return moduleIds.reduce((acc, mod) => {
+        var _a;
+        const { renderedExports } = modules[mod];
+        const moduleData = {
+            module: _stripPathPriorToExtDir(mod),
+            renderedExports,
+        };
+        if ((_a = moduleData.module) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) {
+            acc.external.push(moduleData);
+        }
+        else {
+            acc.internal.push(moduleData);
+        }
+        return acc;
+    }, accumulator);
+}
+exports.default = manifestPlugin;

package/{lib → dist/lib}/self.js

@@ -1,4 +1,4 @@
+"use strict";
 /* eslint-disable hubspot-dev/no-confusing-browser-globals */
-
 // Set methods on the self object to undefined so they are not available within the worker code
 self.importScripts = undefined;

package/dist/lib/server.d.ts

@@ -0,0 +1,13 @@
+import { BaseMessage } from './types';
+import { ViteDevServer } from 'vite';
+import { ServiceConfiguration } from '@hubspot/app-functions-dev-server/dist/types';
+interface StartDevServerArgs {
+    outputDir: string;
+    expressPort: number;
+    webSocketPort: number;
+    baseMessage: BaseMessage;
+    viteDevServer: ViteDevServer;
+    functionsConfig: Partial<ServiceConfiguration>;
+}
+declare function startDevServer({ outputDir, expressPort, webSocketPort, baseMessage, viteDevServer, functionsConfig, }: StartDevServerArgs): Promise<() => Promise<void>>;
+export default startDevServer;

package/dist/lib/server.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const constants_1 = require("./constants");
+const extensionsService_1 = __importDefault(require("./extensionsService"));
+const app_functions_dev_server_1 = require("@hubspot/app-functions-dev-server");
+// @ts-expect-error no type defs
+const logger_1 = require("@hubspot/cli-lib/logger");
+function listen(app, port) {
+    return new Promise((resolve, reject) => {
+        const server = app
+            .listen({ port }, () => {
+            resolve(server);
+        })
+            .on('error', err => {
+            reject(err);
+        });
+    });
+}
+function startDevServer({ outputDir, expressPort, webSocketPort, baseMessage, viteDevServer, functionsConfig, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const app = (0, express_1.default)();
+        // Setup middleware
+        app.use((0, cors_1.default)());
+        app.use(express_1.default.static(outputDir));
+        app.use('/api/crm-extensibility/execution/internal/v3', (0, app_functions_dev_server_1.AppFunctionExecutionService)(Object.assign(Object.assign({}, functionsConfig), { logger: logger_1.logger })));
+        logger_1.logger.info('Serving app functions locally');
+        const endpointsAdded = extensionsService_1.default.add(app, webSocketPort, outputDir, baseMessage, constants_1.SERVER_CAPABILITIES);
+        endpointsAdded.forEach(endpoint => {
+            logger_1.logger.debug(`Listening at http://hslocal.net:${expressPort}${endpoint}`);
+        });
+        // Vite middlewares needs to go last because it's greedy and will block other middleware
+        app.use(viteDevServer.middlewares);
+        let server;
+        try {
+            server = yield listen(app, expressPort);
+        }
+        catch (e) {
+            if (e.code === 'EADDRINUSE') {
+                throw new Error(`Port ${expressPort} is already in use.`);
+            }
+            throw new Error(e);
+        }
+        logger_1.logger.debug(`Listening at ${baseMessage.callback}`);
+        return function shutdown() {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield viteDevServer.pluginContainer.close();
+                // Stop new connections to express server
+                server.close(() => { });
+                logger_1.logger.info('Extension dev server done cleaning up');
+            });
+        };
+    });
+}
+exports.default = startDevServer;