miqro 6.1.4 → 6.2.0

package/src/common/jwt.ts

@@ -0,0 +1,85 @@
+import { EncryptJWT, EncryptOptions, JWTDecryptOptions, JWTDecryptResult, JWTPayload, JWTVerifyOptions, JWTVerifyResult, ProtectedHeaderParameters, SignJWT, SignOptions, decodeJwt, decodeProtectedHeader, jwtDecrypt as joseJWTDecrypt, jwtVerify } from "jose";
+import { KeyObject } from "node:crypto";
+import { EncryptJWTOptions, JWTSignOptions } from "../types.js";
+
+/**
+ * creates a JWT encrypted token with jose
+ * 
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns 
+ */
+export async function encryptJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<EncryptJWTOptions>): Promise<string> {
+  const en = new EncryptJWT(payload)
+    .setProtectedHeader({
+      alg: options?.alg ? options?.alg : 'dir',
+      enc: options?.enc ? options?.enc : 'A128CBC-HS256'
+    })
+    .setIssuedAt(options?.iat)
+    .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+    .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+    .setExpirationTime(options?.exp ? options?.exp : '2h');
+
+  return await en.encrypt(secret, options?.options);
+}
+
+/**
+ * decrypts a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns 
+ */
+export async function decryptJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTDecryptOptions>): Promise<JWTDecryptResult<PayloadType>> {
+  return await joseJWTDecrypt(jwt, secret, options)
+}
+
+/**
+ * verify a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns 
+ */
+export async function verifyJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTVerifyOptions>): Promise<JWTVerifyResult<PayloadType>> {
+  return await jwtVerify(jwt, secret, options)
+}
+
+/**
+ * creates a signed JWT with jose
+ * 
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns 
+ */
+export async function signJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<JWTSignOptions>): Promise<string> {
+  const sign = new SignJWT(payload)
+    .setProtectedHeader({
+      alg: options?.alg ? options?.alg : 'HS256',
+    })
+    .setIssuedAt(options?.iat)
+    .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+    .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+    .setExpirationTime(options?.exp ? options?.exp : '2h');
+  return sign.sign(secret, options?.options);
+}
+
+/**
+ * decodes a protected header with jose
+ * @param token 
+ * @returns 
+ */
+export function decodeProtectedHeaderJWT(token: string | object): ProtectedHeaderParameters {
+  return decodeProtectedHeader(token);
+}
+
+/**
+ * decodes a jwt token
+ * @param jwt 
+ * @returns 
+ */
+export function decodeJWT<PayloadType = JWTPayload>(jwt: string): PayloadType & JWTPayload {
+  return decodeJwt<PayloadType>(jwt)
+}

package/src/inflate/inflate-sea.ts

@@ -1,6 +1,6 @@
 import { Logger } from "@miqro/core";
 import { chmodSync, constants, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, extname, join, relative, resolve } from "node:path";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { cwd, platform } from "node:process";
 
 import { RouteFileMap, StaticFileMap } from "./setup-http.js";
