miqro 7.2.7 → 7.2.9

package/build/esm/src/services/utils/websocketmanager.d.ts

@@ -2,7 +2,7 @@ import { Logger } from "@miqro/core";
 import { ClusterWebSocketServer2 } from "./cluster-ws.js";
 import { WSConfig } from "../../types.js";
 import { LogProvider } from "./log.js";
-import { EditorAdminInterface } from "../../../editor/common/admin-interface.js";
+import { EditorAdminInterface } from "../../common/admin-interface.js";
 export interface WebSocketManagerOptions {
     logger?: Logger | Console;
     loggerProvider?: LogProvider;

package/build/lib.cjs

@@ -2591,7 +2591,7 @@ var init_app = __esm({
           });
         });
         if (config?.onUpgrade) {
-          this.httpServer.on("upgrade", (req, socket, head) => {
+          this.httpServer.on("upgrade", async (req, socket, head) => {
             try {
               const logger = loggerFactory(req.uuid, req);
               try {
@@ -2600,7 +2600,8 @@ var init_app = __esm({
                   socket.destroy();
                 } else {
                   if (config?.onUpgrade) {
-                    return config.onUpgrade(req, socket, head);
+                    const ret = await config.onUpgrade(req, socket, head);
+                    return ret;
                   } else {
                     socket.end("HTTP/1.1 400 Bad Request");
                     socket.destroy();
@@ -2679,7 +2680,7 @@ Sec-WebSocket-Accept: ${acceptValue}${extra}\r
 \r
 `;
 }
-function parseFrame(buffer) {
+function parseFrame(buffer, maxFrameSize = DEFAULT_MAX_FRAME_SIZE) {
   const firstByte = buffer.readUInt8(0);
   const opCode = firstByte & 15;
   if (opCode === OPCODES.close) {
@@ -2699,6 +2700,9 @@ function parseFrame(buffer) {
     payloadLength = Number(buffer.readBigUInt64BE(offset));
     offset += 8;
   }
+  if (payloadLength > maxFrameSize) {
+    return null;
+  }
   const isMasked = Boolean(secondByte >>> 7 & 1);
   if (isMasked) {
     const maskingKey = buffer.readUInt32BE(offset);
@@ -2742,7 +2746,7 @@ function createFrame(payload) {
   buffer.write(payload, payloadBytesOffset);
   return buffer;
 }
-var import_crypto3, WebSocketServer, PING, OPCODES, GUID;
+var import_crypto3, WebSocketServer, PING, OPCODES, GUID, DEFAULT_MAX_FRAME_SIZE;
 var init_websocket = __esm({
   "node_modules/@miqro/core/build/websocket.js"() {
     import_crypto3 = require("crypto");
@@ -2776,12 +2780,21 @@ var init_websocket = __esm({
         if (!client) {
           throw new Error("client not found");
         }
+        if (!client.socket.writable) {
+          this.clients.delete(clientUUID);
+          throw new Error("socket not writable");
+        }
+        if (client.socket.writableLength > (this.options.maxFrameSize ?? DEFAULT_MAX_FRAME_SIZE)) {
+          client.socket.destroy();
+          this.clients.delete(clientUUID);
+          throw new Error("client send buffer full");
+        }
         return new Promise((resolve24, reject) => {
           try {
-            client.req.socket.write(createFrame(data), (err) => {
+            client.socket.write(createFrame(data), (err) => {
               if (err) {
                 try {
-                  client.req.socket.destroy(err);
+                  client.socket.destroy(err);
                 } catch (e) {
                   console.error(e);
                 }
@@ -2793,7 +2806,7 @@ var init_websocket = __esm({
             });
           } catch (e) {
             try {
-              client.req.socket.destroy();
+              client.socket.destroy();
             } catch (e2) {
               console.error(e2);
             }
@@ -2840,8 +2853,8 @@ var init_websocket = __esm({
             };
             req.logger.debug("upgrading connection");
             socket.write(createUpgradeHeaders(acceptKey, extraHeaders));
-            socket.on("data", (data) => {
-              const frame = parseFrame(data);
+            socket.on("data", async (data) => {
+              const frame = parseFrame(data, this.options.maxFrameSize);
               if (frame === PING) {
                 try {
                   socket.write(Buffer.from([138, 0]));
@@ -2854,7 +2867,7 @@ var init_websocket = __esm({
                   socket.destroy();
                 } else {
                   try {
-                    this.options.onMessage(client, frame);
+                    await this.options.onMessage(client, frame);
                   } catch (e) {
                     req.logger.error(e);
                   }
@@ -2869,23 +2882,23 @@ var init_websocket = __esm({
                 socket.destroy();
               }
             });
-            socket.on("error", (error2) => {
+            socket.on("error", async (error2) => {
               req.logger.debug("upgraded connection error!");
               req.logger.error(error2);
               if (this.options.onError) {
                 try {
-                  this.options.onError(client, error2);
+                  await this.options.onError(client, error2);
                 } catch (e) {
                   req.logger.error(e);
                 }
               }
             });
-            socket.on("end", () => {
+            socket.on("end", async () => {
               req.logger.debug("upgraded connection disconnected!");
               this.clients.delete(uuid);
               if (this.options.onDisconnect) {
                 try {
-                  this.options.onDisconnect(client);
+                  await this.options.onDisconnect(client);
                 } catch (e) {
                   req.logger.error(e);
                 }
@@ -2895,7 +2908,7 @@ var init_websocket = __esm({
             this.clients.set(uuid, client);
             if (this.options.onConnection) {
               try {
-                this.options.onConnection(client);
+                await this.options.onConnection(client);
               } catch (e) {
                 req.logger.error(e);
               }
@@ -2908,6 +2921,7 @@ var init_websocket = __esm({
     PING = /* @__PURE__ */ Symbol();
     OPCODES = { text: 1, close: 8, ping: 9, pong: 10 };
     GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+    DEFAULT_MAX_FRAME_SIZE = 1024 * 1024;
   }
 });
 
@@ -14229,9 +14243,13 @@ async function watchAndServer(app) {
       try {
         stopWatch();
         setTimeout(async () => {
-          watchLogger?.debug("closed");
-          await app.reload();
-          reWatch();
+          try {
+            watchLogger?.debug("closed");
+            await app.reload();
+            reWatch();
+          } catch (e) {
+            watchLogger?.error(e);
+          }
         }, 500);
       } catch (e) {
         watchLogger?.error(e);
@@ -14306,11 +14324,11 @@ function setupExitHandlers(app) {
     exceptionOccured = true;
     cleanJSX(app);
     if (app.server) {
-      app.stop();
+      await app.stop();
     }
     process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
   });
-  process.on("exit", async function(code) {
+  process.on("exit", function(code) {
     if (exceptionOccured) {
       app.logger?.error("Exception occured");
     } else {
@@ -14320,6 +14338,16 @@ function setupExitHandlers(app) {
       }
     }
   });
+  process.on("unhandledRejection", async (reason) => {
+    app.logger?.error("Unhandled rejection:");
+    app.logger?.error(reason);
+    exceptionOccured = true;
+    cleanJSX(app);
+    if (app.server) {
+      await app.stop();
+    }
+    process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
+  });
   process.on("SIGTERM", function() {
     app.logger?.info("SIGTERM received");
     process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);

package/editor/auth.ts

@@ -0,0 +1,52 @@
+import { timingSafeEqual } from "node:crypto";
+import { AuthConfig, ServerRequest } from "../src/types.js";
+import { AdminRequest } from "../src/common/admin-interface.js";
+
+export const ADMIN_EDITOR_AUTH_KEY = "$$ADMIN_EDITOR_AUTH_KEY$$";
+
+export const ADMIN_EDITOR_AUTH_QUERY = "key";
+export const ADMIN_EDITOR_AUTH_COOKIE = ADMIN_EDITOR_AUTH_KEY;
+
+export default {
+  authService: {
+    verify: async (args) => {
+
+      const adminInterface = (args.req as AdminRequest).editor;
+      const serverInterface = (args.req as any as ServerRequest).server;
+      const KEY = (adminInterface ? adminInterface.getCache() : serverInterface.cache).get<string>(ADMIN_EDITOR_AUTH_KEY);
+
+      const validSesson = {
+        username: "username",
+        account: "account",
+        groups: [],
+        token: args.token
+      };
+
+      const queryToken = args.req.query[ADMIN_EDITOR_AUTH_QUERY];
+      const cookieToken = args.req.cookies[ADMIN_EDITOR_AUTH_COOKIE];
+
+      //console.log("\n\nqueryToken[%s] cookieToken[%s] KEY[%s]\n\n", queryToken, cookieToken, KEY);
+
+      if (queryToken) {
+        if (typeof queryToken === "string" && timingSafeEqual(Buffer.from(queryToken), Buffer.from(KEY))) {
+          args.res.setCookie(ADMIN_EDITOR_AUTH_COOKIE, KEY, {
+            expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 31 * 12 * 500),
+            httpOnly: true,
+
+            //secure: true,
+            path: "/",
+            //sameSite: "strict"
+          });
+          args.req.searchParams.delete(ADMIN_EDITOR_AUTH_QUERY);
+          const queryString = args.req.searchParams.toString();
+          const redirect = args.req.path + (queryString ? "?" + queryString : "");
+          await args.res.redirect(redirect);
+          return validSesson;
+        }
+      } else if (cookieToken) {
+        return cookieToken === KEY ? validSesson : null;
+      }
+      return null;
+    },
+  }
+} as AuthConfig;

package/editor/common/constants.server.ts

@@ -0,0 +1,5 @@
+import { resolve } from "node:path";
+import { cwd } from "node:process";
+
+export const PORT = process.env["PORT"] ? process.env["PORT"] : "8080";
+export const BASE_PATH = resolve(cwd());

package/editor/common/constants.ts

@@ -0,0 +1,21 @@
+export const BASEEDITOR_PATH = "/admin/editor";
+export const LOG_SOCKET_PATH = "/admin/socket";
+export const LOG_WRITE_EVENT = "LogWrite";
+
+export const SUPPORTED_LANGUAGES = [
+  "text",
+  "json",
+  "javascript",
+  "typescript",
+  "dockerfile",
+  "yaml",
+  "xml",
+  "html",
+  "css",
+  "scss",
+  "markdown",
+  "c",
+  "cpp",
+  "bash",
+  "python"
+];

package/editor/common/editor-index.tsx

@@ -0,0 +1,17 @@
+import { scanDir } from "../http/admin/editor/api/fs/scan.api.js";
+import { parseInflateErrors } from "../http/admin/editor/api/server/restart.api.js";
+import { AdminRequest } from "../../src/common/admin-interface.js";
+import { HTMLEncode } from "./html-encode.js";
+
+export function EditorIndex(editorCSS: string, editorJS: string, enableHotReload: boolean) {
+  return async function editorIndex(req: AdminRequest, res) {
+    const admin = req.editor;
+
+    const errors = parseInflateErrors(admin ? admin.getInflateErrors() : []);
+    const files = scanDir(req);
+    const migrations = admin ? admin.getMigrations().map(m => m.name) : [];
+    const services = admin ? admin.getServices() : ["."];
+    const hotReload = enableHotReload ? (admin ? admin.getHotReloadHTML() : "") : "";
+    res.html(`<!DOCTYPE html><html><body><style>${editorCSS}</style><script type="module">${editorJS}</script><editor-component class="main-container" reloadstring="${req.uuid}" migrations="${HTMLEncode(JSON.stringify(migrations))}" services="${HTMLEncode(JSON.stringify(services))}" errors="${HTMLEncode(JSON.stringify(errors))}" files="${HTMLEncode(JSON.stringify(files))}"><noscript>Enable JavaScript</noscript></editor-component>${hotReload}</body></html>`)
+  }
+}

package/editor/common/html-encode.ts

@@ -0,0 +1,14 @@
+export function HTMLEncode(str: string): string {
+  let i = str.length;
+  const aRet: string[] = [];
+
+  while (i--) {
+    const iC = str[i].charCodeAt(0);
+    if (iC < 65 || iC > 127 || (iC > 90 && iC < 97)) {
+      aRet[i] = '&#' + iC + ';';
+    } else {
+      aRet[i] = str[i];
+    }
+  }
+  return aRet.join('');
+}

package/editor/common/log-socket.tsx

@@ -0,0 +1,87 @@
+import * as jsx from "@miqro/jsx";
+
+interface LogLine { out: string; identifier: string; level: "error" | "warn" | "debug" | "trace" | "info" }
+
+export interface LogSocket {
+  lines: LogLine[];
+  clearLog: () => void;
+  getMaxlogsize: () => number | "unlimited";
+  setMaxLogSize: (val: number | "unlimited") => void;
+}
+
+export function useLogSocket(options: { disableLog?: boolean; }): LogSocket {
+
+  const [_, setmaxLogSize, getMaxlogsize] = jsx.useState<number | "unlimited">(1000000);
+
+  const [__, setlines, getLines] = jsx.useState<LogLine[]>([]);
+  const refresh = jsx.useRefresh();
+
+  jsx.useEffect(() => {
+
+    let timeout;
+
+    function setupSocket() {
+      try {
+        if (options.disableLog) {
+          return;
+        }
+        console.log("setting up log socket");
+        const socket = new WebSocket("/admin/socket");
+        socket.addEventListener("error", (err) => {
+          console.error(err);
+          clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            setupSocket();
+          }, 1000);
+        });
+        socket.addEventListener("open", () => {
+          console.log("log socket open");
+          clearTimeout(timeout);
+          socket.addEventListener("message", (msg) => {
+            const lines = getLines();
+            const data = JSON.parse(msg.data);
+            //console.log(data.out);
+            const maxLogSize = getMaxlogsize();
+            if (maxLogSize !== "unlimited" && lines.length >= maxLogSize) {
+              lines.splice(0, (lines.length - maxLogSize) + 1);
+            }
+            lines.push(data);
+            setlines(lines);
+            refresh();
+          });
+        });
+        socket.addEventListener("close", () => {
+          console.log("log socket close");
+          clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            setupSocket();
+          }, 1000);
+        });
+      } catch (e) {
+        console.error(e);
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+          setupSocket();
+        }, 1000);
+      }
+    }
+
+    setupSocket();
+  }, []);
+
+  return {
+    lines: getLines(),
+    clearLog: () => {
+      setlines([]);
+    },
+    getMaxlogsize,
+    setMaxLogSize: (newValue: number | "unlimited") => {
+      if (newValue === "unlimited") {
+        setmaxLogSize(newValue);
+      } else {
+        setmaxLogSize(newValue);
+      }
+
+    }
+  }
+}