@elliemae/pui-cli 8.24.0 → 8.25.1

package/dist/cjs/server/csp.js

@@ -41,6 +41,7 @@ const CSP_REPORT_URI = "/diagnostics/v1/csp";
 const sources = [
   "'self'",
   "http://localhost:*",
+  "ws://localhost:*",
   "*.elliemae.io",
   "*.elliemae.com",
   "*.elliservices.com",

package/dist/cjs/server/index.js

@@ -26,6 +26,7 @@ var import_logger = require("./logger.js");
 var import_middlewares = require("./middlewares.js");
 var import_utils = require("./utils.js");
 var import_appRoutes = require("./appRoutes.js");
+var import_wsServer = require("./wsServer.js");
 (async function startServer() {
   const app = (0, import_express.default)();
   (0, import_middlewares.setupDefaultMiddlewares)(app);
@@ -37,4 +38,8 @@ var import_appRoutes = require("./appRoutes.js");
     import_logger.logger.error(err);
     process.exit(1);
   });
+  const { wsServer } = await (0, import_wsServer.createWSServer)({
+    port: import_utils.wsPort
+  });
+  app.locals.wsServer = wsServer;
 })();

package/dist/cjs/server/utils.js

@@ -30,14 +30,21 @@ var utils_exports = {};
 __export(utils_exports, {
   getCWD: () => getCWD,
   host: () => host,
-  port: () => port
+  port: () => port,
+  wsPort: () => wsPort
 });
 module.exports = __toCommonJS(utils_exports);
 var import_minimist = __toESM(require("minimist"), 1);
-const argv = (0, import_minimist.default)(process.argv.slice(2));
+const argv = (0, import_minimist.default)(
+  process.argv.slice(2)
+);
 const getCWD = () => process.cwd();
 const port = parseInt(
   argv.port || process.env.port || process.env.PORT || "3000",
   10
 );
 const host = argv.host || process.env.HOST || "localhost";
+const wsPort = parseInt(
+  argv.wsport || process.env.wsport || process.env.WSPORT || "5000",
+  10
+);

package/dist/cjs/server/wsServer.js

@@ -0,0 +1,129 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wsServer_exports = {};
+__export(wsServer_exports, {
+  createWSServer: () => createWSServer
+});
+module.exports = __toCommonJS(wsServer_exports);
+var import_node_http = __toESM(require("node:http"), 1);
+var wsLib = __toESM(require("ws"), 1);
+const PING_INTERVAL = 3e4;
+const DEFAULT_PORT = 5001;
+const onSocketError = (err) => {
+  console.error(err);
+};
+const authenticate = (token, cb) => {
+  if (!token)
+    cb(4401);
+  else
+    cb();
+};
+const getAuthToken = (protocols) => {
+  const authProtocol = protocols.find(
+    (protocol) => protocol.startsWith("auth--")
+  );
+  if (!authProtocol)
+    return "";
+  return authProtocol.split("--")[1]?.trim?.();
+};
+const createWSServer = ({
+  port = DEFAULT_PORT,
+  pingInterval = PING_INTERVAL,
+  onOpen
+}) => {
+  let isAlive = false;
+  const heartbeat = () => {
+    isAlive = true;
+  };
+  const httpServer = import_node_http.default.createServer();
+  const wsServer = new wsLib.WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    socket.on("error", onSocketError);
+    wsServer.handleUpgrade(req, socket, head, (ws) => {
+      const protocols = req.headers["sec-websocket-protocol"]?.split(",");
+      if (!protocols) {
+        console.error("no protocols");
+        ws.close(4401, "unauthorized");
+        socket.destroy();
+        socket.removeListener("error", onSocketError);
+        return;
+      }
+      authenticate(getAuthToken(protocols) || "", (errCode) => {
+        if (errCode) {
+          switch (errCode) {
+            case 4401:
+              ws.close(errCode, "unauthorized");
+              break;
+            default:
+              ws.close(4400, "Unknown error");
+              break;
+          }
+          socket.destroy();
+          socket.removeListener("error", onSocketError);
+        } else {
+          socket.removeListener("error", onSocketError);
+          wsServer.emit("connection", ws, req);
+        }
+      });
+    });
+  });
+  wsServer.on("connection", (ws) => {
+    isAlive = true;
+    ws.on("error", console.error);
+    ws.on("pong", () => {
+      heartbeat();
+    });
+    ws.on("message", (message) => {
+      console.log(
+        "message from client:",
+        JSON.parse(message)
+      );
+      ws.send(JSON.stringify(JSON.parse(message)));
+    });
+    console.log("client connected");
+    onOpen?.(ws);
+  });
+  const interval = setInterval(() => {
+    wsServer.clients.forEach((ws) => {
+      if (isAlive === false)
+        ws.terminate();
+      isAlive = false;
+      ws.ping();
+    });
+  }, pingInterval);
+  wsServer.on("close", function close() {
+    clearInterval(interval);
+  });
+  return new Promise((resolve) => {
+    httpServer.listen(port, () => {
+      console.log(`Websocket server listening on port ${port}`);
+      return resolve({ httpServer, wsServer });
+    });
+  });
+};

