claude-dev-server 1.2.2 → 1.2.3

package/dist/chunk-EEXRIRSF.js

@@ -0,0 +1,667 @@
+import { spawn } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join, relative, resolve } from 'path';
+import http from 'http';
+import { fileURLToPath } from 'url';
+import { createConnection } from 'net';
+import { SourceMapConsumer } from 'source-map';
+import { WebSocketServer } from 'ws';
+import { readFile } from 'fs/promises';
+
+// src/universal/index.ts
+function spawnClaudeCode(options) {
+  const port = 5e4 + Math.floor(Math.random() * 1e4);
+  const ttydProc = spawn("ttyd", [
+    "--port",
+    String(port),
+    "--interface",
+    "127.0.0.1",
+    "--writable",
+    options.claudePath,
+    ...options.args
+  ], {
+    cwd: options.cwd,
+    env: {
+      ...process.env,
+      ...options.env,
+      TERM: "xterm-256color",
+      FORCE_COLOR: "1"
+    }
+  });
+  ttydProc.on("exit", (code) => {
+    console.log(`[claude-dev-server] ttyd exited - code: ${code}`);
+  });
+  ttydProc.on("error", (err) => {
+    console.error(`[claude-dev-server] ttyd error: ${err.message}`);
+  });
+  return new Promise((resolve2, reject) => {
+    ttydProc.stdout?.on("data", (data) => {
+      const msg = data.toString();
+      console.log(`[ttyd] ${msg}`);
+    });
+    ttydProc.stderr?.on("data", (data) => {
+      const msg = data.toString();
+      console.error(`[ttyd stderr] ${msg}`);
+    });
+    setTimeout(() => {
+      resolve2({
+        wsUrl: `ws://127.0.0.1:${port}`,
+        process: ttydProc,
+        port
+      });
+    }, 500);
+    ttydProc.on("error", reject);
+  });
+}
+var sourceMapCache = /* @__PURE__ */ new Map();
+async function parseSourceMap(sourceMapUrl, content) {
+  try {
+    const consumer = await new SourceMapConsumer(content);
+    sourceMapCache.set(sourceMapUrl, consumer);
+  } catch (err) {
+    console.error("Failed to parse source map:", err);
+  }
+}
+async function findOriginalPosition(generatedFile, line, column) {
+  const consumer = sourceMapCache.get(generatedFile);
+  if (!consumer) {
+    return null;
+  }
+  try {
+    const position = consumer.originalPositionFor({ line, column });
+    if (position.source) {
+      return {
+        source: position.source,
+        line: position.line || 1,
+        column: position.column || 0,
+        name: position.name
+      };
+    }
+  } catch (err) {
+    console.error("Failed to find original position:", err);
+  }
+  return null;
+}
+function formatCodeContext(location) {
+  return `
+\u{1F4CD} Code Location:
+   File: ${location.file}
+   Line: ${location.line}
+   Column: ${location.column}
+`;
+}
+function createWebSocketServer(options) {
+  let wss = null;
+  let port = 0;
+  let ttydInfo = null;
+  const start = async () => {
+    console.log("[claude-dev-server] Starting ttyd...");
+    ttydInfo = await spawnClaudeCode({
+      cwd: options.projectRoot,
+      claudePath: options.claudePath,
+      args: options.claudeArgs
+    });
+    console.log(`[claude-dev-server] ttyd running at ${ttydInfo.wsUrl}`);
+    return new Promise((resolve2, reject) => {
+      wss = new WebSocketServer({ port, host: "127.0.0.1" });
+      wss.on("listening", () => {
+        const address = wss.address();
+        if (address && typeof address === "object") {
+          port = address.port;
+          resolve2({ wsPort: port, ttydPort: ttydInfo.port });
+        }
+      });
+      wss.on("error", (err) => {
+        reject(err);
+      });
+      wss.on("connection", (ws) => {
+        ws.on("message", async (message) => {
+          try {
+            const msg = JSON.parse(message.toString());
+            if (msg.type === "inspect") {
+              await handleInspect(msg, ws, options.projectRoot);
+            } else if (msg.type === "loadSourceMap") {
+              await handleLoadSourceMap(msg, ws, options.projectRoot);
+            }
+          } catch (err) {
+          }
+        });
+        ws.send(JSON.stringify({
+          type: "ready",
+          ttydUrl: ttydInfo.wsUrl
+        }));
+      });
+    });
+  };
+  const stop = () => {
+    ttydInfo?.process.kill();
+    wss?.close();
+  };
+  return { start, stop };
+}
+async function handleLoadSourceMap(msg, ws, projectRoot) {
+  const { sourceMapUrl } = msg;
+  try {
+    const mapPath = resolve(projectRoot, sourceMapUrl.replace(/^\//, ""));
+    const content = await readFile(mapPath, "utf-8");
+    await parseSourceMap(sourceMapUrl, content);
+    ws.send(JSON.stringify({
+      type: "sourceMapLoaded",
+      sourceMapUrl,
+      success: true
+    }));
+  } catch (err) {
+    ws.send(JSON.stringify({
+      type: "sourceMapLoaded",
+      sourceMapUrl,
+      success: false,
+      error: err.message
+    }));
+  }
+}
+async function handleInspect(msg, ws, projectRoot) {
+  const { url, line, column, sourceMapUrl } = msg;
+  let location = null;
+  if (sourceMapUrl) {
+    const original = await findOriginalPosition(sourceMapUrl, line, column);
+    if (original) {
+      location = {
+        file: resolve(projectRoot, original.source),
+        line: original.line,
+        column: original.column
+      };
+    }
+  }
+  if (!location) {
+    const match = url.match(/\/@fs\/(.+?)(?:\?|$)|\/@vite\/(.+?)(?:\?|$)/);
+    if (match) {
+      location = {
+        file: decodeURIComponent(match[1] || match[2]),
+        line,
+        column
+      };
+    }
+  }
+  ws.send(JSON.stringify({
+    type: "inspectResult",
+    location: location ? {
+      file: location.file,
+      line: location.line,
+      column: location.column,
+      context: formatCodeContext(location)
+    } : null
+  }));
+}
+
+// src/universal/index.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);
+async function startUniversalServer(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const port = options.port || 3e3;
+  const projectType = options.server?.type || detectProjectType(cwd);
+  const targetCommand = options.server?.command || getDefaultCommand(projectType);
+  console.log(`[Claude Dev Server] Detected project type: ${projectType}`);
+  console.log(`[Claude Dev Server] Starting target server...`);
+  const targetServer = spawnTargetServer(targetCommand, cwd);
+  console.log(`[Claude Dev Server] Waiting for target server to start (PID: ${targetServer.pid})...`);
+  const targetPort = await detectServerPort(targetServer, 3e4);
+  if (!targetPort) {
+    throw new Error("Failed to detect target server port. Please check if the dev server started successfully.");
+  }
+  console.log(`[Claude Dev Server] Target server is running on port ${targetPort}`);
+  const wsServer = createWebSocketServer({
+    port: 0,
+    // 自动分配端口
+    projectRoot: cwd,
+    claudePath: options.claudePath || "claude",
+    claudeArgs: options.claudeArgs || []
+  });
+  const { wsPort, ttydPort } = await wsServer.start();
+  console.log(`[Claude Dev Server] Control server running on ws://localhost:${wsPort}`);
+  console.log(`[Claude Dev Server] ttyd running on ws://localhost:${ttydPort}`);
+  const proxyServer = createProxyServer(targetPort, wsPort, cwd);
+  proxyServer.listen(port);
+  console.log(`[Claude Dev Server] Proxy server running on http://localhost:${port}`);
+  console.log(`
+\u{1F680} Ready! Open http://localhost:${port} in your browser`);
+  const cleanup = () => {
+    console.log("[Claude Dev Server] Shutting down...");
+    targetServer.kill();
+    wsServer.stop();
+    proxyServer.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  return { proxyServer, targetServer, wsServer };
+}
+function detectProjectType(cwd) {
+  if (existsSync(join(cwd, "vite.config.ts")) || existsSync(join(cwd, "vite.config.js"))) {
+    return "vite";
+  }
+  if (existsSync(join(cwd, "next.config.js")) || existsSync(join(cwd, "next.config.mjs"))) {
+    return "next";
+  }
+  if (existsSync(join(cwd, "webpack.config.js")) || existsSync(join(cwd, "webpack.config.ts"))) {
+    return "webpack";
+  }
+  return "custom";
+}
+function getDefaultCommand(projectType) {
+  switch (projectType) {
+    case "vite":
+      return "npm run dev";
+    case "next":
+      return "npm run dev";
+    case "webpack":
+      return "npm run dev";
+    default:
+      return "npm run dev";
+  }
+}
+function spawnTargetServer(command, cwd) {
+  const [cmd, ...args] = command.split(" ");
+  const child = spawn(cmd, args, {
+    cwd,
+    stdio: "pipe",
+    env: process.env
+  });
+  child.stdout?.pipe(process.stdout);
+  child.stderr?.pipe(process.stderr);
+  return child;
+}
+async function detectServerPort(childProcess, timeout) {
+  return new Promise((resolve2) => {
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve2(null);
+    }, timeout);
+    let stdout = "";
+    const onData = (chunk) => {
+      stdout += chunk.toString();
+      const patterns = [
+        /localhost:(\d{4,5})/,
+        /127\.0\.0\.1:(\d{4,5})/,
+        /0\.0\.0\.0:(\d{4,5})/
+      ];
+      for (const pattern of patterns) {
+        const match = stdout.match(pattern);
+        if (match) {
+          const port = parseInt(match[1], 10);
+          console.log(`[Claude Dev Server] Detected port from stdout: ${port}`);
+          cleanup();
+          resolve2(port);
+          return;
+        }
+      }
+    };
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      childProcess.stdout?.off("data", onData);
+    };
+    childProcess.stdout?.on("data", onData);
+  });
+}
+async function handleSourceMapRequest(projectRoot, filePath, line, column, targetPort) {
+  try {
+    let content;
+    let fullPath = filePath;
+    if (filePath.startsWith("/") && targetPort) {
+      try {
+        const response = await fetch(`http://localhost:${targetPort}${filePath}`);
+        if (!response.ok) {
+          console.log("[Claude Dev Server] Failed to fetch from Dev Server:", response.status);
+          return { error: "Failed to fetch from Dev Server" };
+        }
+        content = await response.text();
+        console.log("[Claude Dev Server] Fetched", content.length, "chars from Dev Server");
+      } catch (e) {
+        console.log("[Claude Dev Server] Fetch error:", e);
+        return { error: "Fetch error: " + e.message };
+      }
+    } else {
+      if (!filePath.startsWith("/")) {
+        fullPath = join(projectRoot, filePath);
+      }
+      if (!existsSync(fullPath)) {
+        console.log("[Claude Dev Server] File not found:", fullPath);
+        return { error: "File not found" };
+      }
+      content = readFileSync(fullPath, "utf-8");
+      console.log("[Claude Dev Server] Resolving source map for:", fullPath, "at line:", line);
+    }
+    let sourceMapUrl = null;
+    const patterns = [
+      /\/\/[@#]\s*sourceMappingURL=([^\s]+)/,
+      /\/\*[@#]\s*sourceMappingURL=([^\s]+)\s*\*\//
+    ];
+    for (const pattern of patterns) {
+      const match = content.match(pattern);
+      if (match) {
+        sourceMapUrl = match[1];
+        console.log("[Claude Dev Server] Found sourceMappingURL:", sourceMapUrl.substring(0, 100) + "...");
+        break;
+      }
+    }
+    if (!sourceMapUrl) {
+      console.log("[Claude Dev Server] No source map found in:", fullPath);
+      return { file: relative(projectRoot, fullPath), line, column };
+    }
+    let sourceMapContent;
+    let sourceMap;
+    if (sourceMapUrl.startsWith("data:application/json;base64,") || sourceMapUrl.startsWith("data:application/json;charset=utf-8;base64,")) {
+      console.log("[Claude Dev Server] Found inline source map");
+      const base64Data = sourceMapUrl.split(",", 2)[1];
+      sourceMapContent = Buffer.from(base64Data, "base64").toString("utf-8");
+      try {
+        sourceMap = JSON.parse(sourceMapContent);
+      } catch (e) {
+        console.log("[Claude Dev Server] Failed to parse inline source map:", e);
+        return { file: relative(projectRoot, fullPath), line, column };
+      }
+    } else if (sourceMapUrl.startsWith("http://") || sourceMapUrl.startsWith("https://")) {
+      console.log("[Claude Dev Server] Remote source map not supported:", sourceMapUrl);
+      return { file: relative(projectRoot, fullPath), line, column };
+    } else {
+      let sourceMapPath;
+      if (sourceMapUrl.startsWith("/")) {
+        sourceMapPath = sourceMapUrl;
+      } else {
+        sourceMapPath = join(dirname(fullPath), sourceMapUrl);
+      }
+      console.log("[Claude Dev Server] Reading external source map:", sourceMapPath);
+      if (!existsSync(sourceMapPath)) {
+        console.log("[Claude Dev Server] Source map file not found:", sourceMapPath);
+        return { file: relative(projectRoot, fullPath), line, column };
+      }
+      sourceMapContent = readFileSync(sourceMapPath, "utf-8");
+      sourceMap = JSON.parse(sourceMapContent);
+    }
+    const consumer = await new SourceMapConsumer(sourceMap);
+    const original = consumer.originalPositionFor({
+      line,
+      column
+    });
+    consumer.destroy();
+    if (original.source && original.line !== null) {
+      let originalFile = original.source;
+      if (originalFile.startsWith("webpack://")) {
+        originalFile = originalFile.replace(/^webpack:\/\/[\/\\]?/, "");
+      }
+      if (!originalFile.startsWith("/")) {
+        const possiblePath = join(projectRoot, originalFile);
+        if (existsSync(possiblePath)) {
+        } else {
+          const fileName = originalFile.split("/").pop() || originalFile.split("\\").pop() || originalFile;
+          if (fileName === originalFile) {
+            if (filePath.startsWith("/")) {
+              originalFile = filePath.substring(1);
+              console.log("[Claude Dev Server] Source is just a filename, using filePath:", originalFile);
+            } else {
+              originalFile = relative(projectRoot, fullPath);
+            }
+          } else {
+            originalFile = relative(projectRoot, possiblePath);
+          }
+        }
+      }
+      return {
+        file: originalFile,
+        line: original.line,
+        column: original.column || 1,
+        original: {
+          source: original.source,
+          line: original.line,
+          column: original.column,
+          name: original.name
+        }
+      };
+    }
+    return { file: relative(projectRoot, fullPath), line, column };
+  } catch (err) {
+    console.error("[Claude Dev Server] Source map resolution error:", err);
+    return { error: String(err) };
+  }
+}
+async function handleTurbopackLookup(projectRoot, pagePath, targetPort) {
+  try {
+    console.log("[Claude Dev Server] Turbopack lookup for page:", pagePath);
+    const pageRes = await fetch(`http://localhost:${targetPort}${pagePath}`);
+    if (!pageRes.ok) {
+      return { error: "Failed to fetch page" };
+    }
+    const html = await pageRes.text();
+    const chunkUrls = [];
+    const scriptMatches = html.matchAll(/<script[^>]*src="([^"]*\/_next\/static\/chunks\/[^"]*)"/g);
+    for (const match of scriptMatches) {
+      if (match[1]) {
+        chunkUrls.push(match[1]);
+      }
+    }
+    console.log("[Claude Dev Server] Found", chunkUrls.length, "chunk URLs");
+    for (const chunkUrl of chunkUrls) {
+      try {
+        const fullUrl = chunkUrl.startsWith("http") ? chunkUrl : `http://localhost:${targetPort}${chunkUrl}`;
+        const chunkRes = await fetch(fullUrl);
+        if (!chunkRes.ok) continue;
+        const chunkContent = await chunkRes.text();
+        const modulePathRegex = /\[project\]([^\s"]+\.(tsx?|jsx?))/g;
+        const matches = [...chunkContent.matchAll(modulePathRegex)];
+        for (const match of matches) {
+          if (match[1]) {
+            const sourcePath = match[1];
+            let relativePath = sourcePath.replace(/^\[project\]/, "");
+            const normalizedPagePath = pagePath.replace(/^\/[^/]+/, "");
+            if (relativePath.toLowerCase().includes(normalizedPagePath.toLowerCase()) || relativePath.toLowerCase().includes("login")) {
+              console.log("[Claude Dev Server] Found source file:", relativePath);
+              return {
+                file: relativePath,
+                line: void 0
+                // Turbopack doesn't provide line numbers
+              };
+            }
+          }
+        }
+      } catch (e) {
+        console.log("[Claude Dev Server] Error fetching chunk:", chunkUrl, e);
+      }
+    }
+    return { error: "Source file not found for page: " + pagePath };
+  } catch (err) {
+    console.error("[Claude Dev Server] Turbopack lookup error:", err);
+    return { error: String(err) };
+  }
+}
+function isHtmlPageRequest(req) {
+  const accept = req.headers.accept || "";
+  const url = req.url || "";
+  if (!accept.includes("text/html")) {
+    return false;
+  }
+  if (url.startsWith("/@") || url.startsWith("/_next/") || url.startsWith("/ttyd") || url.startsWith("/dev.html")) {
+    return false;
+  }
+  return true;
+}
+function createProxyServer(targetPort, wsPort, projectRoot) {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const assetsPath = join(moduleDir, "assets");
+  let ttydHtml;
+  let ttydBridgeJs;
+  let devHtml;
+  try {
+    ttydHtml = readFileSync(join(assetsPath, "ttyd-terminal.html"), "utf-8");
+    ttydBridgeJs = readFileSync(join(assetsPath, "ttyd-bridge.js"), "utf-8");
+    devHtml = readFileSync(join(assetsPath, "dev.html"), "utf-8");
+  } catch (e) {
+    console.error("[Claude Dev Server] Failed to read assets from", assetsPath);
+    console.error("[Claude Dev Server] moduleDir:", moduleDir);
+    console.error("[Claude Dev Server] Error:", e.message);
+    throw new Error("Assets not found. Please run `npm run build` first.");
+  }
+  const server = http.createServer((req, res) => {
+    const referer = req.headers.referer || "";
+    const isFromDevPage = referer.includes("dev.html");
+    if (req.url?.startsWith("/dev.html")) {
+      const urlParams = new URL(req.url || "", `http://${req.headers.host}`);
+      const originalPath = urlParams.searchParams.get("path") || "/";
+      const host = req.headers.host || "localhost:3000";
+      const origin = `http://${host}`;
+      const modifiedDevHtml = devHtml.replace(
+        /__CLAUDE_IFRAME_SRC__/g,
+        `${origin}${originalPath}`
+      ).replace(
+        /__CLAUDE_ORIGINAL_PATH__/g,
+        originalPath
+      );
+      res.setHeader("Content-Type", "text/html");
+      res.end(modifiedDevHtml);
+      return;
+    }
+    if (!isFromDevPage && isHtmlPageRequest(req)) {
+      const currentPath = req.url || "/";
+      const devPageUrl = `/dev.html?path=${encodeURIComponent(currentPath)}`;
+      res.writeHead(302, { "Location": devPageUrl });
+      res.end();
+      return;
+    }
+    if (req.url === "/@claude-port") {
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ port: wsPort }));
+      return;
+    }
+    if (req.url?.startsWith("/@sourcemap?")) {
+      const url = new URL(req.url, `http://localhost:${wsPort}`);
+      const file = url.searchParams.get("file");
+      const line = url.searchParams.get("line");
+      const column = url.searchParams.get("col");
+      if (file && line && column) {
+        handleSourceMapRequest(projectRoot, file, parseInt(line), parseInt(column || "1"), targetPort).then((result) => {
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(result));
+        }).catch((err) => {
+          console.error("[Claude Dev Server] Source map error:", err);
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: err.message }));
+        });
+        return;
+      }
+    }
+    if (req.url?.startsWith("/@sourcemap-lookup?")) {
+      const url = new URL(req.url, `http://localhost:${wsPort}`);
+      const page = url.searchParams.get("page");
+      const framework = url.searchParams.get("framework");
+      if (page && framework === "nextjs") {
+        handleTurbopackLookup(projectRoot, page, targetPort).then((result) => {
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(result));
+        }).catch((err) => {
+          console.error("[Claude Dev Server] Turbopack lookup error:", err);
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: err.message }));
+        });
+        return;
+      }
+    }
+    if (req.url?.startsWith("/ttyd/")) {
+      const urlPath = req.url.split("?")[0];
+      if (urlPath === "/ttyd/index.html" || urlPath === "/ttyd/") {
+        res.setHeader("Content-Type", "text/html");
+        res.end(ttydHtml);
+        return;
+      }
+      if (urlPath === "/ttyd/ttyd-bridge.js") {
+        res.setHeader("Content-Type", "application/javascript");
+        res.end(ttydBridgeJs);
+        return;
+      }
+      if (urlPath === "/ttyd/token" || urlPath === "/ttyd/index.html/token") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ token: "" }));
+        return;
+      }
+      res.statusCode = 404;
+      res.end("Not found");
+      return;
+    }
+    const proxyHeaders = { ...req.headers };
+    delete proxyHeaders["accept-encoding"];
+    const options = {
+      hostname: "localhost",
+      port: targetPort,
+      path: req.url,
+      method: req.method,
+      headers: proxyHeaders
+    };
+    const proxyReq = http.request(options, (proxyRes) => {
+      const statusCode = proxyRes.statusCode || 200;
+      res.writeHead(statusCode, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+    proxyReq.on("error", (err) => {
+      console.error("[Claude Dev Server] Proxy error:", err);
+      res.statusCode = 502;
+      res.end("Bad Gateway");
+    });
+    req.pipe(proxyReq);
+  });
+  server.on("upgrade", (req, socket, head) => {
+    if (req.headers["upgrade"]?.toLowerCase() !== "websocket") {
+      return;
+    }
+    console.log("[Claude Dev Server] WebSocket upgrade request:", req.url);
+    const targetSocket = createConnection(targetPort, "localhost", () => {
+      console.log("[Claude Dev Server] Connected to target WebSocket server");
+      const upgradeRequest = [
+        `${req.method} ${req.url} HTTP/1.1`,
+        `Host: localhost:${targetPort}`,
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Key: ${req.headers["sec-websocket-key"]}`,
+        `Sec-WebSocket-Version: ${req.headers["sec-websocket-version"] || "13"}`
+      ];
+      if (req.headers["sec-websocket-protocol"]) {
+        upgradeRequest.push(`Sec-WebSocket-Protocol: ${req.headers["sec-websocket-protocol"]}`);
+      }
+      if (req.headers["sec-websocket-extensions"]) {
+        upgradeRequest.push(`Sec-WebSocket-Extensions: ${req.headers["sec-websocket-extensions"]}`);
+      }
+      targetSocket.write(upgradeRequest.join("\r\n") + "\r\n\r\n");
+      if (head && head.length > 0) {
+        targetSocket.write(head);
+      }
+    });
+    targetSocket.on("data", (data) => {
+      if (socket.writable) {
+        socket.write(data);
+      }
+    });
+    socket.on("data", (data) => {
+      if (targetSocket.writable) {
+        targetSocket.write(data);
+      }
+    });
+    socket.on("close", () => {
+      console.log("[Claude Dev Server] Client WebSocket closed");
+      targetSocket.destroy();
+    });
+    targetSocket.on("close", () => {
+      console.log("[Claude Dev Server] Target WebSocket closed");
+      socket.end();
+    });
+    socket.on("error", (err) => {
+      console.error("[Claude Dev Server] Client socket error:", err.message);
+      targetSocket.destroy();
+    });
+    targetSocket.on("error", (err) => {
+      console.error("[Claude Dev Server] Target socket error:", err.message);
+      socket.end();
+    });
+  });
+  return server;
+}
+
+export { startUniversalServer };
+//# sourceMappingURL=chunk-EEXRIRSF.js.map
+//# sourceMappingURL=chunk-EEXRIRSF.js.map