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

package/dist/error.html

@@ -160,13 +160,13 @@
     // 探测服务是否恢复
     async function probeService() {
       try {
-        console.log('[Probe] 探测服务状态: /dev/health/check');
+        console.log('[Probe] 探测服务状态: /dev/logs/health');
 
         // 使用 AbortController 实现超时控制
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT);
 
-        const response = await fetch(`${clientBasePath}/dev/health/check`, {
+        const response = await fetch(`${clientBasePath}/dev/logs/health`, {
           method: 'GET',
           cache: 'no-cache',
           redirect: 'manual', // 不自动跟随重定向

package/dist/index.cjs

@@ -28093,7 +28093,6 @@ var index_exports = {};
 __export(index_exports, {
   createCollectLogsMiddleware: () => createCollectLogsMiddleware,
   createDevLogsMiddleware: () => createDevLogsMiddleware,
-  createHealthCheckMiddleware: () => createHealthCheckMiddleware,
   createOpenapiMiddleware: () => createOpenapiMiddleware,
   handleDevProxyError: () => handleDevProxyError,
   normalizeBasePath: () => normalizeBasePath,
@@ -28658,99 +28657,8 @@ __name(sendSimpleRedirect, "sendSimpleRedirect");
 // src/middlewares/index.ts
 var import_node_path8 = __toESM(require("path"), 1);
 
-// 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 = import_express.default.Router();
-  router.get("/check", 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: "/check",
-    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);
+var import_express = __toESM(require_express2(), 1);
 
 // src/middlewares/openapi/controller.ts
 var import_promises = __toESM(require("fs/promises"), 1);
@@ -28997,7 +28905,7 @@ __name(createOpenapiHandler, "createOpenapiHandler");
 // src/middlewares/openapi/router.ts
 function createOpenapiRouter(options, context) {
   const { openapiFilePath, enableEnhancement, serverDir } = options;
-  const router = import_express2.default.Router();
+  const router = import_express.default.Router();
   const handler = createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir);
   router.get("/openapi.json", (req, res) => handler(req, res, context));
   return router;
@@ -29016,7 +28924,7 @@ function createOpenapiMiddleware(options) {
   const { openapiFilePath, enableEnhancement = true, serverDir } = options;
   return {
     name: "openapi",
-    mountPath: "/dev/openapi.json",
+    mountPath: "/dev",
     routes: OPENAPI_ROUTES,
     enabled: /* @__PURE__ */ __name((context) => context.isDev, "enabled"),
     createRouter: /* @__PURE__ */ __name((context) => {
@@ -29031,7 +28939,7 @@ function createOpenapiMiddleware(options) {
 __name(createOpenapiMiddleware, "createOpenapiMiddleware");
 
 // src/middlewares/dev-logs/router.ts
-var import_express3 = __toESM(require_express2(), 1);
+var import_express2 = __toESM(require_express2(), 1);
 
 // src/middlewares/dev-logs/utils.ts
 var import_node_fs5 = require("fs");
@@ -29473,13 +29381,81 @@ function createGetLogFileHandler(logDir) {
 }
 __name(createGetLogFileHandler, "createGetLogFileHandler");
 
+// src/middlewares/dev-logs/health.controller.ts
+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 createHealthCheckHandler(options = {}) {
+  const { targetPort = Number(process.env.SERVER_PORT) || 3e3, targetHost = "localhost", timeout = 2e3 } = options;
+  return 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()
+      });
+    }
+  };
+}
+__name(createHealthCheckHandler, "createHealthCheckHandler");
+
 // src/middlewares/dev-logs/router.ts
 function createDevLogRouter(options = {}) {
   const logDir = resolveLogDir(options.logDir);
-  const router = import_express3.default.Router();
+  const router = import_express2.default.Router();
   router.get("/app/trace/:traceId", createGetTraceEntriesHandler(logDir));
   router.get("/trace/recent", createGetRecentTracesHandler(logDir));
   router.get("/files/:fileName", createGetLogFileHandler(logDir));
+  router.get("/health", createHealthCheckHandler());
   return router;
 }
 __name(createDevLogRouter, "createDevLogRouter");
@@ -29519,7 +29495,7 @@ function createDevLogsMiddleware(options = {}) {
 __name(createDevLogsMiddleware, "createDevLogsMiddleware");
 
 // src/middlewares/collect-logs/router.ts
-var import_express4 = __toESM(require_express2(), 1);
+var import_express3 = __toESM(require_express2(), 1);
 
 // src/middlewares/collect-logs/controller.ts
 var import_path = require("path");
@@ -29618,9 +29594,9 @@ __name(handleError2, "handleError");
 // src/middlewares/collect-logs/router.ts
 function createDevLogRouter2(options = {}) {
   const logDir = resolveLogDir2(options.logDir);
-  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"));
+  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"));
   return router;
 }
 __name(createDevLogRouter2, "createDevLogRouter");
@@ -29683,18 +29659,7 @@ async function registerRouteMiddleware(server, middleware, context) {
   }
   const router = middleware.createRouter(context);
   const fullMountPath = computeMountPath(context.basePath, middleware.mountPath);
-  const wrappedRouter = /* @__PURE__ */ __name((req, res, next) => {
-    console.log(`[Middleware] ${middleware.name} received request: ${req.method} ${req.url}`);
-    router(req, res, (err) => {
-      if (err) {
-        console.log(`[Middleware] ${middleware.name} error:`, err);
-      } else {
-        console.log(`[Middleware] ${middleware.name} called next()`);
-      }
-      next(err);
-    });
-  }, "wrappedRouter");
-  server.use(fullMountPath, wrappedRouter);
+  server.use(fullMountPath, router);
   logMiddlewareRegistration(middleware, fullMountPath);
 }
 __name(registerRouteMiddleware, "registerRouteMiddleware");
@@ -29714,29 +29679,10 @@ async function registerMiddlewares(server, middlewares, options) {
     rootDir: process.cwd(),
     ...options
   };
-  const defaultMiddlewares = [
-    createHealthCheckMiddleware()
-  ];
   const allMiddlewares = [
-    ...middlewares,
-    ...defaultMiddlewares
+    ...middlewares
   ];
-  console.log(`[Middleware] Total middlewares to register: ${allMiddlewares.length}`);
-  allMiddlewares.forEach((m, i) => {
-    console.log(`[Middleware] [${i}] ${m.name} (mountPath: ${m.mountPath || "N/A"})`);
-  });
-  const seen = /* @__PURE__ */ new Set();
-  const uniqueMiddlewares = [];
   for (const middleware of allMiddlewares) {
-    if (!seen.has(middleware.name)) {
-      seen.add(middleware.name);
-      uniqueMiddlewares.push(middleware);
-    } else {
-      console.log(`[Middleware] Skipping duplicate: ${middleware.name}`);
-    }
-  }
-  console.log(`[Middleware] After deduplication: ${uniqueMiddlewares.length} middlewares`);
-  for (const middleware of uniqueMiddlewares) {
     if (middleware.enabled && !middleware.enabled(context)) {
       continue;
     }
@@ -29763,7 +29709,6 @@ __name(registerMiddlewares, "registerMiddlewares");
 0 && (module.exports = {
   createCollectLogsMiddleware,
   createDevLogsMiddleware,
-  createHealthCheckMiddleware,
   createOpenapiMiddleware,
   handleDevProxyError,
   normalizeBasePath,