package/dist/cjs/webpack/webpack.dev.babel.js

@@ -43,6 +43,8 @@ var import_middlewares = require("../server/middlewares.js");
 var import_appRoutes = require("../server/appRoutes.js");
 var import_helpers = require("./helpers.js");
 var import_webpack_base_babel = require("./webpack.base.babel.js");
+var import_utils = require("../server/utils.js");
+var import_wsServer = require("../server/wsServer.js");
 const import_meta = {};
 const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
 const {
@@ -160,6 +162,14 @@ const devConfig = {
           }
           next();
         });
+        (0, import_wsServer.createWSServer)({
+          port: import_utils.wsPort
+        }).then(({ wsServer }) => {
+          if (devServer.app)
+            devServer.app.locals.wsServer = wsServer;
+        }).catch((err) => {
+          console.error(err);
+        });
       }
       return middlewares;
     }

package/dist/esm/server/csp.js

@@ -7,6 +7,7 @@ const CSP_REPORT_URI = "/diagnostics/v1/csp";
 const sources = [
   "'self'",
   "http://localhost:*",
+  "ws://localhost:*",
   "*.elliemae.io",
   "*.elliemae.com",
   "*.elliservices.com",

package/dist/esm/server/index.js

@@ -4,8 +4,9 @@ import {
   setupDefaultMiddlewares,
   setupAdditionalMiddlewars
 } from "./middlewares.js";
-import { port, host } from "./utils.js";
+import { port, wsPort, host } from "./utils.js";
 import { loadRoutes } from "./appRoutes.js";
+import { createWSServer } from "./wsServer.js";
 (async function startServer() {
   const app = express();
   setupDefaultMiddlewares(app);
@@ -17,4 +18,8 @@ import { loadRoutes } from "./appRoutes.js";
     logger.error(err);
     process.exit(1);
   });
+  const { wsServer } = await createWSServer({
+    port: wsPort
+  });
+  app.locals.wsServer = wsServer;
 })();

package/dist/esm/server/utils.js

@@ -1,13 +1,20 @@
 import minimist from "minimist";
-const argv = minimist(process.argv.slice(2));
+const argv = minimist(
+  process.argv.slice(2)
+);
 const getCWD = () => process.cwd();
 const port = parseInt(
   argv.port || process.env.port || process.env.PORT || "3000",
   10
 );
 const host = argv.host || process.env.HOST || "localhost";
+const wsPort = parseInt(
+  argv.wsport || process.env.wsport || process.env.WSPORT || "5000",
+  10
+);
 export {
   getCWD,
   host,
-  port
+  port,
+  wsPort
 };

package/dist/esm/server/wsServer.js

