@lark-apaas/devtool-kits 1.2.5-alpha.1 → 1.2.5-alpha.3

package/dist/index.js

@@ -2095,229 +2095,147 @@ async function readLogFilePage(filePath, page, pageSize) {
   };
 }
 __name(readLogFilePage, "readLogFilePage");
-async function readServerLogs(logDir, options = {}) {
-  const limit = options.limit || 100;
-  const offset = options.offset || 0;
-  const sources = options.sources || [
-    "server",
-    "trace",
-    "server-std",
-    "client-std"
-  ];
-  const allLogs = [];
-  const errors = [];
-  for (const source of sources) {
-    try {
-      const logs = await readLogsBySource(logDir, source);
-      allLogs.push(...logs);
-    } catch (error) {
-      const errorMsg = `Failed to read ${source}: ${error instanceof Error ? error.message : String(error)}`;
-      errors.push(errorMsg);
-      console.warn(`[readServerLogs] ${errorMsg}`);
-    }
-  }
-  if (allLogs.length === 0) {
-    if (errors.length > 0) {
-      console.warn(`[readServerLogs] No logs found. Errors: ${errors.join(", ")}`);
-    }
+async function readTriggerList(filePath, trigger, path7, limit) {
+  if (!await fileExists(filePath)) {
     return void 0;
   }
-  let filteredLogs = allLogs;
-  if (options.levels && options.levels.length > 0) {
-    filteredLogs = allLogs.filter((log) => options.levels.includes(log.level));
-  }
-  filteredLogs.sort((a, b) => b.timestamp - a.timestamp);
-  const total = filteredLogs.length;
-  const paginatedLogs = filteredLogs.slice(offset, offset + limit);
-  return {
-    logs: paginatedLogs,
-    total,
-    hasMore: offset + limit < total
+  const config = {
+    maxEntriesPerTrace: 10,
+    chunkSize: 64 * 1024
   };
-}
-__name(readServerLogs, "readServerLogs");
-async function readLogsBySource(logDir, source) {
-  const { join: join6 } = await import("path");
-  let filePath;
-  let parser;
-  if (source === "server") {
-    filePath = join6(logDir, "server.log");
-    parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "server"), "parser");
-  } else if (source === "trace") {
-    filePath = join6(logDir, "trace.log");
-    parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "trace"), "parser");
-  } else if (source === "server-std") {
-    filePath = join6(logDir, "server.std.log");
-    parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "server-std"), "parser");
-  } else if (source === "client-std") {
-    filePath = join6(logDir, "client.std.log");
-    parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "client-std"), "parser");
-  } else {
-    console.warn(`[readLogsBySource] Unknown source: ${source}`);
-    return [];
-  }
-  if (!await fileExists(filePath)) {
-    console.warn(`[readLogsBySource] File not found: ${filePath}`);
-    return [];
-  }
-  const logs = [];
-  let stream = null;
-  let rl = null;
-  try {
-    stream = createReadStream(filePath, {
-      encoding: "utf8"
-    });
-    rl = createInterface({
-      input: stream,
-      crlfDelay: Infinity
-    });
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      try {
-        const log = parser(line);
-        if (log) {
-          logs.push(log);
-        }
-      } catch (parseError) {
+  const builders = /* @__PURE__ */ new Map();
+  const completedCalls = [];
+  const createTraceBuilder = /* @__PURE__ */ __name((traceId) => ({
+    traceId,
+    entries: [],
+    method: void 0,
+    path: void 0,
+    startTime: void 0,
+    endTime: void 0,
+    statusCode: void 0,
+    durationMs: void 0,
+    hasCompleted: false
+  }), "createTraceBuilder");
+  const shouldIncludeInCompletedCalls = /* @__PURE__ */ __name((builder) => {
+    const alreadyAdded = completedCalls.some((call) => call.traceId === builder.traceId);
+    if (alreadyAdded) {
+      return false;
+    }
+    if (!builder.hasCompleted) {
+      return false;
+    }
+    const isAutomationTrigger = builder.path?.endsWith(path7);
+    if (!isAutomationTrigger) {
+      return false;
+    }
+    if (trigger && builder.entries.length > 0) {
+      const requestEntry = builder.entries.find((e) => e.request_body?.trigger);
+      if (requestEntry?.request_body?.trigger) {
+        return String(requestEntry.request_body.trigger) === trigger;
       }
+      return false;
     }
-  } catch (error) {
-    console.error(`[readLogsBySource] Error reading ${filePath}:`, error);
-    throw error;
-  } finally {
-    if (rl) {
-      rl.close();
+    return true;
+  }, "shouldIncludeInCompletedCalls");
+  const updateBuilderMetadata = /* @__PURE__ */ __name((builder, entry) => {
+    if (entry.method && !builder.method) builder.method = String(entry.method);
+    if (entry.path && !builder.path) builder.path = String(entry.path);
+    builder.entries.push(entry);
+    if (builder.entries.length > config.maxEntriesPerTrace) {
+      builder.entries.shift();
     }
-    if (stream) {
-      stream.close();
+    if (shouldIncludeInCompletedCalls(builder)) {
+      completedCalls.push(builder);
+      if (limit && completedCalls.length > limit) {
+        completedCalls.shift();
+      }
     }
-  }
-  return logs;
-}
-__name(readLogsBySource, "readLogsBySource");
-function parsePinoLog(line, source) {
-  try {
-    const pinoLog = JSON.parse(line);
-    const id = generateUUID();
-    return {
-      id,
-      level: mapPinoLevelToServerLogLevel(pinoLog.level),
-      timestamp: new Date(pinoLog.time).getTime(),
-      message: pinoLog.message || pinoLog.msg || "",
-      context: pinoLog.context || null,
-      traceId: pinoLog.trace_id || null,
-      userId: pinoLog.user_id || null,
-      appId: pinoLog.app_id || null,
-      tenantId: pinoLog.tenant_id || null,
-      stack: pinoLog.stack || null,
-      meta: {
-        pid: pinoLog.pid,
-        hostname: pinoLog.hostname,
-        path: pinoLog.path,
-        method: pinoLog.method,
-        statusCode: pinoLog.status_code,
-        durationMs: pinoLog.duration_ms,
-        ip: pinoLog.ip,
-        requestBody: pinoLog.request_body,
-        responseBody: pinoLog.response_body
-      },
-      tags: [
-        source
-      ]
-    };
-  } catch (error) {
-    return null;
-  }
-}
-__name(parsePinoLog, "parsePinoLog");
-function parseStdLog(line, source) {
-  const id = generateUUID();
-  const match = line.match(/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[(server|client)\] (.*)$/);
-  if (!match) {
-    return {
-      id,
-      level: "log",
-      timestamp: Date.now(),
-      message: line,
-      context: null,
-      traceId: null,
-      userId: null,
-      appId: null,
-      tenantId: null,
-      stack: null,
-      meta: null,
-      tags: [
-        source
-      ]
-    };
-  }
-  const [, timeStr, , content] = match;
-  let timestamp;
-  try {
-    const isoStr = timeStr.replace(" ", "T");
-    timestamp = new Date(isoStr).getTime();
-    if (isNaN(timestamp)) {
-      timestamp = Date.now();
+  }, "updateBuilderMetadata");
+  const handleRequestCompleted = /* @__PURE__ */ __name((builder, entry, message) => {
+    builder.hasCompleted = true;
+    builder.endTime = entry.time;
+    builder.statusCode = extractNumber(message, /status_code:\s*(\d+)/);
+    builder.durationMs = extractNumber(message, /duration_ms:\s*(\d+)/);
+    if (!builder.path && entry.path) {
+      builder.path = String(entry.path);
     }
-  } catch (error) {
-    timestamp = Date.now();
-  }
-  const level = extractLogLevel(content);
+    if (shouldIncludeInCompletedCalls(builder)) {
+      completedCalls.push(builder);
+      if (limit && completedCalls.length > limit) {
+        completedCalls.shift();
+      }
+    }
+  }, "handleRequestCompleted");
+  const processLogEntry = /* @__PURE__ */ __name((entry) => {
+    const { trace_id: traceId, message = "" } = entry;
+    if (!traceId) return;
+    let builder = builders.get(traceId);
+    if (!builder) {
+      builder = createTraceBuilder(traceId);
+      builders.set(traceId, builder);
+    }
+    updateBuilderMetadata(builder, entry);
+    if (!builder.hasCompleted && (message.includes("HTTP request completed") || message.includes("HTTP request failed"))) {
+      handleRequestCompleted(builder, entry, message);
+    }
+    if (message.includes("HTTP request started") && !builder.startTime) {
+      builder.startTime = entry.time;
+    }
+  }, "processLogEntry");
+  const processLine = /* @__PURE__ */ __name((line) => {
+    const entry = parseLogLine2(line);
+    if (entry?.trace_id) {
+      processLogEntry(entry);
+    }
+  }, "processLine");
+  await readFileReverse(filePath, config.chunkSize, processLine);
   return {
-    id,
-    level,
-    timestamp,
-    message: content,
-    context: null,
-    traceId: null,
-    userId: null,
-    appId: null,
-    tenantId: null,
-    stack: null,
-    meta: null,
-    tags: [
-      source
-    ]
+    page: 1,
+    pageSize: completedCalls.length,
+    totalCalls: completedCalls.length,
+    totalPages: 1,
+    calls: completedCalls.map((builder) => ({
+      traceId: builder.traceId,
+      method: builder.method,
+      path: builder.path,
+      startTime: builder.startTime,
+      endTime: builder.endTime,
+      statusCode: builder.statusCode,
+      durationMs: builder.durationMs,
+      entries: builder.entries.slice().reverse()
+    }))
   };
 }
-__name(parseStdLog, "parseStdLog");
-function mapPinoLevelToServerLogLevel(pinoLevel) {
-  if (typeof pinoLevel === "string") {
-    const lower = pinoLevel.toLowerCase();
-    if (lower === "fatal") return "fatal";
-    if (lower === "error") return "error";
-    if (lower === "warn" || lower === "warning") return "warn";
-    if (lower === "info" || lower === "log") return "log";
-    if (lower === "debug") return "debug";
-    if (lower === "trace" || lower === "verbose") return "verbose";
-    return "log";
-  }
-  if (pinoLevel >= 60) return "fatal";
-  if (pinoLevel >= 50) return "error";
-  if (pinoLevel >= 40) return "warn";
-  if (pinoLevel >= 30) return "log";
-  if (pinoLevel >= 20) return "debug";
-  return "verbose";
-}
-__name(mapPinoLevelToServerLogLevel, "mapPinoLevelToServerLogLevel");
-function extractLogLevel(text) {
-  const lower = text.toLowerCase();
-  if (lower.includes("fatal") || lower.includes("critical")) return "fatal";
-  if (lower.includes("error") || lower.includes("<e>") || lower.includes("\u2716")) return "error";
-  if (lower.includes("warn") || lower.includes("warning") || lower.includes("<w>") || lower.includes("\u26A0")) return "warn";
-  if (lower.includes("debug") || lower.includes("<d>")) return "debug";
-  if (lower.includes("verbose") || lower.includes("trace")) return "verbose";
-  return "log";
-}
-__name(extractLogLevel, "extractLogLevel");
-function generateUUID() {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
+__name(readTriggerList, "readTriggerList");
+async function readTriggerDetail(filePath, path7, instanceID) {
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    return void 0;
+  }
+  const matches = [];
+  const stream = createReadStream(filePath, {
+    encoding: "utf8"
   });
+  const rl = createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    const entry = parseLogLine2(line);
+    if (!entry) continue;
+    const isAutomationTrigger = entry.path?.endsWith(path7);
+    const hasInstanceID = entry.message?.includes(`instanceID=${instanceID}`);
+    if (!isAutomationTrigger || !hasInstanceID) continue;
+    matches.push(entry);
+  }
+  rl.close();
+  stream.close();
+  return {
+    instanceID,
+    entries: matches
+  };
 }
-__name(generateUUID, "generateUUID");
+__name(readTriggerDetail, "readTriggerDetail");
 
 // src/middlewares/dev-logs/controller.ts
 function handleNotFound(res, filePath, message = "Log file not found") {
@@ -2411,32 +2329,58 @@ function createGetLogFileHandler(logDir) {
   };
 }
 __name(createGetLogFileHandler, "createGetLogFileHandler");
-function createGetServerLogsHandler(logDir) {
+function createGetTriggerListHandler(logDir) {
+  const traceLogPath = join3(logDir, "trace.log");
   return async (req, res) => {
-    const limit = parseLimit(req.query.limit, 100, 1e3);
-    const offset = parsePositiveInt(req.query.offset, 0);
-    const levels = req.query.levels ? String(req.query.levels).split(",").map((l) => l.trim()).filter(Boolean) : void 0;
-    const sources = req.query.sources ? String(req.query.sources).split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+    const trigger = typeof req.query.trigger === "string" ? req.query.trigger.trim() : void 0;
+    if (!trigger) {
+      return res.status(400).json({
+        message: "trigger is required"
+      });
+    }
+    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const limit = parseLimit(req.query.limit, 10, 200);
     try {
-      const result = await readServerLogs(logDir, {
-        limit,
-        offset,
-        levels,
-        sources
+      const result = await readTriggerList(traceLogPath, trigger, path7, limit);
+      if (!result) {
+        return handleNotFound(res, traceLogPath);
+      }
+      res.json({
+        file: getRelativePath(traceLogPath),
+        path: path7,
+        ...result
       });
+    } catch (error) {
+      handleError(res, error, "Failed to read trace log");
+    }
+  };
+}
+__name(createGetTriggerListHandler, "createGetTriggerListHandler");
+function createGetTriggerDetailHandler(logDir) {
+  const traceLogPath = join3(logDir, "server.log");
+  return async (req, res) => {
+    const instanceID = (req.params.instanceID || "").trim();
+    if (!instanceID) {
+      return res.status(400).json({
+        message: "instanceID is required"
+      });
+    }
+    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    try {
+      const result = await readTriggerDetail(traceLogPath, path7, instanceID);
       if (!result) {
-        return res.status(404).json({
-          message: "No server log files found",
-          hint: "Expected files: server.log, trace.log, server.std.log, client.std.log"
-        });
+        return handleNotFound(res, traceLogPath);
       }
-      res.json(result);
+      res.json({
+        file: getRelativePath(traceLogPath),
+        ...result
+      });
     } catch (error) {
-      handleError(res, error, "Failed to read server logs");
+      handleError(res, error, "Failed to read trace log");
     }
   };
 }
-__name(createGetServerLogsHandler, "createGetServerLogsHandler");
+__name(createGetTriggerDetailHandler, "createGetTriggerDetailHandler");
 
 // src/middlewares/dev-logs/health.controller.ts
 import http2 from "http";
@@ -2512,7 +2456,8 @@ function createDevLogRouter(options = {}) {
   router.get("/app/trace/:traceId", createGetTraceEntriesHandler(logDir));
   router.get("/trace/recent", createGetRecentTracesHandler(logDir));
   router.get("/files/:fileName", createGetLogFileHandler(logDir));
-  router.get("/server-logs", createGetServerLogsHandler(logDir));
+  router.get("/trace/trigger/list", createGetTriggerListHandler(logDir));
+  router.get("/trace/trigger/:instanceID", createGetTriggerDetailHandler(logDir));
   router.get("/health", createHealthCheckHandler());
   return router;
 }
@@ -2537,8 +2482,13 @@ var DEV_LOGS_ROUTES = [
   },
   {
     method: "GET",
-    path: "/server-logs",
-    description: "Get server logs in ServerLog format (compatible with frontend)"
+    path: "/trace/trigger/list",
+    description: "Get trigger list (automation trigger) in trace.log"
+  },
+  {
+    method: "GET",
+    path: "/trace/trigger/:instanceID",
+    description: "Get trigger detail (automation trigger) in trace.log by instanceID"
   }
 ];
 function createDevLogsMiddleware(options = {}) {