@lark-apaas/devtool-kits 1.2.9-alpha.0 → 1.2.10-alpha.0

package/dist/index.js

@@ -2344,6 +2344,144 @@ function generateUUID() {
   });
 }
 __name(generateUUID, "generateUUID");
+async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
+  if (!await fileExists(filePath)) {
+    return void 0;
+  }
+  const config = {
+    maxEntriesPerTrace: 10,
+    chunkSize: 64 * 1024
+  };
+  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;
+    }
+    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 && (triggerID ? requestEntry?.request_body?.triggerID === triggerID : true);
+      }
+      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.pop();
+      }
+    }
+  }, "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.pop();
+      }
+    }
+  }, "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 {
+    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(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.instance_id === instanceID && entry.trigger;
+    if (!isAutomationTrigger || !hasInstanceID) continue;
+    matches.push(entry);
+  }
+  rl.close();
+  stream.close();
+  return {
+    instanceID,
+    entries: matches
+  };
+}
+__name(readTriggerDetail, "readTriggerDetail");
 
 // src/middlewares/dev-logs/controller.ts
 function handleNotFound(res, filePath, message = "Log file not found") {
@@ -2463,6 +2601,59 @@ function createGetServerLogsHandler(logDir) {
   };
 }
 __name(createGetServerLogsHandler, "createGetServerLogsHandler");
+function createGetTriggerListHandler(logDir) {
+  const traceLogPath = join3(logDir, "trace.log");
+  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 triggerID = typeof req.query.triggerID === "string" ? req.query.triggerID.trim() : void 0;
+    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 readTriggerList(traceLogPath, trigger, path7, limit, triggerID);
+      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 handleNotFound(res, traceLogPath);
+      }
+      res.json({
+        file: getRelativePath(traceLogPath),
+        ...result
+      });
+    } catch (error) {
+      handleError(res, error, "Failed to read trace log");
+    }
+  };
+}
+__name(createGetTriggerDetailHandler, "createGetTriggerDetailHandler");
 
 // src/middlewares/dev-logs/health.controller.ts
 import http2 from "http";
@@ -2539,6 +2730,8 @@ function createDevLogRouter(options = {}) {
   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;
 }
@@ -2565,6 +2758,16 @@ var DEV_LOGS_ROUTES = [
     method: "GET",
     path: "/server-logs",
     description: "Get server logs in ServerLog format (compatible with frontend)"
+  },
+  {
+    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"
   }
 ];
 function createDevLogsMiddleware(options = {}) {