@@ -0,0 +1,99 @@
+import http from "node:http";
+import * as wsLib from "ws";
+const PING_INTERVAL = 3e4;
+const DEFAULT_PORT = 5001;
+const onSocketError = (err) => {
+  console.error(err);
+};
+const authenticate = (token, cb) => {
+  if (!token)
+    cb(4401);
+  else
+    cb();
+};
+const getAuthToken = (protocols) => {
+  const authProtocol = protocols.find(
+    (protocol) => protocol.startsWith("auth--")
+  );
+  if (!authProtocol)
+    return "";
+  return authProtocol.split("--")[1]?.trim?.();
+};
+const createWSServer = ({
+  port = DEFAULT_PORT,
+  pingInterval = PING_INTERVAL,
+  onOpen
+}) => {
+  let isAlive = false;
+  const heartbeat = () => {
+    isAlive = true;
+  };
+  const httpServer = http.createServer();
+  const wsServer = new wsLib.WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    socket.on("error", onSocketError);
+    wsServer.handleUpgrade(req, socket, head, (ws) => {
+      const protocols = req.headers["sec-websocket-protocol"]?.split(",");
+      if (!protocols) {
+        console.error("no protocols");
+        ws.close(4401, "unauthorized");
+        socket.destroy();
+        socket.removeListener("error", onSocketError);
+        return;
+      }
+      authenticate(getAuthToken(protocols) || "", (errCode) => {
+        if (errCode) {
+          switch (errCode) {
+            case 4401:
+              ws.close(errCode, "unauthorized");
+              break;
+            default:
+              ws.close(4400, "Unknown error");
+              break;
+          }
+          socket.destroy();
+          socket.removeListener("error", onSocketError);
+        } else {
+          socket.removeListener("error", onSocketError);
+          wsServer.emit("connection", ws, req);
+        }
+      });
+    });
+  });
+  wsServer.on("connection", (ws) => {
+    isAlive = true;
+    ws.on("error", console.error);
+    ws.on("pong", () => {
+      heartbeat();
+    });
+    ws.on("message", (message) => {
+      console.log(
+        "message from client:",
+        JSON.parse(message)
+      );
+      ws.send(JSON.stringify(JSON.parse(message)));
+    });
+    console.log("client connected");
+    onOpen?.(ws);
+  });
+  const interval = setInterval(() => {
+    wsServer.clients.forEach((ws) => {
+      if (isAlive === false)
+        ws.terminate();
+      isAlive = false;
+      ws.ping();
+    });
+  }, pingInterval);
+  wsServer.on("close", function close() {
+    clearInterval(interval);
+  });
+  return new Promise((resolve) => {
+    httpServer.listen(port, () => {
+      console.log(`Websocket server listening on port ${port}`);
+      return resolve({ httpServer, wsServer });
+    });
+  });
+};
+export {
+  createWSServer
+};

package/dist/esm/webpack/webpack.dev.babel.js

@@ -14,6 +14,8 @@ import {
   isGoogleTagManagerEnabled
 } from "./helpers.js";
 import { baseConfig } from "./webpack.base.babel.js";
+import { wsPort } from "../server/utils.js";
+import { createWSServer } from "../server/wsServer.js";
 const __filename = fileURLToPath(import.meta.url);
 const {
   appVersion,
@@ -130,6 +132,14 @@ const devConfig = {
           }
           next();
         });
+        createWSServer({
+          port: wsPort
+        }).then(({ wsServer }) => {
+          if (devServer.app)
+            devServer.app.locals.wsServer = wsServer;
+        }).catch((err) => {
+          console.error(err);
+        });
       }
       return middlewares;
     }

package/dist/types/server/utils.d.ts

@@ -1,3 +1,4 @@
 export declare const getCWD: () => string;
 export declare const port: number;
 export declare const host: string;
+export declare const wsPort: number;

package/dist/types/server/wsServer.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import http from 'node:http';
+import * as wsLib from 'ws';
+export interface Servers {
+    httpServer: http.Server;
+    wsServer: wsLib.WebSocketServer;
+}
+export interface WSServerOptions {
+    port?: number;
+    pingInterval?: number;
+    onOpen?: (webSocket: wsLib.WebSocket) => void;
+}
+export declare const createWSServer: ({ port, pingInterval, onOpen, }: WSServerOptions) => Promise<Servers>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/pui-cli",
-  "version": "8.24.0",
+  "version": "8.25.1",
   "description": "ICE MT UI Platform CLI",
   "sideEffects": false,
   "type": "module",
