@lark-apaas/devtool-kits 1.2.24 → 1.2.25-alpha.20260819082505

package/dist/index.cjs

@@ -31,16 +31,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  HEALTH_ENDPOINT: () => HEALTH_ENDPOINT,
   buildFullPath: () => buildFullPath,
   calculateFileHash: () => calculateFileHash,
   createCollectLogsMiddleware: () => createCollectLogsMiddleware,
   createDevLogsMiddleware: () => createDevLogsMiddleware,
+  createHealthHandler: () => createHealthHandler,
+  createHealthProbe: () => createHealthProbe,
   createOpenapiMiddleware: () => createOpenapiMiddleware,
   evaluateTemplateLiteral: () => evaluateTemplateLiteral,
   extractPageRouteInfo: () => extractPageRouteInfo,
+  getHealthPayload: () => getHealthPayload,
   getQuery: () => getQuery,
   getQueryParam: () => getQueryParam,
   handleDevProxyError: () => handleDevProxyError,
+  isPidAlive: () => isPidAlive,
   isRouteComponent: () => isRouteComponent,
   normalizeBasePath: () => normalizeBasePath,
   parseAndGenerateNestResourceTemplate: () => parseAndGenerateNestResourceTemplate,
@@ -48,6 +53,8 @@ __export(index_exports, {
   parseRoutesFromFile: () => parseRoutesFromFile,
   postprocessDrizzleSchema: () => postprocessDrizzleSchema,
   registerMiddlewares: () => registerMiddlewares,
+  resolveHealth: () => resolveHealth,
+  resolveServerLiveness: () => resolveServerLiveness,
   routeParserLog: () => routeParserLog,
   sendError: () => sendError,
   sendJson: () => sendJson,
@@ -1991,8 +1998,8 @@ function hasSpecialPatterns(pattern) {
   return /[{*]/.test(pattern);
 }
 __name(hasSpecialPatterns, "hasSpecialPatterns");
-function normalizePathForMatching(path8) {
-  return path8.replace(/\/+/g, "/").replace(/\/+$/, "");
+function normalizePathForMatching(path11) {
+  return path11.replace(/\/+/g, "/").replace(/\/+$/, "");
 }
 __name(normalizePathForMatching, "normalizePathForMatching");
 
@@ -2541,7 +2548,7 @@ __name(readLogsBySource, "readLogsBySource");
 // src/middlewares/dev-logs/services/trigger.service.ts
 var import_node_fs9 = require("fs");
 var import_node_readline3 = require("readline");
-async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
+async function readTriggerList(filePath, trigger, path11, limit, triggerID) {
   if (!await fileExists(filePath)) {
     return void 0;
   }
@@ -2567,7 +2574,7 @@ async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
     if (alreadyAdded) {
       return false;
     }
-    const isAutomationTrigger = builder.path?.endsWith(path8);
+    const isAutomationTrigger = builder.path?.endsWith(path11);
     if (!isAutomationTrigger) {
       return false;
     }
@@ -2650,7 +2657,7 @@ async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
   };
 }
 __name(readTriggerList, "readTriggerList");
-async function readTriggerDetail(filePath, path8, instanceID) {
+async function readTriggerDetail(filePath, path11, instanceID) {
   const exists = await fileExists(filePath);
   if (!exists) {
     return void 0;
@@ -2666,7 +2673,7 @@ async function readTriggerDetail(filePath, path8, instanceID) {
   for await (const line of rl) {
     const entry = parseLogLine(line);
     if (!entry) continue;
-    const isAutomationTrigger = entry.path?.endsWith(path8);
+    const isAutomationTrigger = entry.path?.endsWith(path11);
     const hasInstanceID = entry.instance_id === instanceID && entry.trigger;
     if (!isAutomationTrigger || !hasInstanceID) continue;
     matches.push(entry);
@@ -2920,16 +2927,16 @@ function createGetTriggerListHandler(logDir) {
       });
     }
     const triggerID = typeof req.query.triggerID === "string" ? req.query.triggerID.trim() : void 0;
-    const path8 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path11 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     const limit = parseLimit(req.query.limit, 10, 200);
     try {
-      const result = await readTriggerList(traceLogPath, trigger, path8, limit, triggerID);
+      const result = await readTriggerList(traceLogPath, trigger, path11, limit, triggerID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
       res.json({
         file: getRelativePath(traceLogPath),
-        path: path8,
+        path: path11,
         ...result
       });
     } catch (error) {
@@ -2947,9 +2954,9 @@ function createGetTriggerDetailHandler(logDir) {
         message: "instanceID is required"
       });
     }
-    const path8 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path11 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     try {
-      const result = await readTriggerDetail(traceLogPath, path8, instanceID);
+      const result = await readTriggerDetail(traceLogPath, path11, instanceID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
@@ -3575,8 +3582,8 @@ __name(createSSEHandler, "createSSEHandler");
 
 // src/middlewares/dev-logs/api-list-handler.ts
 var SERVER_PORT = process.env.SERVER_PORT || "3000";
-function extractModuleFromPath(path8) {
-  const segments = path8.split("/").filter(Boolean);
+function extractModuleFromPath(path11) {
+  const segments = path11.split("/").filter(Boolean);
   let startIndex = 0;
   if (segments[0] === "api") {
     startIndex = 1;
@@ -3591,8 +3598,8 @@ function extractModuleFromPath(path8) {
   return moduleName;
 }
 __name(extractModuleFromPath, "extractModuleFromPath");
-function generateRouteId(method, path8) {
-  const cleanPath = path8.replace(/[/:]/g, "_").replace(/^_+|_+$/g, "");
+function generateRouteId(method, path11) {
+  const cleanPath = path11.replace(/[/:]/g, "_").replace(/^_+|_+$/g, "");
   return `${method.toLowerCase()}_${cleanPath}`;
 }
 __name(generateRouteId, "generateRouteId");
@@ -4067,9 +4074,204 @@ function registerMiddlewares(server, middlewares, options) {
 }
 __name(registerMiddlewares, "registerMiddlewares");
 
+// src/health/resolve.ts
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+
+// src/health/server-liveness.ts
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
+var TAIL_BYTES = 64 * 1024;
+function isListenMarker(line) {
+  const message = String(line.message ?? "");
+  if (line.context === "Bootstrap" && message.startsWith("Server running on")) {
+    return true;
+  }
+  return line.context === "PlatformHealth" && message.startsWith("listening");
+}
+__name(isListenMarker, "isListenMarker");
+function readLastListenMarker(logFile) {
+  let fd;
+  try {
+    const size = import_node_fs11.default.statSync(logFile).size;
+    if (size === 0) return null;
+    const length = Math.min(size, TAIL_BYTES);
+    const buf = Buffer.alloc(length);
+    fd = import_node_fs11.default.openSync(logFile, "r");
+    import_node_fs11.default.readSync(fd, buf, 0, length, size - length);
+    const lines = buf.toString("utf8").split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const raw = lines[i].trim();
+      if (!raw.startsWith("{")) continue;
+      try {
+        const parsed = JSON.parse(raw);
+        if (isListenMarker(parsed)) return parsed;
+      } catch {
+      }
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        import_node_fs11.default.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+__name(readLastListenMarker, "readLastListenMarker");
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+__name(isPidAlive, "isPidAlive");
+function resolveServerLiveness(logDir, sessionStartedAt) {
+  const marker = readLastListenMarker(import_node_path10.default.join(logDir, "server.log"));
+  if (!marker || typeof marker.pid !== "number") {
+    return {
+      alive: false,
+      pid: null,
+      listenAt: null
+    };
+  }
+  const listenAt = typeof marker.time === "string" ? marker.time : null;
+  if (sessionStartedAt && listenAt) {
+    const markerMs = Date.parse(listenAt);
+    if (Number.isFinite(markerMs) && markerMs < sessionStartedAt - 5e3) {
+      return {
+        alive: false,
+        pid: marker.pid,
+        listenAt
+      };
+    }
+  }
+  return {
+    alive: isPidAlive(marker.pid),
+    pid: marker.pid,
+    listenAt
+  };
+}
+__name(resolveServerLiveness, "resolveServerLiveness");
+
+// src/health/resolve.ts
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+function resolveHealth(options) {
+  const { rootDir, hasServer, clientReady, firstStartedAt, logDir = import_node_path11.default.join(rootDir, "logs"), serverEntry = import_node_path11.default.join(rootDir, "dist", "server", "main.js"), timeoutMs = DEFAULT_TIMEOUT_MS, now = Date.now, sessionStartedAt = null, onServerAlive } = options;
+  if (!hasServer) {
+    return {
+      ready: clientReady,
+      failed: false
+    };
+  }
+  const liveness = resolveServerLiveness(logDir, sessionStartedAt);
+  if (liveness.alive) {
+    onServerAlive?.();
+    return {
+      ready: clientReady,
+      failed: false
+    };
+  }
+  const elapsed = firstStartedAt ? now() - firstStartedAt : 0;
+  if (!firstStartedAt || elapsed <= timeoutMs) {
+    return {
+      ready: false,
+      failed: false
+    };
+  }
+  const seconds = Math.round(elapsed / 1e3);
+  const compiled = safeExists(serverEntry);
+  const message = compiled ? `\u540E\u7AEF\u670D\u52A1\u542F\u52A8\u8D85\u65F6\uFF08\u5DF2\u7B49\u5F85 ${seconds}s\uFF09\uFF1A\u7F16\u8BD1\u4EA7\u7269\u5DF2\u751F\u6210\u4F46\u670D\u52A1\u672A\u76D1\u542C\uFF0C\u8BF7\u67E5\u770B ${import_node_path11.default.join(logDir, "server.std.log")}` : `\u540E\u7AEF\u670D\u52A1\u7F16\u8BD1\u672A\u901A\u8FC7\uFF08\u5DF2\u7B49\u5F85 ${seconds}s\uFF09\uFF1A\u672A\u751F\u6210 ${import_node_path11.default.relative(rootDir, serverEntry)}\uFF0C\u8BF7\u67E5\u770B ${import_node_path11.default.join(logDir, "server.std.log")}`;
+  return {
+    ready: false,
+    failed: true,
+    message
+  };
+}
+__name(resolveHealth, "resolveHealth");
+function safeExists(file) {
+  try {
+    return import_node_fs12.default.existsSync(file);
+  } catch {
+    return false;
+  }
+}
+__name(safeExists, "safeExists");
+
+// src/health/handler.ts
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
+var HEALTH_ENDPOINT = "/dev/health";
+function resolveTimeoutMs(explicit) {
+  if (typeof explicit === "number") return explicit;
+  const raw = Number(process.env.MIAODA_HEALTH_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : void 0;
+}
+__name(resolveTimeoutMs, "resolveTimeoutMs");
+function readSessionStartedAt(logDir) {
+  try {
+    const raw = import_node_fs13.default.readFileSync(import_node_path12.default.join(logDir, "dev-status.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.firstStartedAt === "number" ? parsed.firstStartedAt : null;
+  } catch {
+    return null;
+  }
+}
+__name(readSessionStartedAt, "readSessionStartedAt");
+function createHealthProbe(options) {
+  const logDir = options.logDir ?? import_node_path12.default.join(options.rootDir, "logs");
+  let lastAliveAt = null;
+  return /* @__PURE__ */ __name(function probe() {
+    try {
+      const sessionStartedAt = readSessionStartedAt(logDir);
+      const since = lastAliveAt !== null && (sessionStartedAt === null || lastAliveAt > sessionStartedAt) ? lastAliveAt : sessionStartedAt;
+      const payload = resolveHealth({
+        rootDir: options.rootDir,
+        logDir,
+        hasServer: options.hasServer,
+        clientReady: options.isClientReady(),
+        firstStartedAt: since,
+        timeoutMs: resolveTimeoutMs(options.timeoutMs),
+        onServerAlive: /* @__PURE__ */ __name(() => {
+          lastAliveAt = Date.now();
+        }, "onServerAlive")
+      });
+      return payload;
+    } catch {
+      return {
+        ready: false,
+        failed: false
+      };
+    }
+  }, "probe");
+}
+__name(createHealthProbe, "createHealthProbe");
+function getHealthPayload(options) {
+  return createHealthProbe(options)();
+}
+__name(getHealthPayload, "getHealthPayload");
+function createHealthHandler(options) {
+  const probe = createHealthProbe(options);
+  return /* @__PURE__ */ __name(function healthHandler(req, res, next) {
+    if (req.method && req.method !== "GET" && next) {
+      return next();
+    }
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Cache-Control", "no-store");
+    res.statusCode = 200;
+    res.end(JSON.stringify(probe()));
+  }, "healthHandler");
+}
+__name(createHealthHandler, "createHealthHandler");
+
 // src/route-parser.ts
-var fs12 = __toESM(require("fs"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs15 = __toESM(require("fs"), 1);
+var path10 = __toESM(require("path"), 1);
 var crypto3 = __toESM(require("crypto"), 1);
 var import_parser = require("@babel/parser");
 var import_traverse = __toESM(require("@babel/traverse"), 1);
@@ -4095,7 +4297,7 @@ function routeParserLog(level, message, ...args) {
 __name(routeParserLog, "routeParserLog");
 function calculateFileHash(filePath) {
   try {
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs15.readFileSync(filePath, "utf-8");
     return crypto3.createHash("md5").update(content).digest("hex");
   } catch (error) {
     routeParserLog("warn", "Failed to calculate file hash:", error.message);
@@ -4179,11 +4381,11 @@ function parseRoutesFromFile(appPath, basePath, options = {}) {
   const { applyBasePath = true } = options;
   const defaultPath = applyBasePath && basePath ? `${basePath}/` : "/";
   try {
-    const appFilePath = path7.resolve(process.cwd(), appPath);
-    if (!fs12.existsSync(appFilePath)) {
+    const appFilePath = path10.resolve(process.cwd(), appPath);
+    if (!fs15.existsSync(appFilePath)) {
       throw new Error(`App file does not exist: ${appFilePath}`);
     }
-    const sourceCode = fs12.readFileSync(appFilePath, "utf-8");
+    const sourceCode = fs15.readFileSync(appFilePath, "utf-8");
     const ast = (0, import_parser.parse)(sourceCode, {
       sourceType: "module",
       plugins: [
@@ -4243,16 +4445,21 @@ function parseRoutesFromFile(appPath, basePath, options = {}) {
 __name(parseRoutesFromFile, "parseRoutesFromFile");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HEALTH_ENDPOINT,
   buildFullPath,
   calculateFileHash,
   createCollectLogsMiddleware,
   createDevLogsMiddleware,
+  createHealthHandler,
+  createHealthProbe,
   createOpenapiMiddleware,
   evaluateTemplateLiteral,
   extractPageRouteInfo,
+  getHealthPayload,
   getQuery,
   getQueryParam,
   handleDevProxyError,
+  isPidAlive,
   isRouteComponent,
   normalizeBasePath,
   parseAndGenerateNestResourceTemplate,
@@ -4260,6 +4467,8 @@ __name(parseRoutesFromFile, "parseRoutesFromFile");
   parseRoutesFromFile,
   postprocessDrizzleSchema,
   registerMiddlewares,
+  resolveHealth,
+  resolveServerLiveness,
   routeParserLog,
   sendError,
   sendJson,