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

package/dist/index.cjs

@@ -2136,147 +2136,229 @@ async function readLogFilePage(filePath, page, pageSize) {
   };
 }
 __name(readLogFilePage, "readLogFilePage");
-async function readTriggerList(filePath, trigger, path7, limit) {
-  if (!await fileExists(filePath)) {
+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(", ")}`);
+    }
     return void 0;
   }
-  const config = {
-    maxEntriesPerTrace: 10,
-    chunkSize: 64 * 1024
+  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 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;
-    }
-    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 (shouldIncludeInCompletedCalls(builder)) {
-      completedCalls.push(builder);
-      if (limit && completedCalls.length > limit) {
-        completedCalls.shift();
-      }
-    }
-  }, "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);
-    }
-    if (shouldIncludeInCompletedCalls(builder)) {
-      completedCalls.push(builder);
-      if (limit && completedCalls.length > limit) {
-        completedCalls.shift();
+}
+__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 = (0, import_node_fs7.createReadStream)(filePath, {
+      encoding: "utf8"
+    });
+    rl = (0, import_node_readline.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) {
       }
     }
-  }, "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;
+  } catch (error) {
+    console.error(`[readLogsBySource] Error reading ${filePath}:`, error);
+    throw error;
+  } finally {
+    if (rl) {
+      rl.close();
     }
-  }, "processLogEntry");
-  const processLine = /* @__PURE__ */ __name((line) => {
-    const entry = parseLogLine2(line);
-    if (entry?.trace_id) {
-      processLogEntry(entry);
+    if (stream) {
+      stream.close();
     }
-  }, "processLine");
-  await readFileReverse(filePath, config.chunkSize, processLine);
-  return {
-    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()
-    }))
-  };
+  }
+  return logs;
 }
-__name(readTriggerList, "readTriggerList");
-async function readTriggerDetail(filePath, path7, instanceID) {
-  const exists = await fileExists(filePath);
-  if (!exists) {
-    return void 0;
+__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;
   }
-  const matches = [];
-  const stream = (0, import_node_fs7.createReadStream)(filePath, {
-    encoding: "utf8"
-  });
-  const rl = (0, import_node_readline.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);
+}
+__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
+      ]
+    };
   }
-  rl.close();
-  stream.close();
+  const [, timeStr, , content] = match;
+  let timestamp;
+  try {
+    const isoStr = timeStr.replace(" ", "T");
+    timestamp = new Date(isoStr).getTime();
+    if (isNaN(timestamp)) {
+      timestamp = Date.now();
+    }
+  } catch (error) {
+    timestamp = Date.now();
+  }
+  const level = extractLogLevel(content);
   return {
-    instanceID,
-    entries: matches
+    id,
+    level,
+    timestamp,
+    message: content,
+    context: null,
+    traceId: null,
+    userId: null,
+    appId: null,
+    tenantId: null,
+    stack: null,
+    meta: null,
+    tags: [
+      source
+    ]
   };
 }
-__name(readTriggerDetail, "readTriggerDetail");
+__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(generateUUID, "generateUUID");
 
 // src/middlewares/dev-logs/controller.ts
 function handleNotFound(res, filePath, message = "Log file not found") {
@@ -2370,58 +2452,32 @@ function createGetLogFileHandler(logDir) {
   };
 }
 __name(createGetLogFileHandler, "createGetLogFileHandler");
-function createGetTriggerListHandler(logDir) {
-  const traceLogPath = (0, import_node_path7.join)(logDir, "trace.log");
+function createGetServerLogsHandler(logDir) {
   return async (req, res) => {
-    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);
+    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;
     try {
-      const result = await readTriggerList(traceLogPath, trigger, path7, limit);
-      if (!result) {
-        return handleNotFound(res, traceLogPath);
-      }
-      res.json({
-        file: getRelativePath(traceLogPath),
-        path: path7,
-        ...result
+      const result = await readServerLogs(logDir, {
+        limit,
+        offset,
+        levels,
+        sources
       });
-    } catch (error) {
-      handleError(res, error, "Failed to read trace log");
-    }
-  };
-}
-__name(createGetTriggerListHandler, "createGetTriggerListHandler");
-function createGetTriggerDetailHandler(logDir) {
-  const traceLogPath = (0, import_node_path7.join)(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 handleNotFound(res, traceLogPath);
+        return res.status(404).json({
+          message: "No server log files found",
+          hint: "Expected files: server.log, trace.log, server.std.log, client.std.log"
+        });
       }
-      res.json({
-        file: getRelativePath(traceLogPath),
-        ...result
-      });
+      res.json(result);
     } catch (error) {
-      handleError(res, error, "Failed to read trace log");
+      handleError(res, error, "Failed to read server logs");
     }
   };
 }
-__name(createGetTriggerDetailHandler, "createGetTriggerDetailHandler");
+__name(createGetServerLogsHandler, "createGetServerLogsHandler");
 
 // src/middlewares/dev-logs/health.controller.ts
 var import_node_http2 = __toESM(require("http"), 1);
@@ -2497,8 +2553,7 @@ function createDevLogRouter(options = {}) {
   router.get("/app/trace/:traceId", createGetTraceEntriesHandler(logDir));
   router.get("/trace/recent", createGetRecentTracesHandler(logDir));
   router.get("/files/:fileName", createGetLogFileHandler(logDir));
-  router.get("/trace/trigger/list", createGetTriggerListHandler(logDir));
-  router.get("/trace/trigger/:instanceID", createGetTriggerDetailHandler(logDir));
+  router.get("/server-logs", createGetServerLogsHandler(logDir));
   router.get("/health", createHealthCheckHandler());
   return router;
 }
@@ -2523,13 +2578,8 @@ var DEV_LOGS_ROUTES = [
   },
   {
     method: "GET",
-    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"
+    path: "/server-logs",
+    description: "Get server logs in ServerLog format (compatible with frontend)"
   }
 ];
 function createDevLogsMiddleware(options = {}) {