@@ -129,10 +129,10 @@
     "@types/cors": "~2.8.15",
     "@types/duplicate-package-checker-webpack-plugin": "~2.1.4",
     "@types/ip": "~1.1.2",
-    "@types/jest": "~29.5.6",
+    "@types/jest": "~29.5.7",
     "@types/jest-axe": "~3.5.7",
     "@types/moment-locales-webpack-plugin": "~1.2.5",
-    "@types/node": "~18.18.6",
+    "@types/node": "~18.18.8",
     "@types/normalize-path": "~3.0.1",
     "@types/postcss-preset-env": "~7.7.0",
     "@types/rimraf": "~3.0.2",
@@ -191,7 +191,7 @@
     "eslint-plugin-compat": "~4.2.0",
     "eslint-plugin-eslint-comments": "~3.2.0",
     "eslint-plugin-import": "~2.29.0",
-    "eslint-plugin-jest": "~27.4.3",
+    "eslint-plugin-jest": "~27.6.0",
     "eslint-plugin-jsdoc": "~43.2.0",
     "eslint-plugin-jsx-a11y": "~6.7.1",
     "eslint-plugin-mdx": "~2.2.0",
@@ -210,7 +210,7 @@
     "favicons-webpack-plugin": "~6.0.1",
     "find-up": "~6.3.0",
     "find-up-cli": "~5.0.0",
-    "happy-dom": "~12.9.1",
+    "happy-dom": "~12.10.3",
     "helmet-csp": "~3.4.0",
     "html-loader": "~4.2.0",
     "html-webpack-plugin": "~5.5.3",
@@ -225,7 +225,7 @@
     "jest-sonar-reporter": "~2.0.0",
     "jest-styled-components": "~7.2.0",
     "jest-watch-typeahead": "~2.2.2",
-    "jscodeshift": "~0.15.0",
+    "jscodeshift": "~0.15.1",
     "jsdoc": "~4.0.2",
     "lerna": "~6.6.2",
     "lint-staged": "~13.3.0",
@@ -234,14 +234,14 @@
     "moment": "~2.29.4",
     "moment-locales-webpack-plugin": "~1.2.0",
     "msw": "~1.3.2",
-    "node-gyp": "~9.4.0",
+    "node-gyp": "~9.4.1",
     "node-plop": "~0.32.0",
     "nodemon": "~2.0.22",
     "normalize-path": "~3.0.0",
     "npm-check-updates": "16.14.6",
     "npm-run-all": "~4.1.5",
     "pino": "~8.16.1",
-    "pino-http": "~8.5.0",
+    "pino-http": "~8.5.1",
     "pino-pretty": "~10.2.3",
     "plop": "~3.1.2",
     "postcss": "~8.4.31",
@@ -249,7 +249,7 @@
     "postcss-jsx": "~0.36.4",
     "postcss-loader": "~7.3.3",
     "postcss-markdown": "~1.2.0",
-    "postcss-preset-env": "9.2.0",
+    "postcss-preset-env": "9.3.0",
     "postcss-syntax": "~0.36.2",
     "prettier": "~2.8.8",
     "prisma": "~4.16.2",
@@ -277,14 +277,14 @@
     "ts-node": "~10.9.1",
     "tsc-alias": "~1.8.8",
     "tsx": "~3.13.0",
-    "typedoc": "~0.25.2",
+    "typedoc": "~0.25.3",
     "typescript": "~5.2.2",
     "update-notifier": "~6.0.2",
     "url-loader": "~4.1.1",
     "uuid": "~9.0.1",
     "vite": "~4.5.0",
     "vite-tsconfig-paths": "~4.2.1",
-    "vitest": "~1.0.0-beta.2",
+    "vitest": "~1.0.0-beta.3",
     "webpack": "~5.89.0",
     "webpack-bundle-analyzer": "~4.9.1",
     "webpack-cli": "~5.1.4",
@@ -293,6 +293,7 @@
     "webpack-merge": "~5.10.0",
     "whatwg-fetch": "~3.6.19",
     "workbox-webpack-plugin": "~6.6.0",
+    "ws": "~8.14.2",
     "yargs": "~17.7.2"
   },
   "devDependencies": {