@lark-apaas/devtool-kits 1.0.5-alpha.3 → 1.0.5-alpha.5

package/dist/error.html

@@ -108,6 +108,7 @@
 
   <script>
     // 全局错误对象
+    let clientBasePath = '{{.clientBasePath}}';
     let errorData = {
       message: `{{.errorData.message}}`,
     };
@@ -159,71 +160,60 @@
     // 探测服务是否恢复
     async function probeService() {
       try {
-        // 获取当前 URL
-        const currentUrl = window.location.pathname + window.location.search;
-
-        console.log('[Probe] 探测服务状态:', currentUrl);
+        console.log('[Probe] 探测服务状态: /dev/health');
 
         // 使用 AbortController 实现超时控制
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT);
 
-        const response = await fetch(currentUrl, {
-          method: 'GET', // 使用 GET 而不是 HEAD，获取完整响应
+        const response = await fetch(`${clientBasePath}/dev/health`, {
+          method: 'GET',
           cache: 'no-cache',
-          redirect: 'manual', // 不自动跟随重定向，避免无限循环
-          signal: controller.signal,
-          headers: {
-            'X-Health-Check': 'true' // 标识这是健康检查请求
-          }
+          redirect: 'manual', // 不自动跟随重定向
+          signal: controller.signal
         });
 
         clearTimeout(timeoutId);
 
-        // 检查响应状态和响应头
-        const contentType = response.headers.get('content-type') || '';
-        const isErrorPage = response.headers.get('x-proxy-error-page') === 'true';
+        console.log('[Probe] 状态码:', response.status);
 
-        console.log('[Probe] 状态码:', response.status, 'Content-Type:', contentType, '是否错误页面:', isErrorPage);
-
-        // 如果收到 302/303 重定向，说明服务正在恢复中，继续探测
+        // 如果收到 302/303 重定向，说明代理层正在恢复中，继续探测
         if (response.status === 302 || response.status === 303) {
           console.log('[Probe] 收到重定向响应，服务可能正在恢复，继续探测');
           return;
         }
 
-        // 如果是 502 或明确标记为错误页面，继续探测
-        if (response.status === 502 || isErrorPage) {
-          console.log('[Probe] 服务未恢复，继续探测');
+        // 如果是 502，说明代理遇到错误，继续探测
+        if (response.status === 502) {
+          console.log('[Probe] 服务未恢复（502），继续探测');
           return;
         }
 
-        // 如果是 200，需要进一步验证不是错误页面
+        // 如果是 200，解析健康检查结果
         if (response.status === 200) {
-          // 检查响应头是否明确标记为错误页面
-          if (isErrorPage) {
-            console.log('[Probe] 收到 200 但是错误页面，继续探测');
-            return;
-          }
-
-          // 读取响应文本，检查是否包含错误页面的特征
-          const text = await response.text();
-
-          // 检查是否是当前的错误页面（通过检查特定的标识字符串）
-          if (text.includes('哎呀，写错代码了') || text.includes('X-Proxy-Error-Page')) {
-            console.log('[Probe] 响应内容包含错误页面标识，继续探测');
-            return;
+          try {
+            const data = await response.json();
+
+            // 检查健康状态
+            if (data.status === 'healthy') {
+              console.log('[Probe] 服务已恢复，响应时间:', data.responseTime, 'ms');
+              stopServiceProbe();
+
+              // 延迟一小段时间后刷新，让日志输出完整
+              setTimeout(() => {
+                console.log('[Probe] 刷新页面...');
+                const currentUrl = window.location.pathname + window.location.search;
+                window.location.href = currentUrl;
+              }, 300);
+            } else {
+              console.log('[Probe] 服务状态:', data.status, '错误:', data.error);
+            }
+          } catch (e) {
+            console.log('[Probe] 解析响应失败:', e.message, '继续探测');
           }
-
-          // 通过所有检查，认为服务真正恢复
-          console.log('[Probe] 服务已恢复，准备刷新页面');
-          stopServiceProbe();
-
-          // 延迟一小段时间后刷新，让日志输出完整
-          setTimeout(() => {
-            console.log('[Probe] 刷新页面...');
-            window.location.href = currentUrl;
-          }, 300);
+        } else if (response.status === 503) {
+          // 503 表示服务不健康，继续探测
+          console.log('[Probe] 服务不健康（503），继续探测');
         } else {
           console.log('[Probe] 收到非预期状态码:', response.status, '继续探测');
         }

package/dist/index.cjs

@@ -22320,10 +22320,10 @@ var require_layer = __commonJS({
 var require_methods = __commonJS({
   "../../../node_modules/methods/index.js"(exports2, module2) {
     "use strict";
-    var http2 = require("http");
+    var http3 = require("http");
     module2.exports = getCurrentNodeMethods() || getBasicNodeMethods();
     function getCurrentNodeMethods() {
-      return http2.METHODS && http2.METHODS.map(/* @__PURE__ */ __name(function lowerCaseMethod(method) {
+      return http3.METHODS && http3.METHODS.map(/* @__PURE__ */ __name(function lowerCaseMethod(method) {
         return method.toLowerCase();
       }, "lowerCaseMethod"));
     }
@@ -25995,13 +25995,13 @@ var require_application = __commonJS({
   "../../../node_modules/express/lib/application.js"(exports2, module2) {
     "use strict";
     var finalhandler = require_finalhandler();
-    var Router = require_router();
+    var Router2 = require_router();
     var methods = require_methods();
     var middleware = require_init();
     var query = require_query();
     var debug = require_src3()("express:application");
     var View = require_view();
-    var http2 = require("http");
+    var http3 = require("http");
     var compileETag = require_utils2().compileETag;
     var compileQueryParser = require_utils2().compileQueryParser;
     var compileTrust = require_utils2().compileTrust;
@@ -26060,7 +26060,7 @@ var require_application = __commonJS({
     }, "defaultConfiguration");
     app.lazyrouter = /* @__PURE__ */ __name(function lazyrouter() {
       if (!this._router) {
-        this._router = new Router({
+        this._router = new Router2({
           caseSensitive: this.enabled("case sensitive routing"),
           strict: this.enabled("strict routing")
         });
@@ -26250,7 +26250,7 @@ var require_application = __commonJS({
       tryRender(view, renderOptions, done);
     }, "render");
     app.listen = /* @__PURE__ */ __name(function listen() {
-      var server = http2.createServer(this);
+      var server = http3.createServer(this);
       return server.listen.apply(server, arguments);
     }, "listen");
     function logerror(err) {
@@ -26913,12 +26913,12 @@ var require_request = __commonJS({
     var deprecate = require_depd()("express");
     var isIP = require("net").isIP;
     var typeis = require_type_is();
-    var http2 = require("http");
+    var http3 = require("http");
     var fresh = require_fresh();
     var parseRange = require_range_parser();
     var parse = require_parseurl();
     var proxyaddr = require_proxy_addr();
-    var req = Object.create(http2.IncomingMessage.prototype);
+    var req = Object.create(http3.IncomingMessage.prototype);
     module2.exports = req;
     req.get = req.header = /* @__PURE__ */ __name(function header(name) {
       if (!name) {
@@ -27344,7 +27344,7 @@ var require_response = __commonJS({
     var deprecate = require_depd()("express");
     var encodeUrl = require_encodeurl();
     var escapeHtml = require_escape_html();
-    var http2 = require("http");
+    var http3 = require("http");
     var isAbsolute3 = require_utils2().isAbsolute;
     var onFinished = require_on_finished();
     var path6 = require("path");
@@ -27360,7 +27360,7 @@ var require_response = __commonJS({
     var mime = send.mime;
     var resolve = path6.resolve;
     var vary = require_vary();
-    var res = Object.create(http2.ServerResponse.prototype);
+    var res = Object.create(http3.ServerResponse.prototype);
     module2.exports = res;
     var charsetRegExp = /;\s*charset\s*=/;
     res.status = /* @__PURE__ */ __name(function status(code) {
@@ -28009,7 +28009,7 @@ var require_express = __commonJS({
     var mixin = require_merge_descriptors();
     var proto = require_application();
     var Route = require_route();
-    var Router = require_router();
+    var Router2 = require_router();
     var req = require_request();
     var res = require_response();
     exports2 = module2.exports = createApplication;
@@ -28043,7 +28043,7 @@ var require_express = __commonJS({
     exports2.request = req;
     exports2.response = res;
     exports2.Route = Route;
-    exports2.Router = Router;
+    exports2.Router = Router2;
     exports2.json = bodyParser.json;
     exports2.query = require_query();
     exports2.raw = bodyParser.raw;
@@ -28093,6 +28093,7 @@ var index_exports = {};
 __export(index_exports, {
   createCollectLogsMiddleware: () => createCollectLogsMiddleware,
   createDevLogsMiddleware: () => createDevLogsMiddleware,
+  createHealthCheckMiddleware: () => createHealthCheckMiddleware,
   createOpenapiMiddleware: () => createOpenapiMiddleware,
   handleDevProxyError: () => handleDevProxyError,
   normalizeBasePath: () => normalizeBasePath,
@@ -28405,8 +28406,6 @@ __name(collapseExtraBlankLines, "collapseExtraBlankLines");
 // src/helpers/proxy-error/index.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
-var import_node_fs3 = require("fs");
-var import_node_readline = require("readline");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_https = __toESM(require("https"), 1);
 var errorHtmlTemplate = null;
@@ -28482,63 +28481,82 @@ function parseLogLine(line) {
   if (!trimmed) return null;
   const match = trimmed.match(/^\[\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\]\s+\[server\]\s+(.*)$/);
   if (match) {
-    return match[1];
+    const content = match[1].trim();
+    return content || null;
   }
-  return trimmed;
+  return null;
 }
 __name(parseLogLine, "parseLogLine");
 async function readRecentErrorLogs(logDir, maxLogs, fileName) {
   const logFilePath = import_node_path2.default.join(logDir, fileName);
+  let fileStats;
   try {
-    await import_node_fs2.default.promises.access(logFilePath);
+    fileStats = await import_node_fs2.default.promises.stat(logFilePath);
   } catch {
     return {
       logs: [],
       hasCompileError: false
     };
   }
-  const allLines = [];
-  const stream = (0, import_node_fs3.createReadStream)(logFilePath, {
-    encoding: "utf8"
-  });
-  const rl = (0, import_node_readline.createInterface)({
-    input: stream,
-    crlfDelay: Infinity
-  });
+  const fileSize = fileStats.size;
+  const maxReadSize = 1024 * 1024;
+  const readSize = Math.min(fileSize, maxReadSize);
+  const startPosition = Math.max(0, fileSize - readSize);
+  const buffer = Buffer.allocUnsafe(readSize);
+  let fileHandle;
   try {
-    for await (const line of rl) {
-      const parsed = parseLogLine(line);
-      if (parsed !== null) {
-        allLines.push(parsed);
-      }
-    }
+    fileHandle = await import_node_fs2.default.promises.open(logFilePath, "r");
+    await fileHandle.read(buffer, 0, readSize, startPosition);
+  } catch (error) {
+    console.error("[Proxy Error]: Failed to read log file:", error);
+    return {
+      logs: [],
+      hasCompileError: false
+    };
   } finally {
-    rl.close();
-    stream.destroy();
+    if (fileHandle) {
+      await fileHandle.close();
+    }
+  }
+  const content = buffer.toString("utf8");
+  const lines = content.split("\n");
+  if (startPosition > 0 && lines.length > 0) {
+    lines.shift();
+  }
+  const allLines = [];
+  for (const line of lines) {
+    const parsed = parseLogLine(line);
+    if (parsed !== null) {
+      allLines.push(parsed);
+    }
   }
   let startIndex = -1;
   for (let i = allLines.length - 1; i >= 0; i--) {
-    if (allLines[i].includes("dev:server")) {
+    const line = allLines[i];
+    if (line.includes("Starting compilation in watch mode") || line.includes("File change detected. Starting incremental compilation")) {
       startIndex = i;
       break;
     }
   }
   if (startIndex === -1) {
+    console.log("[Proxy Error]: No compilation start marker found, returning last logs");
+    const fallbackLogs = allLines.slice(-maxLogs);
+    const hasCompileError2 = checkForErrors(fallbackLogs);
     return {
-      logs: [],
-      hasCompileError: false
+      logs: fallbackLogs,
+      hasCompileError: hasCompileError2
     };
   }
   let endIndex = allLines.length;
-  let hasCompileError = false;
-  for (let i = startIndex; i < allLines.length; i++) {
-    if (/Found \d+ errors?\./.test(allLines[i])) {
-      endIndex = i + 1;
-      hasCompileError = true;
+  for (let i = startIndex + 1; i < allLines.length; i++) {
+    const line = allLines[i];
+    if (line.includes("Starting compilation in watch mode") || line.includes("File change detected. Starting incremental compilation")) {
+      endIndex = i;
       break;
     }
   }
   const errorSection = allLines.slice(startIndex, endIndex);
+  const hasCompileError = checkForErrors(errorSection);
   const logs = errorSection.length > maxLogs ? errorSection.slice(-maxLogs) : errorSection;
   return {
     logs,
@@ -28546,7 +28564,21 @@ async function readRecentErrorLogs(logDir, maxLogs, fileName) {
   };
 }
 __name(readRecentErrorLogs, "readRecentErrorLogs");
-function injectErrorData(template, errorLogs) {
+function checkForErrors(logs) {
+  for (const line of logs) {
+    const compileErrorMatch = line.match(/Found (\d+) errors?\. Watching for file changes/);
+    if (compileErrorMatch) {
+      const errorCount = parseInt(compileErrorMatch[1], 10);
+      if (errorCount > 0) {
+        console.log(`[Proxy Error]: Found ${errorCount} compilation error(s)`);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(checkForErrors, "checkForErrors");
+function injectErrorData(template, errorLogs, clientBasePath) {
   let logsText = "";
   if (errorLogs.length > 0) {
     logsText = errorLogs.join("\n");
@@ -28554,11 +28586,12 @@ function injectErrorData(template, errorLogs) {
     logsText = "\u672A\u627E\u5230\u76F8\u5173\u9519\u8BEF\u65E5\u5FD7";
   }
   return template.replace("{{.errorData.message}}", `\u670D\u52A1\u542F\u52A8\u5F02\u5E38\uFF0C\u8BF7\u6839\u636E\u65E5\u5FD7\u4FEE\u590D\u76F8\u5173\u95EE\u9898
- ${JSON.stringify(logsText)}`);
+ ${JSON.stringify(logsText)}`).replace("{{.clientBasePath}}", clientBasePath);
 }
 __name(injectErrorData, "injectErrorData");
 function handleDevProxyError(err, req, res, options) {
-  const { logDir = import_node_path2.default.join(process.cwd(), "logs"), maxErrorLogs = 100, logFileName = "server.log", retryTimeout = 5e3, retryInterval = 500, target } = options || {};
+  const { logDir = import_node_path2.default.join(process.cwd(), "logs"), maxErrorLogs = 100, logFileName = "server.log", retryTimeout = 5e3, retryInterval = 500, target, clientBasePath = process.env.CLIENT_BASE_PATH || "/" } = options || {};
+  const clientBasePathWithoutSlash = normalizeBasePath(clientBasePath);
   console.error("[Proxy Error]:", err.message);
   if (res.headersSent) {
     console.error("[Proxy Error]: Headers already sent, cannot send error page");
@@ -28591,7 +28624,7 @@ function handleDevProxyError(err, req, res, options) {
         console.log("[Proxy Error]: Compile error or non-connection error, showing error page");
       }
       const template = getErrorHtmlTemplate();
-      const html = injectErrorData(template, errorLogs);
+      const html = injectErrorData(template, errorLogs, clientBasePathWithoutSlash);
       res.writeHead(502, {
         "Content-Type": "text/html; charset=utf-8",
         "Cache-Control": "no-cache, no-store, must-revalidate",
@@ -28625,25 +28658,116 @@ __name(sendSimpleRedirect, "sendSimpleRedirect");
 // src/middlewares/index.ts
 var import_node_path8 = __toESM(require("path"), 1);
 
-// src/middlewares/openapi/router.ts
+// src/middlewares/health-check/router.ts
 var import_express = __toESM(require_express2(), 1);
+var import_node_http2 = __toESM(require("http"), 1);
+function checkServiceHealth(host, port, timeout) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const req = import_node_http2.default.request({
+      hostname: host,
+      port,
+      path: "/",
+      method: "HEAD",
+      timeout
+    }, (_res) => {
+      const responseTime = Date.now() - startTime;
+      resolve({
+        available: true,
+        responseTime
+      });
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({
+        available: false,
+        error: "Request timeout"
+      });
+    });
+    req.on("error", (err) => {
+      resolve({
+        available: false,
+        error: err.message
+      });
+    });
+    req.end();
+  });
+}
+__name(checkServiceHealth, "checkServiceHealth");
+function createHealthCheckRouter(options = {}) {
+  const { targetPort = Number(process.env.SERVER_PORT) || 3e3, targetHost = "localhost", timeout = 2e3 } = options;
+  const router = (0, import_express.Router)();
+  router.get("/", async (_req, res) => {
+    try {
+      const result = await checkServiceHealth(targetHost, targetPort, timeout);
+      if (result.available) {
+        res.status(200).json({
+          status: "healthy",
+          service: `${targetHost}:${targetPort}`,
+          responseTime: result.responseTime,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else {
+        res.status(503).json({
+          status: "unhealthy",
+          service: `${targetHost}:${targetPort}`,
+          error: result.error,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    } catch (error) {
+      res.status(500).json({
+        status: "error",
+        service: `${targetHost}:${targetPort}`,
+        error: error instanceof Error ? error.message : "Unknown error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  });
+  return router;
+}
+__name(createHealthCheckRouter, "createHealthCheckRouter");
+
+// src/middlewares/health-check/index.ts
+var HEALTH_CHECK_ROUTES = [
+  {
+    method: "GET",
+    path: "/",
+    description: "Check if target service is healthy and available"
+  }
+];
+function createHealthCheckMiddleware(options = {}) {
+  return {
+    name: "health-check",
+    mountPath: "/dev/health",
+    routes: HEALTH_CHECK_ROUTES,
+    enabled: /* @__PURE__ */ __name((context) => context.isDev, "enabled"),
+    createRouter: /* @__PURE__ */ __name((_context) => {
+      return createHealthCheckRouter(options);
+    }, "createRouter")
+  };
+}
+__name(createHealthCheckMiddleware, "createHealthCheckMiddleware");
+
+// src/middlewares/openapi/router.ts
+var import_express2 = __toESM(require_express2(), 1);
 
 // src/middlewares/openapi/controller.ts
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_node_crypto = __toESM(require("crypto"), 1);
 
 // src/middlewares/openapi/services.ts
-var import_node_fs5 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path4 = __toESM(require("path"), 1);
 var import_typescript = __toESM(require("typescript"), 1);
 
 // src/middlewares/openapi/utils.ts
 var import_node_path3 = __toESM(require("path"), 1);
-var import_node_fs4 = require("fs");
+var import_node_fs3 = require("fs");
 async function findControllerFiles(dir) {
   const files = [];
   async function scan(currentDir) {
-    const entries = await import_node_fs4.promises.readdir(currentDir, {
+    const entries = await import_node_fs3.promises.readdir(currentDir, {
       withFileTypes: true
     });
     for (const entry of entries) {
@@ -28727,14 +28851,14 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
   if (options.openapiData) {
     openapi = JSON.parse(JSON.stringify(options.openapiData));
   } else {
-    const openapiContent = await import_node_fs5.promises.readFile(openapiPath, "utf-8");
+    const openapiContent = await import_node_fs4.promises.readFile(openapiPath, "utf-8");
     openapi = JSON.parse(openapiContent);
   }
   const controllerFiles = await findControllerFiles(serverDir);
   const sourceMap = await buildSourceMap(controllerFiles, processControllerFile);
   const enhanced = enhanceOpenApiPaths(openapi, sourceMap);
   if (writeFile) {
-    await import_node_fs5.promises.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
+    await import_node_fs4.promises.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
   }
   const duration = Date.now() - startTime;
   return {
@@ -28750,7 +28874,7 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
 __name(enhanceOpenApiWithSourceInfo, "enhanceOpenApiWithSourceInfo");
 async function processControllerFile(filePath) {
   const relativePath = import_node_path4.default.relative(process.cwd(), filePath);
-  const content = await import_node_fs5.promises.readFile(filePath, "utf-8");
+  const content = await import_node_fs4.promises.readFile(filePath, "utf-8");
   const sourceFile = import_typescript.default.createSourceFile(filePath, content, import_typescript.default.ScriptTarget.Latest, true);
   return extractControllerMetadata(sourceFile, relativePath);
 }
@@ -28873,7 +28997,7 @@ __name(createOpenapiHandler, "createOpenapiHandler");
 // src/middlewares/openapi/router.ts
 function createOpenapiRouter(options, context) {
   const { openapiFilePath, enableEnhancement, serverDir } = options;
-  const router = import_express.default.Router();
+  const router = import_express2.default.Router();
   const handler = createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir);
   router.get("/openapi.json", (req, res) => handler(req, res, context));
   return router;
@@ -28907,10 +29031,10 @@ function createOpenapiMiddleware(options) {
 __name(createOpenapiMiddleware, "createOpenapiMiddleware");
 
 // src/middlewares/dev-logs/router.ts
-var import_express2 = __toESM(require_express2(), 1);
+var import_express3 = __toESM(require_express2(), 1);
 
 // src/middlewares/dev-logs/utils.ts
-var import_node_fs6 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_path5 = require("path");
 
 // src/middlewares/dev-logs/helper/path-matcher.ts
@@ -28962,7 +29086,7 @@ function getRelativePath(filePath) {
 __name(getRelativePath, "getRelativePath");
 async function fileExists(filePath) {
   try {
-    await import_node_fs6.promises.access(filePath);
+    await import_node_fs5.promises.access(filePath);
     return true;
   } catch {
     return false;
@@ -29045,18 +29169,18 @@ __name(serializeError, "serializeError");
 var import_node_path6 = require("path");
 
 // src/middlewares/dev-logs/services.ts
-var import_node_fs7 = require("fs");
-var import_node_readline2 = require("readline");
+var import_node_fs6 = require("fs");
+var import_node_readline = require("readline");
 async function readLogEntriesByTrace(filePath, traceId, limit) {
   const exists = await fileExists(filePath);
   if (!exists) {
     return void 0;
   }
   const matches = [];
-  const stream = (0, import_node_fs7.createReadStream)(filePath, {
+  const stream = (0, import_node_fs6.createReadStream)(filePath, {
     encoding: "utf8"
   });
-  const rl = (0, import_node_readline2.createInterface)({
+  const rl = (0, import_node_readline.createInterface)({
     input: stream,
     crlfDelay: Infinity
   });
@@ -29145,7 +29269,7 @@ async function readRecentTraceCalls(filePath, page, pageSize, pathFilter, method
 }
 __name(readRecentTraceCalls, "readRecentTraceCalls");
 async function readFileReverse(filePath, chunkSize, processLine) {
-  const handle = await import_node_fs7.promises.open(filePath, "r");
+  const handle = await import_node_fs6.promises.open(filePath, "r");
   try {
     const stats = await handle.stat();
     let position = stats.size;
@@ -29207,10 +29331,10 @@ async function readLogFilePage(filePath, page, pageSize) {
   const capacity = page * pageSize;
   const buffer = [];
   let totalLines = 0;
-  const stream = (0, import_node_fs7.createReadStream)(filePath, {
+  const stream = (0, import_node_fs6.createReadStream)(filePath, {
     encoding: "utf8"
   });
-  const rl = (0, import_node_readline2.createInterface)({
+  const rl = (0, import_node_readline.createInterface)({
     input: stream,
     crlfDelay: Infinity
   });
@@ -29352,7 +29476,7 @@ __name(createGetLogFileHandler, "createGetLogFileHandler");
 // src/middlewares/dev-logs/router.ts
 function createDevLogRouter(options = {}) {
   const logDir = resolveLogDir(options.logDir);
-  const router = import_express2.default.Router();
+  const router = import_express3.default.Router();
   router.get("/app/trace/:traceId", createGetTraceEntriesHandler(logDir));
   router.get("/trace/recent", createGetRecentTracesHandler(logDir));
   router.get("/files/:fileName", createGetLogFileHandler(logDir));
@@ -29395,7 +29519,7 @@ function createDevLogsMiddleware(options = {}) {
 __name(createDevLogsMiddleware, "createDevLogsMiddleware");
 
 // src/middlewares/collect-logs/router.ts
-var import_express3 = __toESM(require_express2(), 1);
+var import_express4 = __toESM(require_express2(), 1);
 
 // src/middlewares/collect-logs/controller.ts
 var import_path = require("path");
@@ -29403,7 +29527,7 @@ var import_fs = __toESM(require("fs"), 1);
 
 // src/middlewares/collect-logs/utils.ts
 var import_node_path7 = require("path");
-var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
 function resolveLogDir2(provided) {
   if (!provided) {
     return (0, import_node_path7.join)(process.cwd(), "logs");
@@ -29412,8 +29536,8 @@ function resolveLogDir2(provided) {
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
-  if (!import_node_fs8.default.existsSync(dir)) {
-    import_node_fs8.default.mkdirSync(dir, {
+  if (!import_node_fs7.default.existsSync(dir)) {
+    import_node_fs7.default.mkdirSync(dir, {
       recursive: true
     });
   }
@@ -29494,9 +29618,9 @@ __name(handleError2, "handleError");
 // src/middlewares/collect-logs/router.ts
 function createDevLogRouter2(options = {}) {
   const logDir = resolveLogDir2(options.logDir);
-  const router = import_express3.default.Router();
-  router.post("/collect", import_express3.default.json(), collectLogsHandler(logDir, options.fileName || "client.log"));
-  router.post("/collect-batch", import_express3.default.json(), collectLogsBatchHandler(logDir, options.fileName || "client.log"));
+  const router = import_express4.default.Router();
+  router.post("/collect", import_express4.default.json(), collectLogsHandler(logDir, options.fileName || "client.log"));
+  router.post("/collect-batch", import_express4.default.json(), collectLogsBatchHandler(logDir, options.fileName || "client.log"));
   return router;
 }
 __name(createDevLogRouter2, "createDevLogRouter");
@@ -29579,7 +29703,15 @@ async function registerMiddlewares(server, middlewares, options) {
     rootDir: process.cwd(),
     ...options
   };
-  for (const middleware of middlewares) {
+  const defaultMiddlewares = [];
+  if (context.isDev) {
+    defaultMiddlewares.push(createHealthCheckMiddleware());
+  }
+  const allMiddlewares = [
+    ...defaultMiddlewares,
+    ...middlewares
+  ];
+  for (const middleware of allMiddlewares) {
     if (middleware.enabled && !middleware.enabled(context)) {
       continue;
     }
@@ -29606,6 +29738,7 @@ __name(registerMiddlewares, "registerMiddlewares");
 0 && (module.exports = {
   createCollectLogsMiddleware,
   createDevLogsMiddleware,
+  createHealthCheckMiddleware,
   createOpenapiMiddleware,
   handleDevProxyError,
   normalizeBasePath,