@@ -66,22 +66,22 @@ export async function inflateAppForSea(logger: Logger, inflateDir: string, servi
 
   writeFile(logger, join(inflateDir, "sea", "package.json"), `{ "type": "module", "private": true }`);
 
-  writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { ServerInterfaceImpl, ServerRequestHandler, WebSocketManager, initGlobals, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
+  writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { createServerInterface, ServerRequestHandler, WebSocketManager, initGlobals, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
 
 async function main() {
   const PORT = process.env["PORT"] ? process.env["PORT"] : 8080; 
-  const logProvider = new LogProvider();
+  const loggerProvider = new LogProvider();
   const localCache = new LocalCache();
   const cache = new ClusterCache();
   const webSocketManager = new WebSocketManager();
   const dbManager = new DBManager();
   await initGlobals();
-  const serverInterface = new ServerInterfaceImpl({
+  const serverInterface = createServerInterface({
     cache,
     localCache,
-    logProvider,
+    loggerProvider,
     wsManager: webSocketManager,
-    logger: logProvider.getLogger("server"),
+    logger: loggerProvider.getLogger("server"),
     dbManager,
     port: PORT
   });
@@ -133,9 +133,10 @@ ${Object.keys(serviceRouteFileMap)
       .map(filePath => serviceRouteFileMap[filePath])
       .filter(data => data.previewMethod === "api")
       .map(data => data.routes.map(r => {
-        const rPath = r.inflatePath;
+        const rPath = join(relative(cwd(), dirname(data.filePath)), basename(data.filePath));
         if (rPath) {
-          const apiInflatedPath = join("..", "..", service, "http", rPath + ".api.js");
+          const rPathExt = extname(rPath);
+          const apiInflatedPath = join("..", "..", rPath.substring(0, rPath.length - rPathExt.length) + ".js");
           return `  await appendAPIModule(router, "../../${service}/http", "./${apiInflatedPath}", (await import("./${apiInflatedPath}")).default);`;
         } else {
           return "";

package/src/inflate/setup-http.ts

@@ -27,6 +27,7 @@ export interface RouteFileMap {
       options?: RouterHandlerOptions;
       inflatePath?: string;
     }[];
+    filePath: string;
     service: string;
     previewMethod: "api" | "html" | null;
   }
@@ -93,6 +94,7 @@ function createStaticRoute(service: string, logger: Logger, router: Router, dir:
       path: normalizePath(path)
     }],
     service,
+    filePath: file.filePath,
     previewMethod: "html"
   };
 
@@ -185,6 +187,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
               routeFileMap[file.filePath] = {
                 routes,
                 service,
+                filePath: file.filePath,
                 previewMethod: "api"
               };
 
@@ -230,6 +233,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
               routeFileMap[file.filePath] = {
                 routes,
                 service,
+                filePath: file.filePath,
                 previewMethod: "html"
               };
 
@@ -297,6 +301,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
 
               routeFileMap[file.filePath] = {
                 routes,
+                filePath: file.filePath,
                 service,
                 previewMethod: "html"
               };
@@ -375,6 +380,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     method: "GET",
                     path
                   }],
+                  filePath: file.filePath,
                   service,
                   previewMethod: "html"
                 };
@@ -428,6 +434,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                   path
                 }],
                 service,
+                filePath: file.filePath,
                 previewMethod: "html"
               };
 
@@ -487,6 +494,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     method: "GET",
                     path
                   }],
+                  filePath: file.filePath,
                   service,
                   previewMethod: "html"
                 };
@@ -545,6 +553,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     path
                   }],
                   service,
+                  filePath: file.filePath,
                   previewMethod: "html"
                 };
 

package/src/lib.ts

@@ -10,10 +10,10 @@ export { DBManager } from "./services/utils/db-manager.js";
 export { LogProvider, LogProviderOptions } from "./services/utils/log.js";
 export { Miqro, MiqroOptions, ServerRequestHandler } from "./services/app.js";
 export { initGlobals, assertGlobalTampered } from "./services/globals.js";
-export { appendAPIModule } from "./inflate/utils/sea-utils.js";
 
 //exported for --inflate-sea
