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

package/dist/index.cjs

@@ -2136,6 +2136,229 @@ 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(", ")}`);
+    }
+    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
+  };
+}
+__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) {
+      }
+    }
+  } catch (error) {
+    console.error(`[readLogsBySource] Error reading ${filePath}:`, error);
+    throw error;
+  } finally {
+    if (rl) {
+      rl.close();
+    }
+    if (stream) {
+      stream.close();
+    }
+  }
+  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();
+    }
+  } catch (error) {
+    timestamp = Date.now();
+  }
+  const level = extractLogLevel(content);
+  return {
+    id,
+    level,
+    timestamp,
+    message: content,
+    context: null,
+    traceId: null,
+    userId: null,
+    appId: null,
+    tenantId: null,
+    stack: null,
+    meta: null,
+    tags: [
+      source
+    ]
+  };
+}
+__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") {
@@ -2229,6 +2452,32 @@ function createGetLogFileHandler(logDir) {
   };
 }
 __name(createGetLogFileHandler, "createGetLogFileHandler");
+function createGetServerLogsHandler(logDir) {
+  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;
+    try {
+      const result = await readServerLogs(logDir, {
+        limit,
+        offset,
+        levels,
+        sources
+      });
+      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"
+        });
+      }
+      res.json(result);
+    } catch (error) {
+      handleError(res, error, "Failed to read server logs");
+    }
+  };
+}
+__name(createGetServerLogsHandler, "createGetServerLogsHandler");
 
 // src/middlewares/dev-logs/health.controller.ts
 var import_node_http2 = __toESM(require("http"), 1);
@@ -2304,6 +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("/server-logs", createGetServerLogsHandler(logDir));
   router.get("/health", createHealthCheckHandler());
   return router;
 }
@@ -2325,6 +2575,11 @@ var DEV_LOGS_ROUTES = [
     method: "GET",
     path: "/files/:fileName",
     description: "Get paginated log file content by file name"
+  },
+  {
+    method: "GET",
+    path: "/server-logs",
+    description: "Get server logs in ServerLog format (compatible with frontend)"
   }
 ];
 function createDevLogsMiddleware(options = {}) {