@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/server/utils/{microservices.js → microservices.ts}

@@ -7,32 +7,42 @@ import path from "node:path";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
 
 // Local imports
+import { type Microservice, microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
+import { type NamedChildProcess, getAvailablePort, waitForReady } from "./scripts.js";
 import { addNginxLocation, addSupervisorProgram } from "./cloud.js";
-import { getAvailablePort, waitForReady } from "./scripts.js";
-import { microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
 import { executablePath } from "./path.js";
 
+interface RunArgs {
+  projectFolderPath: string;
+  uploadFolderPath?: string;
+  [key: string]: unknown;
+}
+
 const MILLISECONDS_PER_SECOND = 1000;
 const DEFAULT_TIMEOUT_SECONDS = 45;
 const MAX_PORT_RETRIES = 1;
+const DEFAULT_RUN_ARGS: RunArgs = { projectFolderPath: "" };
+
 async function runScript(
-  execPath,
-  execName,
-  args,
-  expectedResponse,
+  execPath: string,
+  execName: string,
+  args: readonly string[],
+  expectedResponse: string,
   timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-) {
+): Promise<NamedChildProcess> {
   const command = executablePath(execPath, execName);
   console.log("runScript", command, args);
   const child = child_process.spawn(command, args, {
     stdio: ["ignore", "pipe", "pipe"],
-  });
+  }) as NamedChildProcess;
   child.name = command.replace(/^.*[\\/]/u, "");
   child.on("spawn", () => {
     console.log(`[${child.name}] spawned, pid=${child.pid}`);
   });
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutSeconds * MILLISECONDS_PER_SECOND);
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeoutSeconds * MILLISECONDS_PER_SECOND);
   if (typeof timer.unref === "function") {
     timer.unref();
   }
@@ -46,16 +56,20 @@ async function runScript(
     throw error;
   }
 }