-export { ServerInterfaceImpl, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
+export { appendAPIModule } from "./inflate/utils/sea-utils.js";
+export { createServerInterface, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";
 

package/src/services/app.ts

@@ -25,7 +25,7 @@ import { setupExitHandlers } from "../common/exit.js";
 import { inflateDBConfig, inflateDBMigrations, MigrationModule } from "../inflate/setup-db.js";
 import { getServicePath } from "../common/paths.js";
 import { LogConfigMap } from "../inflate/setup-log.js";
-import { ServerInterfaceImpl } from "./utils/server-interface.js";
+import { createServerInterface } from "./utils/server-interface.js";
 import { getPORT, importMiqroJSON } from "../common/arguments.js";
 import { createLogProviderOptions } from "./utils/log-transport.js";
 import { createAdminInterface } from "./utils/admin-interface.js";
@@ -139,6 +139,7 @@ export class Miqro {
     this.localCache = new LocalCache(`MiqroApplicationLocalCache[${this.options.name}]`, this.logger);
     this.webSocketManager = new WebSocketManager({
       logger: this.logger,
+      loggerProvider: this.loggerProvider,
       name: `MiqroApplicationWebsocketManager[${this.options.name}]`,
       avoidLogSocket: this.options.editor
     });
@@ -150,16 +151,17 @@ export class Miqro {
       logger: this.logger
     });
 
-    this.serverInterface = new ServerInterfaceImpl({
+    this.serverInterface = createServerInterface({
       cache: this.cache,
-      localCache: this.localCache,
       dbManager: this.dbManager,
-      wsManager: this.webSocketManager,
+      localCache: this.localCache,
+      webSocketManager: this.webSocketManager,
       app: this,
       logger: this.logger,
       loggerProvider: this.loggerProvider,
       port: this.options.port
     });
+
     this.serverRequestHandler = ServerRequestHandler(this.serverInterface);
 
     this.adminInterface = createAdminInterface(this);

package/src/services/globals.ts

@@ -1,5 +1,6 @@
 //@ts-ignore
 import { ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core";
+import cluster from "node:cluster";
 import { strictEqual } from "node:assert";
 import { HTMLEncode } from "@miqro/jsx-node";
 import { createElement as realCreateElement, enableDebugLog, useRuntime, Link, Router, usePathname, Fragment, useEffect, useRef, useState, useQuery, useRefresh, useElement, createContext, useContext, Component, Props } from "@miqro/jsx";
@@ -7,7 +8,10 @@ import { createElement as realCreateElement, enableDebugLog, useRuntime, Link, R
 import { jsx2HTML } from "../common/jsx.js";
 import { inflateMD2HTML } from "../inflate/md.js";
 import { EXIT_CODES } from "../common/constants.js";
-import { ServerGlobal } from "../lib.js";
+import { ClusterCache, LocalCache, ServerGlobal } from "../lib.js";
+import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../common/jwt.js";
+import { createSecretKey } from "node:crypto";
+import { Parser } from "@miqro/parser";
 
 /*const globaljsx: any = Object.freeze({
   useContext,
@@ -83,7 +87,46 @@ const globalServer: ServerGlobal = Object.freeze<ServerGlobal>({
     session: SessionHandler
   }),
   encodeHTML: HTMLEncode,
-  inflateMDtoHTML: inflateMD2HTML
+  inflateMDtoHTML: inflateMD2HTML,
+  createSecretKey,
+  newParser() {
+    return new Parser();
+  },
+  newClusterCache(name, logger) {
+    return new ClusterCache(name, logger);
+  },
+  newLocalCache(name, logger) {
+    return new LocalCache(name, logger);
+  },
+  getWorkerNumber(): number {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
+  },
+  getWorkerCount(): number {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
+  },
+  isPrimaryWorker(): boolean {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
+  },
+  jwt: {
+    decode(jwt) {
+      return decodeJWT(jwt);
+    },
+    decodeProtectedHeader(token) {
+      return decodeProtectedHeaderJWT(token);
+    },
+    decrypt(jwt, secret, options) {
+      return decryptJWT(jwt, secret, options);
+    },
+    encrypt(payload, secret, options) {
+      return encryptJWT(payload, secret, options);
+    },
+    sign(payload, secret, options) {
+      return signJWT(payload, secret, options);
+    },
+    verify(jwt, secret, options) {
+      return verifyJWT(jwt, secret, options);
+    }
+  }
 }) as ServerGlobal;
 
 export function browserJSXGlobals(inFile: string, jsxPath: string | false = false, useExport = true): string {

package/src/services/utils/cluster-ws.ts

@@ -17,7 +17,7 @@ export interface ClusterWebSocketServer2Message {
 export class ClusterWebSocketServer2 extends WebSocketServer {
   public remoteClients: Set<string> = new Set();
   listener: (data: any) => Promise<void>;
-  public constructor(protected name: string, options: WebSocketServerOptions) {
+  public constructor(protected name: string, public path: string, public logger: Logger | Console, options: WebSocketServerOptions) {
     super({
       ...options,
       validate: (req) => {
@@ -25,6 +25,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
           this.options.maxConnections !== undefined &&
           this.clients.size + this.remoteClients.size >= this.options.maxConnections
         ) {
+          this.logger?.warn("[%s] max web socket connection reached! connection refused from [%s]", req.uuid, req.socket.remoteAddress);
           return false;
         } else {
           return options.validate ? options.validate(req) : true;
@@ -41,6 +42,8 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
             errorMessage: error.message
           } as ClusterWebSocketServer2Message);
         }
+        this.logger?.error("[%s] error from (%s) error [%s]", req.uuid, req.req.socket.remoteAddress, error);
+        this.logger?.error(error);
         if (options.onError) {
           options.onError(req, error);
         }
@@ -55,6 +58,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
             clientUUID: req.uuid
           } as ClusterWebSocketServer2Message);
         }
+        this.logger?.log("[%s] new web socket connection from (%s)", req.uuid, req.req.socket.remoteAddress);
         if (options.onConnection) {
           options.onConnection(req);
         }
@@ -69,6 +73,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
             clientUUID: req.uuid
           } as ClusterWebSocketServer2Message);
         }
+        this.logger?.log("[%s] [%s] web socket disconnection from (%s)", req.uuid, this.path, req.req.socket.remoteAddress);
         if (options.onDisconnect) {
           options.onDisconnect(req);
         }

package/src/services/utils/server-interface.ts

@@ -7,137 +7,33 @@ import { Miqro } from "../app.js";
 import { WebSocketManager } from "./websocketmanager.js";
 import { execSync } from "node:child_process";
 import { LogProvider } from "./log.js";
-
-/*
-{
-      cache: this.cache,
-      localCache: this.localCache,
-      db: {
-        get: (name: string) => {
-          return this.dbManager.getDB(name);
-        },
-        getMigrations: () => {
-          if (this.inflated) {
-            const ret: NamedMigration[] = [];
-            for (const d of this.inflated.dbList) {
-              ret.push(...(d.migrations.map(m => {
-                return {
-                  name: m.name,
-                  service: m.service,
-                  dbName: m.dbName
-                }
-              })));
-            }
-            return ret;
-          }
-          return [];
-        },
-        migrate: (options) => {
-          return this.migrate(options);
-        },
-      },
-      ws: {
-        get: (path: string) => {
-          if (path === LOG_SOCKET_PATH) {
-            throw new Error("cannot use this path");
-          }
-          return this.webSocketManager.getWS(path);
-        },
-        disconnectAll: (path: string) => {
-          if (path === LOG_SOCKET_PATH) {
-            throw new Error("cannot use this path");
-          }
-          this.webSocketManager.disconnectAllFrom(path);
-        }
-      },
-      isPrimaryWorker: () => {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
-      },
-      openBrowser: (path: string) => {
-        const PORT = this.options.port;
-        const URL = `http://localhost:${PORT}${path}`;
-        const DEFAULT_OPEN = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
-        const OPEN = process.env["BROWSER"] ? process.env["BROWSER"] === "none" ? false : process.env["BROWSER"] : DEFAULT_OPEN;
-        if (OPEN) {
-          const openCMD = `${OPEN} "${URL}"`;
-          this.logger?.info("opening browser with [%s]", openCMD);
-          execSync(openCMD);
-        } else {
-          this.logger?.warn("ignoring browser [%s]", process.env["BROWSER"]);
-        }
-      },
-      logger: this.logger,
-      getLogger: (identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }) => {
-        return this.loggerProvider.getLogger(identifier, options);
-      }
-    }*/
+import { initGlobals } from "../globals.js";
 
 export interface ServerInterfaceImplOptions {
   cache: CacheInterface;
   localCache: CacheInterface;
   dbManager: DBManager;
-  wsManager: WebSocketManager;
+  webSocketManager: WebSocketManager;
   logger?: Logger;
   app?: Miqro;
   port?: string;
   loggerProvider?: LogProvider;
 }
 
-export class ServerInterfaceImpl implements ServerInterface {
-  public cache: CacheInterface;
-  public localCache: CacheInterface;
-  public logger?: Logger;
-  public port?: string;
-
-  public db: {
-    get(name: string): Database | null;
-    getMigrations(): NamedMigration[];
-    migrate(options: MigrateOptions): Promise<void>;
-  };
-  public ws: {
-    get(path: string): WebSocketServer | undefined;
-    disconnectAll(path: string): void;
-  };
-  public loggerProvider?: LogProvider;
-  openBrowser: (path: string) => void;
-
-  constructor(options: ServerInterfaceImplOptions) {
-    this.cache = options.cache;
-    this.localCache = options.localCache;
-    this.logger = options.logger ? options.logger : options.loggerProvider ? options.loggerProvider.getLogger("server") : undefined;
-    this.port = options.port;
-
-    const dbManager = options.dbManager;
-    const wsManager = options.wsManager;
-    this.loggerProvider = options.loggerProvider;
-    const app = options.app;
-
-    this.openBrowser = (path: string) => {
-      const PORT = this.port;
-      const URL = `http://localhost${PORT ? `:${PORT}` : ""}${path}`;
-      const DEFAULT_OPEN = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
-      const OPEN = app.options.browser !== undefined && String(app.options.browser).toUpperCase() !== "TRUE" && String(app.options.browser).toUpperCase() !== "1" ?
-        String(app.options.browser).toUpperCase() !== "0" && String(app.options.browser).toUpperCase() !== "FALSE" && String(app.options.browser).toUpperCase() !== "NONE" && app.options.browser ?
-          app.options.browser : false :
-        process.env["BROWSER"] ?
-          process.env["BROWSER"] === "none" ? false : process.env["BROWSER"] : DEFAULT_OPEN;
-      if (OPEN) {
-        const openCMD = `${OPEN} "${URL}"`;
-        this.logger?.info("opening browser with [%s]", openCMD);
-        execSync(openCMD);
-      } else {
-        this.logger?.warn("ignoring browser [%s]", OPEN);
-      }
-    }
-
-    this.db = Object.freeze({
-      get: (name: string) => {
-        return dbManager.getDB(name);
+export function createServerInterface(options: ServerInterfaceImplOptions): ServerInterface {
+  initGlobals();
+  return Object.freeze<ServerInterface>({
+    cache: options.cache,
+    localCache: options.localCache,
+    logger: options.logger,
+    db: {
+      get(name) {
+        return options.dbManager.getDB(name);
       },
-      getMigrations: () => {
-        if (app?.inflated) {
+      getMigrations() {
+        if (options.app?.inflated) {
           const ret: NamedMigration[] = [];
-          for (const d of app?.inflated.dbList) {
+          for (const d of options.app?.inflated.dbList) {
             ret.push(...(d.migrations.map(m => {
               return {
                 name: m.name,
@@ -150,30 +46,38 @@ export class ServerInterfaceImpl implements ServerInterface {
         }
         return [];
       },
-      migrate: (options: MigrateOptions) => {
-        return app?.migrate(options);
-      }
-    });
-    this.ws = Object.freeze({
+      migrate(migrateOptions) {
+        return options?.app?.migrate(migrateOptions);
+      },
+    },
+    ws: {
       get: (name: string) => {
-        return wsManager?.getWS(name);
+        return options?.webSocketManager?.getWS(name);
       },
       disconnectAll: (path: string) => {
-        return wsManager?.disconnectAllButLOGSocket();
+        return options?.webSocketManager?.disconnectAllButLOGSocket();
       }
-    });
-  }
-  public getWorkerNumber(): number {
-    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
-  }
-  public getWorkerCount(): number {
-    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
-  }
-  public isPrimaryWorker(): boolean {
-    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
-  }
-
-  public getLogger(identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }): Logger {
-    return this.loggerProvider?.getLogger(identifier, options);
-  }
+    },
+    openBrowser(path) {
+      const PORT = options.port;
+      const URL = `http://localhost${PORT ? `:${PORT}` : ""}${path}`;
+      const DEFAULT_OPEN = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
+      const OPEN = options?.app?.options.browser !== undefined && String(options?.app?.options.browser).toUpperCase() !== "TRUE" && String(options?.app?.options.browser).toUpperCase() !== "1" ?
+        String(options?.app.options.browser).toUpperCase() !== "0" && String(options?.app?.options.browser).toUpperCase() !== "FALSE" && String(options?.app?.options.browser).toUpperCase() !== "NONE" && options?.app?.options.browser ?
+          options?.app.options.browser : false :
+        process.env["BROWSER"] ?
+          process.env["BROWSER"] === "none" ? false : process.env["BROWSER"] : DEFAULT_OPEN;
+      if (OPEN) {
+        const openCMD = `${OPEN} "${URL}"`;
+        options?.logger?.info("opening browser with [%s]", openCMD);
+        execSync(openCMD);
+      } else {
+        options?.logger?.warn("ignoring browser [%s]", OPEN);
+      }
+    },
+    getLogger(identifier, loggerOptions) {
+      return options?.loggerProvider?.getLogger(identifier, loggerOptions);
+    },
+    ...server
+  });
 }

package/src/services/utils/websocketmanager.ts

@@ -2,9 +2,11 @@ import { Logger } from "@miqro/core";
 import { LOG_SOCKET_PATH } from "../../../editor/common/constants.js";
 import { ClusterWebSocketServer2 } from "./cluster-ws.js";
 import { WSConfig } from "../../types.js";
+import { LogProvider } from "./log.js";
 
 export interface WebSocketManagerOptions {
   logger?: Logger | Console;
+  loggerProvider?: LogProvider;
   name?: string;
   avoidLogSocket?: boolean;
 }
@@ -14,10 +16,12 @@ export class WebSocketManager {
   public logger?: Logger | Console | null = null;
   public name: string;
   public avoidLogSocket: boolean;
+  public loggerProvider: LogProvider;
   constructor(options?: WebSocketManagerOptions) {
     this.onUpgrade = this.onUpgrade.bind(this);
     this.logger = options && options.logger ? options.logger : null;
     this.name = options && options.name ? options.name : "WebSocketManager";
+    this.loggerProvider = options.loggerProvider;
     this.avoidLogSocket = options && options.avoidLogSocket ? options.avoidLogSocket : false;
   }
 
@@ -46,7 +50,9 @@ export class WebSocketManager {
           throw new Error(`ws on path ${wsConfig.path} already setup!`);
         }
         this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
-        const server = new ClusterWebSocketServer2(wsConfig.path, wsConfig);
+        const identifier = wsConfig.path.replaceAll("/", "_").toUpperCase();
+        const logger = this.loggerProvider && identifier.length >= 0 ? this.loggerProvider.getLogger(identifier.substring(identifier.charAt(0) === "_" ? 1 : 0)) : this.logger;
+        const server = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig.path, logger, wsConfig);
         this.runningGlobalWSMap.set(wsConfig.path, server);
       }
     }
@@ -65,7 +71,9 @@ export class WebSocketManager {
             throw new Error(`ws on path ${wsConfig.path} already setup!`);
           }
           this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
-          const server = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig);
+          const identifier = wsConfig.path.replaceAll("/", "_").toUpperCase();
+          const logger = this.loggerProvider && identifier.length >= 0 ? this.loggerProvider.getLogger(identifier.substring(identifier.charAt(0) === "_" ? 1 : 0)) : this.logger;
+          const server = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig.path, logger, wsConfig);
           this.runningGlobalWSMap.set(wsConfig.path, server);
         }
       }

package/src/types/cookie.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "cookie/index.js";

package/src/types/jose.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "jose/types/index.js";