-function isPortInUseError(errorMessage) {
-  return /EADDRINUSE|address already in use|port already in use/iu.test(errorMessage);
+
+function isPortInUseError(error: unknown): boolean {
+  return /EADDRINUSE|address already in use|port already in use/iu.test(String(error));
 }
 
-function backArgs(args, port) {
+function backArgs(args: RunArgs, port: number): string[] {
   const { projectFolderPath } = args;
   if (!projectFolderPath) {
     throw new Error("projectFolderPath is required");
   }
-  const uploadFolderPath = args.uploadFolderPath || path.join(projectFolderPath, "uploads");
+  const uploadFolderPath =
+    args.uploadFolderPath !== undefined && args.uploadFolderPath !== ""
+      ? args.uploadFolderPath
+      : path.join(projectFolderPath, "uploads");
   const executableArgs = [
     "--port",
     String(port),
@@ -68,14 +82,19 @@ function backArgs(args, port) {
     "--timeout",
     "0",
   ];
-  if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
+  if (process.env.NODE_ENV === undefined || process.env.NODE_ENV === "development") {
     executableArgs.push("--debug");
   }
   return executableArgs;
 }
 
-async function runBack(execName, execPath, args = {}, attempts = 0) {
-  let port = undefined;
+async function runBack(
+  execName: string,
+  execPath: string,
+  args: RunArgs = DEFAULT_RUN_ARGS,
+  attempts = 0,
+): Promise<number> {
+  let port: number | undefined = undefined;
   try {
     port = await getAvailablePort();
     const executableArgs = backArgs(args, port);
@@ -93,14 +112,20 @@ async function runBack(execName, execPath, args = {}, attempts = 0) {
       return newPort;
     }
   }
+  throw new Error(`runBack failed to run ${execName}`);
 }
 
-async function runViewer(execName, execPath, args = {}, attempts = 0) {
+async function runViewer(
+  execName: string,
+  execPath: string,
+  args: RunArgs = DEFAULT_RUN_ARGS,
+  attempts = 0,
+): Promise<number> {
   const { projectFolderPath } = args;
   if (!projectFolderPath) {
     throw new Error("projectFolderPath is required");
   }
-  let port = undefined;
+  let port: number | undefined = undefined;
   try {
     port = await getAvailablePort();
     const viewerArgs = [
@@ -116,7 +141,7 @@ async function runViewer(execName, execPath, args = {}, attempts = 0) {
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
-      console.log("runBack error", error);
+      console.log("runViewer error", error);
       throw error;
     }
     if (attempts <= MAX_PORT_RETRIES) {
@@ -125,10 +150,17 @@ async function runViewer(execName, execPath, args = {}, attempts = 0) {
       return newPort;
     }
   }
+  throw new Error(`runViewer failed to run ${execName}`);
 }
 
-async function runExtension(extensionId, execName, execPath, args = {}, attempts = 0) {
-  let port = undefined;
+async function runExtension(
+  extensionId: string,
+  execName: string,
+  execPath: string,
+  args: RunArgs = DEFAULT_RUN_ARGS,
+  attempts = 0,
+): Promise<number> {
+  let port: number | undefined = undefined;
   try {
     port = await getAvailablePort();
     const executableArgs = backArgs(args, port);
@@ -139,7 +171,7 @@ async function runExtension(extensionId, execName, execPath, args = {}, attempts
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
-      console.log("runBack error", error);
+      console.log("runExtension error", error);
       throw error;
     }
     if (attempts <= MAX_PORT_RETRIES) {
@@ -148,18 +180,26 @@ async function runExtension(extensionId, execName, execPath, args = {}, attempts
       return newPort;
     }
   }
+  throw new Error(`runExtension failed to run ${extensionId}`);
 }
-function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
+function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microservice): void {
   const microservices = projectMicroservices(projectFolderPath);
+  let enriched: Microservice = { ...serviceObj };
   if (serviceObj.type === "back") {
     const schema = back_schemas.opengeodeweb_back.kill;
-    serviceObj.url = `http://localhost:${serviceObj.port}/${schema.$id}`;
     const [method] = schema.methods;
-    serviceObj.method = method;
+    enriched = {
+      ...enriched,
+      url: `http://localhost:${serviceObj.port}/${schema.$id}`,
+      method,
+    };
   } else if (serviceObj.type === "viewer") {
-    serviceObj.url = `ws://localhost:${serviceObj.port}/ws`;
+    enriched = {
+      ...enriched,
+      url: `ws://localhost:${serviceObj.port}/ws`,
+    };
   }
-  microservices.push(serviceObj);
+  microservices.push(enriched);
   fs.writeFileSync(
     microservicesMetadatasPath(projectFolderPath),
     JSON.stringify(
@@ -171,4 +211,5 @@ function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
     ),
   );
 }
+
 export { addMicroserviceMetadatas, runBack, runExtension, runViewer };

package/server/utils/{path.js → path.ts}

@@ -8,17 +8,21 @@ import { setTimeout } from "node:timers/promises";
 import { v4 as uuidv4 } from "uuid";
 
 // Local imports
-import { appMode } from "@geode/opengeodeweb-front/shared/app_mode.js";
-import { commandExistsSync } from "./scripts.js";
+import { appMode } from "@geode/opengeodeweb-front/shared/app_mode.ts";
+import { commandExistsSync } from "./scripts.ts";
 
-function executableName(execName) {
+function executableName(execName: string): string {
   if (process.platform === "win32") {
     return `${execName}.exe`;
   }
   return execName;
 }
 
-function findExecutableInDir(baseDir, execName, osExecutableName) {
+function findExecutableInDir(
+  baseDir: string,
+  execName: string,
+  osExecutableName: string,
+): string | undefined {
   const oneFilePath = path.join(baseDir, osExecutableName);
   if (fs.existsSync(oneFilePath) && fs.statSync(oneFilePath).isFile()) {
     console.log(`[executablePath] Found OneFile executable: ${oneFilePath}`);
@@ -35,7 +39,7 @@ function findExecutableInDir(baseDir, execName, osExecutableName) {
   return undefined;
 }
 
-function executablePath(execPath, execName) {
+function executablePath(execPath: string, execName: string): string {
   const osExecutableName = executableName(execName);
   const resourcesPath = process.env.RESOURCES_PATH;
   const mode = process.env.MODE;
@@ -49,13 +53,15 @@ function executablePath(execPath, execName) {
   }
 
   const foundAtExecPath = findExecutableInDir(execPath, execName, osExecutableName);
-  if (foundAtExecPath) {
+  if (foundAtExecPath !== undefined && foundAtExecPath !== "") {
     return foundAtExecPath;
   }
   if (mode === appMode.DESKTOP && nodeEnv === "production") {
-    const foundInResources = findExecutableInDir(resourcesPath, execName, osExecutableName);
-    if (foundInResources) {
-      return foundInResources;
+    if (resourcesPath !== undefined && resourcesPath !== "") {
+      const foundInResources = findExecutableInDir(resourcesPath, execName, osExecutableName);
+      if (foundInResources !== undefined && foundInResources !== "") {
+        return foundInResources;
+      }
     }
     throw new Error(
       `Executable not found in execPath (${execPath}) or resourcesPath (${resourcesPath}): ${osExecutableName}`,
@@ -65,7 +71,7 @@ function executablePath(execPath, execName) {
   throw new Error(`Executable not found: ${osExecutableName}`);
 }
 
-function createPath(dirPath) {
+function createPath(dirPath: string): string {
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, {
       recursive: true,
@@ -74,17 +80,21 @@ function createPath(dirPath) {
   }
   return dirPath;
 }
-function generateProjectFolderPath(projectName) {
+function generateProjectFolderPath(projectName: string): string {
   return path.join(os.tmpdir(), projectName.replaceAll("/", "_"), uuidv4());
 }
-function extensionFolderPath(projectFolderPath, extensionId) {
+function extensionFolderPath(projectFolderPath: string, extensionId: string): string {
   return path.join(projectFolderPath, "extensions", extensionId);
 }
-async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, frontendFile) {
+async function lookForLocalExtensionDistPath(
+  rootPath: string,
+  extentionRepoName: string,
+  frontendFile: string,
+): Promise<string | undefined> {
   const localExtensionPath = path.join(rootPath, "..", extentionRepoName);
   const localExtensionDistPath = path.join(localExtensionPath, "dist");
   if (!fs.existsSync(localExtensionDistPath)) {
-    return;
+    return undefined;
   }
   console.log(
     `[extensionFrontendPath] Found existing folder: ${localExtensionDistPath}, deleting it...`,
@@ -107,8 +117,14 @@ async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, fronte
     // oxlint-disable-next-line no-await-in-loop
     await setTimeout(MILLISECONDS_PER_RETRY);
   }
+  return undefined;
 }
-async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPath, extensionId) {
+async function extensionFrontendPath(
+  unzippedExtensionPath: string,
+  frontendFile: string,
+  rootPath: string,
+  extensionId: string,
+): Promise<string> {
   console.log("[extensionFrontendPath]", {
     unzippedExtensionPath,
     frontendFile,
@@ -124,7 +140,7 @@ async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPa
     extentionRepoName,
     frontendFile,
   );
-  if (localFilePath) {
+  if (localFilePath !== undefined && localFilePath !== "") {
     return localFilePath;
   }
   const unzippedfrontendFilePath = path.join(unzippedExtensionPath, frontendFile);
@@ -133,7 +149,10 @@ async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPa
   }
   throw new Error(`Failed to find ${unzippedfrontendFilePath}`);
 }
-function extensionBackendPath(unzippedExtensionPath, backendExecutableName) {
+function extensionBackendPath(
+  unzippedExtensionPath: string,
+  backendExecutableName: string,
+): string {
   const backendExecutablePath = path.join(
     unzippedExtensionPath,
     executableName(backendExecutableName),

package/server/utils/{scripts.js → scripts.ts}

@@ -1,4 +1,5 @@
 // Node imports
+import type { Readable } from "node:stream";
 import child_process from "node:child_process";
 import fs from "node:fs";
 import { on } from "node:events";
@@ -9,32 +10,44 @@ import readline from "node:readline";
 import { getPort } from "get-port-please";
 
 // Local imports
-import { appMode } from "@geode/opengeodeweb-front/shared/app_mode.js";
-import { setAppBaseUrl } from "@geode/opengeodeweb-front/shared/scripts.js";
+import { appMode } from "@geode/opengeodeweb-front/shared/app_mode.ts";
+import { setAppBaseUrl } from "@geode/opengeodeweb-front/shared/scripts.ts";
 
 const BYTES_PER_KIBIBYTE = 1024;
 const MAX_ERROR_BUFFER_KIBIBYTES = 64;
 const MAX_ERROR_BUFFER_BYTES = MAX_ERROR_BUFFER_KIBIBYTES * BYTES_PER_KIBIBYTE;
-function getAvailablePort() {
-  return getPort({
+
+async function getAvailablePort(): Promise<number> {
+  const port = await getPort({
     host: "localhost",
     random: true,
   });
+  return port;
 }
-function commandExistsSync(execName) {
-  const envPath = process.env.PATH || "";
+
+function commandExistsSync(execName: string): boolean {
+  const envPath = process.env.PATH ?? "";
   return envPath.split(path.delimiter).some((directory) => {
     const filePath = path.join(directory, execName);
     return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
   });
 }
+
 const encoder = new TextEncoder();
-function byteLength(str) {
+function byteLength(str: string): number {
   return encoder.encode(str).byteLength;
 }
 
-// oxlint-disable-next-line max-lines-per-function
-function waitForReady(child, expectedResponse, signal) {
+interface NamedChildProcess extends child_process.ChildProcessByStdio<null, Readable, Readable> {
+  name?: string;
+}
+
+// oxlint-disable-next-line max-lines-per-function typescript/prefer-readonly-parameter-types eslint/require-await
+async function waitForReady(
+  child: NamedChildProcess,
+  expectedResponse: string,
+  signal?: AbortSignal,
+): Promise<NamedChildProcess> {
   // oxlint-disable-next-line promise/avoid-new
   return new Promise((resolve, reject) => {
     const readlineStdout = readline.createInterface({
@@ -44,7 +57,7 @@ function waitForReady(child, expectedResponse, signal) {
       input: child.stderr,
     });
     let recentOutput = "";
-    function recordOutput(lineOutput) {
+    function recordOutput(lineOutput: string): void {
       const safeLine =
         byteLength(lineOutput) > MAX_ERROR_BUFFER_BYTES / 2
           ? `${lineOutput.slice(0, MAX_ERROR_BUFFER_BYTES / 2)}…[truncated]`
@@ -59,13 +72,13 @@ function waitForReady(child, expectedResponse, signal) {
         recentOutput = recentOutput.slice(newline + 1);
       }
     }
-    let onLine = undefined;
-    let onErrLine = undefined;
-    let onError = undefined;
-    let onClose = undefined;
-    let onAbort = undefined;
+    let onLine: ((line: string) => void) | undefined = undefined;
+    let onErrLine: ((line: string) => void) | undefined = undefined;
+    let onError: ((err: Error) => void) | undefined = undefined;
+    let onClose: ((code: number | null) => void) | undefined = undefined;
+    let onAbort: (() => void) | undefined = undefined;
 
-    function cleanup() {
+    function cleanup(): void {
       if (onLine) {
         readlineStdout.removeListener("line", onLine);
       }
@@ -83,7 +96,7 @@ function waitForReady(child, expectedResponse, signal) {
       }
     }
 
-    function becomeReady() {
+    function becomeReady(): void {
       cleanup();
       readlineStdout.on("line", (line) => {
         console.log(`[${child.name}] ${line}`);
@@ -97,7 +110,7 @@ function waitForReady(child, expectedResponse, signal) {
       resolve(child);
     }
 
-    onLine = (lineOutput) => {
+    onLine = (lineOutput): void => {
       console.log(`[${child.name}] ${lineOutput}`);
       recordOutput(lineOutput);
       if (lineOutput.includes(expectedResponse)) {
@@ -105,7 +118,7 @@ function waitForReady(child, expectedResponse, signal) {
       }
     };
 
-    onErrLine = (line) => {
+    onErrLine = (line): void => {
       console.log(`[${child.name}] ${line}`);
       recordOutput(line);
       if (line.includes(expectedResponse)) {
@@ -113,12 +126,12 @@ function waitForReady(child, expectedResponse, signal) {
       }
     };
 
-    onError = (err) => {
+    onError = (err): void => {
       cleanup();
       reject(err);
     };
 
-    onClose = (code) => {
+    onClose = (code): void => {
       console.log(`[${child.name}] exited with code ${code}`);
       cleanup();
       reject(
@@ -128,7 +141,7 @@ function waitForReady(child, expectedResponse, signal) {
       );
     };
 
-    onAbort = () => {
+    onAbort = (): void => {
       cleanup();
       reject(new Error(`[${child.name}] timed out waiting for "${expectedResponse}"`));
     };
@@ -143,36 +156,38 @@ function waitForReady(child, expectedResponse, signal) {
     }
   });
 }
-async function waitNuxt(nuxtProcess) {
-  nuxtProcess.stderr.on("data", (data) => {
+async function waitNuxt(
+  nuxtProcess: child_process.ChildProcessWithoutNullStreams,
+): Promise<string> {
+  nuxtProcess.stderr.on("data", (data: Buffer) => {
     console.log("Nuxt STDERR:", data.toString().trim());
   });
   nuxtProcess.on("close", (code) => {
     console.log(`Nuxt process closed with code ${code}`);
   });
   for await (const [data] of on(nuxtProcess.stdout, "data")) {
-    const output = data.toString();
+    const output = String(data);
     console.log("Nuxt STDOUT:", output.trim());
-    const portMatch = output.match(/Listening on http:\/\/\[::\]:(?<port>\d+)/u);
-    if (portMatch) {
-      console.log("Nuxt listening on port", portMatch.groups.port);
-      nuxtProcess.stdout.on("data", (newData) => {
+    const portMatch = /Listening on http:\/\/\[::\]:(?<port>\d+)/u.exec(output);
+    const port = portMatch?.groups?.port;
+    if (port !== undefined) {
+      console.log("Nuxt listening on port", port);
+      nuxtProcess.stdout.on("data", (newData: Buffer) => {
         console.log("Nuxt STDOUT:", newData.toString().trim());
       });
-      return portMatch.groups.port;
+      return port;
     }
   }
   throw new Error("Nuxt process closed");
 }
-async function runBrowser(scriptName) {
+async function runBrowser(scriptName: string): Promise<number> {
   process.env.MODE = appMode.BROWSER;
   const port = await getAvailablePort();
   const nuxtProcess = child_process.spawn("npm", ["run", scriptName], {
     shell: true,
-    FORCE_COLOR: true,
     env: {
       ...process.env,
-      PORT: port,
+      PORT: String(port),
     },
   });
   await waitNuxt(nuxtProcess);
@@ -180,3 +195,4 @@ async function runBrowser(scriptName) {
   return port;
 }
 export { commandExistsSync, getAvailablePort, runBrowser, waitForReady };
+export type { NamedChildProcess };

package/server/utils/{server.js → server.ts}

@@ -8,19 +8,23 @@ import { extract as extractTar } from "tar";
 
 const TAR_ARCHIVE_PATTERN = /\.(?<ext>tar\.gz|tgz|tar)$/u;
 
-async function extractZipArchive(zipFilePath, outputDir) {
+async function extractZipArchive(zipFilePath: string, outputDir: string): Promise<void> {
   const data = await fs.promises.readFile(zipFilePath);
   const zip = await JSZip.loadAsync(data);
-  const promises = [];
+  const promises: Promise<void>[] = [];
 
   for (const [relativePath, zipEntry] of Object.entries(zip.files)) {
     const outputPath = path.join(outputDir, relativePath);
 
     if (zipEntry.dir) {
-      promises.push(fs.promises.mkdir(outputPath, { recursive: true }));
+      promises.push(
+        (async (): Promise<void> => {
+          await fs.promises.mkdir(outputPath, { recursive: true });
+        })(),
+      );
     } else {
       promises.push(
-        (async () => {
+        (async (): Promise<void> => {
           const content = await zipEntry.async("nodebuffer");
           await fs.promises.mkdir(path.dirname(outputPath), {
             recursive: true,
@@ -34,11 +38,14 @@ async function extractZipArchive(zipFilePath, outputDir) {
   await Promise.all(promises);
 }
 
-async function extractTarArchive(archivePath, outputDir) {
+async function extractTarArchive(archivePath: string, outputDir: string): Promise<void> {
   await extractTar({ file: archivePath, cwd: outputDir });
 }
 
-async function unzipFile(zipFilePath, outputDir = zipFilePath.replace(/\.[^/.]+$/u, "")) {
+async function unzipFile(
+  zipFilePath: string,
+  outputDir: string = zipFilePath.replace(/\.[^/.]+$/u, ""),
+): Promise<string> {
   console.log("Unzipping file...", zipFilePath, outputDir);
   try {
     await fs.promises.mkdir(outputDir, { recursive: true });

package/server/utils/server_config.ts

@@ -0,0 +1,74 @@
+import { type ServerWsRpcClient, createServerWsRpcClient } from "./ws_client.js";
+
+const stringStorage = new Map<string, string>();
+const booleanStorage = new Map<string, boolean>();
+const clientStorage = new Map<string, ServerWsRpcClient>();
+
+function getAppBaseUrl(): string {
+  const value = stringStorage.get("APP_BASE_URL");
+  if (value === undefined) {
+    throw new Error("APP_BASE_URL is not set");
+  }
+  return value;
+}
+function setAppBaseUrl(baseUrl: string): void {
+  stringStorage.set("APP_BASE_URL", baseUrl);
+}
+function getBackBaseUrl(): string {
+  const value = stringStorage.get("BACK_BASE_URL");
+  if (value === undefined) {
+    throw new Error("BACK_BASE_URL is not set");
+  }
+  return value;
+}
+function setBackBaseUrl(baseUrl: string): void {
+  stringStorage.set("BACK_BASE_URL", baseUrl);
+}
+function getViewerBaseUrl(): string {
+  const value = stringStorage.get("VIEWER_BASE_URL");
+  if (value === undefined) {
+    throw new Error("VIEWER_BASE_URL is not set");
+  }
+  return value;
+}
+function setViewerBaseUrl(baseUrl: string): void {
+  stringStorage.set("VIEWER_BASE_URL", baseUrl);
+}
+function getIsAppReady(): boolean {
+  return booleanStorage.get("IS_APP_READY") ?? false;
+}
+function setIsAppReady(isAppReady: boolean): void {
+  booleanStorage.set("IS_APP_READY", isAppReady);
+}
+async function setViewerWebSocketClient(baseUrl: string): Promise<ServerWsRpcClient> {
+  const client = createServerWsRpcClient(baseUrl);
+  client.onConnectionClose(() => {
+    if (clientStorage.get("VIEWER_CLIENT") === client) {
+      clientStorage.delete("VIEWER_CLIENT");
+    }
+  });
+  await client.ready;
+  clientStorage.set("VIEWER_CLIENT", client);
+  return client;
+}
+async function getViewerWebSocketClient(): Promise<ServerWsRpcClient> {
+  const viewerClient = clientStorage.get("VIEWER_CLIENT");
+  if (viewerClient !== undefined && viewerClient.isOpen()) {
+    return viewerClient;
+  }
+  const viewerBaseUrl = getViewerBaseUrl();
+  const client = await setViewerWebSocketClient(viewerBaseUrl);
+  return client;
+}
+export {
+  getAppBaseUrl,
+  getBackBaseUrl,
+  getIsAppReady,
+  getViewerBaseUrl,
+  getViewerWebSocketClient,
+  setAppBaseUrl,
+  setBackBaseUrl,
+  setIsAppReady,
+  setViewerBaseUrl,
+  setViewerWebSocketClient,
+};

package/server/utils/stream.ts

@@ -0,0 +1,6 @@
+import type { ReadableStream as NodeReadableStream } from "node:stream/web";
+
+export function toNodeWebStream(stream: ReadableStream): NodeReadableStream {
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  return stream as NodeReadableStream;
+}