@lark-apaas/devtool-kits 1.2.11-alpha.1 → 1.2.12-alpha.0

package/dist/index.js

@@ -1465,7 +1465,7 @@ function sendSimpleRedirect(req, res) {
 __name(sendSimpleRedirect, "sendSimpleRedirect");
 
 // src/middlewares/index.ts
-import path6 from "path";
+import path7 from "path";
 
 // src/middlewares/openapi/router.ts
 import express from "express";
@@ -1809,8 +1809,8 @@ function hasSpecialPatterns(pattern) {
   return /[{*]/.test(pattern);
 }
 __name(hasSpecialPatterns, "hasSpecialPatterns");
-function normalizePathForMatching(path7) {
-  return path7.replace(/\/+/g, "/").replace(/\/+$/, "");
+function normalizePathForMatching(path8) {
+  return path8.replace(/\/+/g, "/").replace(/\/+$/, "");
 }
 __name(normalizePathForMatching, "normalizePathForMatching");
 
@@ -1908,194 +1908,10 @@ function serializeError(error) {
 __name(serializeError, "serializeError");
 
 // src/middlewares/dev-logs/controller.ts
-import { join as join4 } from "path";
-
-// src/middlewares/dev-logs/services/file-reader.ts
-import { promises as fs8 } from "fs";
-async function readFileReverse(filePath, chunkSize, processLine) {
-  const handle = await fs8.open(filePath, "r");
-  try {
-    const stats = await handle.stat();
-    let position = stats.size;
-    let remainder = "";
-    while (position > 0) {
-      const length = Math.min(chunkSize, position);
-      position -= length;
-      const buffer = Buffer.alloc(length);
-      await handle.read(buffer, 0, length, position);
-      let chunk = buffer.toString("utf8");
-      if (remainder) {
-        chunk += remainder;
-        remainder = "";
-      }
-      const lines = chunk.split("\n");
-      remainder = lines.shift() ?? "";
-      for (let i = lines.length - 1; i >= 0; i -= 1) {
-        if (lines[i]) {
-          processLine(lines[i]);
-        }
-      }
-    }
-    if (remainder) {
-      processLine(remainder);
-    }
-  } finally {
-    await handle.close();
-  }
-}
-__name(readFileReverse, "readFileReverse");
-function buildPaginatedResponse(items, page, pageSize) {
-  const totalItems = items.length;
-  const totalPages = totalItems === 0 ? 0 : Math.ceil(totalItems / pageSize);
-  const startIndex = (page - 1) * pageSize;
-  const endIndex = Math.min(startIndex + pageSize, totalItems);
-  const pagedItems = items.slice(startIndex, endIndex).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 {
-    page,
-    pageSize,
-    totalCalls: totalItems,
-    totalPages,
-    calls: pagedItems
-  };
-}
-__name(buildPaginatedResponse, "buildPaginatedResponse");
-
-// src/middlewares/dev-logs/services/parsers.ts
-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");
-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 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");
+import { join as join3 } from "path";
 
-// src/middlewares/dev-logs/services/trace.service.ts
-import { createReadStream } from "fs";
+// src/middlewares/dev-logs/services.ts
+import { createReadStream, promises as fs8 } from "fs";
 import { createInterface } from "readline";
 async function readLogEntriesByTrace(filePath, traceId, limit) {
   const exists = await fileExists(filePath);
@@ -2194,6 +2010,62 @@ async function readRecentTraceCalls(filePath, page, pageSize, pathFilter, method
   return buildPaginatedResponse(completedCalls, page, pageSize);
 }
 __name(readRecentTraceCalls, "readRecentTraceCalls");
+async function readFileReverse(filePath, chunkSize, processLine) {
+  const handle = await fs8.open(filePath, "r");
+  try {
+    const stats = await handle.stat();
+    let position = stats.size;
+    let remainder = "";
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      await handle.read(buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const lines = chunk.split("\n");
+      remainder = lines.shift() ?? "";
+      for (let i = lines.length - 1; i >= 0; i -= 1) {
+        if (lines[i]) {
+          processLine(lines[i]);
+        }
+      }
+    }
+    if (remainder) {
+      processLine(remainder);
+    }
+  } finally {
+    await handle.close();
+  }
+}
+__name(readFileReverse, "readFileReverse");
+function buildPaginatedResponse(items, page, pageSize) {
+  const totalItems = items.length;
+  const totalPages = totalItems === 0 ? 0 : Math.ceil(totalItems / pageSize);
+  const startIndex = (page - 1) * pageSize;
+  const endIndex = Math.min(startIndex + pageSize, totalItems);
+  const pagedItems = items.slice(startIndex, endIndex).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 {
+    page,
+    pageSize,
+    totalCalls: totalItems,
+    totalPages,
+    calls: pagedItems
+  };
+}
+__name(buildPaginatedResponse, "buildPaginatedResponse");
 async function readLogFilePage(filePath, page, pageSize) {
   if (!await fileExists(filePath)) {
     return void 0;
@@ -2249,11 +2121,6 @@ async function readLogFilePage(filePath, page, pageSize) {
   };
 }
 __name(readLogFilePage, "readLogFilePage");
-
-// src/middlewares/dev-logs/services/server-log.service.ts
-import { createReadStream as createReadStream2 } from "fs";
-import { createInterface as createInterface2 } from "readline";
-import { join as join3 } from "path";
 async function readServerLogs(logDir, options = {}) {
   const limit = options.limit || 100;
   const offset = options.offset || 0;
@@ -2296,19 +2163,20 @@ async function readServerLogs(logDir, options = {}) {
 }
 __name(readServerLogs, "readServerLogs");
 async function readLogsBySource(logDir, source) {
+  const { join: join7 } = await import("path");
   let filePath;
   let parser;
   if (source === "server") {
-    filePath = join3(logDir, "server.log");
+    filePath = join7(logDir, "server.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "server"), "parser");
   } else if (source === "trace") {
-    filePath = join3(logDir, "trace.log");
+    filePath = join7(logDir, "trace.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "trace"), "parser");
   } else if (source === "server-std") {
-    filePath = join3(logDir, "server.std.log");
+    filePath = join7(logDir, "server.std.log");
     parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "server-std"), "parser");
   } else if (source === "client-std") {
-    filePath = join3(logDir, "client.std.log");
+    filePath = join7(logDir, "client.std.log");
     parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "client-std"), "parser");
   } else {
     console.warn(`[readLogsBySource] Unknown source: ${source}`);
@@ -2322,10 +2190,10 @@ async function readLogsBySource(logDir, source) {
   let stream = null;
   let rl = null;
   try {
-    stream = createReadStream2(filePath, {
+    stream = createReadStream(filePath, {
       encoding: "utf8"
     });
-    rl = createInterface2({
+    rl = createInterface({
       input: stream,
       crlfDelay: Infinity
     });
@@ -2353,11 +2221,130 @@ async function readLogsBySource(logDir, source) {
   return logs;
 }
 __name(readLogsBySource, "readLogsBySource");
-
-// src/middlewares/dev-logs/services/trigger.service.ts
-import { createReadStream as createReadStream3 } from "fs";
-import { createInterface as createInterface3 } from "readline";
-async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
+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");
+async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
   if (!await fileExists(filePath)) {
     return void 0;
   }
@@ -2383,7 +2370,7 @@ async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
     if (alreadyAdded) {
       return false;
     }
-    const isAutomationTrigger = builder.path?.endsWith(path7);
+    const isAutomationTrigger = builder.path?.endsWith(path8);
     if (!isAutomationTrigger) {
       return false;
     }
@@ -2437,176 +2424,64 @@ async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
     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 = createReadStream3(filePath, {
-    encoding: "utf8"
-  });
-  const rl = createInterface3({
-    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/services/capability.service.ts
-async function readCapabilityTraceList(filePath, capabilityId, limit) {
-  if (!await fileExists(filePath)) {
-    return void 0;
-  }
-  const config = {
-    chunkSize: 64 * 1024
-  };
-  const builders = /* @__PURE__ */ new Map();
-  const completedTraces = [];
-  const createCapabilityTraceBuilder = /* @__PURE__ */ __name((traceId, capId) => ({
-    traceId,
-    capabilityId: capId,
-    hasCompleted: false,
-    hasStartEntry: false
-  }), "createCapabilityTraceBuilder");
-  const shouldIncludeInCompletedTraces = /* @__PURE__ */ __name((builder) => {
-    const alreadyAdded = completedTraces.some((trace) => trace.traceId === builder.traceId);
-    if (alreadyAdded) {
-      return false;
-    }
-    return builder.capabilityId === capabilityId;
-  }, "shouldIncludeInCompletedTraces");
-  const updateBuilderMetadata = /* @__PURE__ */ __name((builder, entry) => {
-    if (entry.plugin_key && !builder.pluginKey) {
-      builder.pluginKey = String(entry.plugin_key);
-    }
-    if (entry.action && !builder.action) {
-      builder.action = String(entry.action);
-    }
-    const message = entry.message || "";
-    if (message.includes("Executing capability") && !builder.hasStartEntry) {
-      builder.hasStartEntry = true;
-      builder.startTime = entry.time;
-      if (entry.input) {
-        builder.input = String(entry.input);
-      }
-    }
-    if (message.includes("executed successfully")) {
-      builder.hasCompleted = true;
-      builder.endTime = entry.time;
-      builder.status = "success";
-      if (entry.output) {
-        builder.output = String(entry.output);
-      }
-      if (entry.duration_ms) {
-        builder.durationMs = Number(entry.duration_ms);
-      }
-      if (shouldIncludeInCompletedTraces(builder)) {
-        completedTraces.push(builder);
-      }
-    }
-    if (message.includes("execution failed")) {
-      builder.hasCompleted = true;
-      builder.endTime = entry.time;
-      builder.status = "failed";
-      if (entry.error) {
-        builder.error = {
-          message: String(entry.error)
-        };
-      }
-      if (entry.duration_ms) {
-        builder.durationMs = Number(entry.duration_ms);
-      }
-      if (shouldIncludeInCompletedTraces(builder)) {
-        completedTraces.push(builder);
-      }
-    }
-  }, "updateBuilderMetadata");
-  const processLogEntry = /* @__PURE__ */ __name((entry) => {
-    const { trace_id: traceId, capability_id: capId } = entry;
-    if (!traceId || !capId || capId !== capabilityId) return;
-    let builder = builders.get(traceId);
-    if (!builder) {
-      builder = createCapabilityTraceBuilder(traceId, capId);
-      builders.set(traceId, builder);
+    if (message.includes("HTTP request started") && !builder.startTime) {
+      builder.startTime = entry.time;
     }
-    updateBuilderMetadata(builder, entry);
   }, "processLogEntry");
   const processLine = /* @__PURE__ */ __name((line) => {
     const entry = parseLogLine2(line);
-    if (entry?.capability_id) {
+    if (entry?.trace_id) {
       processLogEntry(entry);
     }
   }, "processLine");
   await readFileReverse(filePath, config.chunkSize, processLine);
-  completedTraces.sort((a, b) => {
-    const timeA = a.endTime ? new Date(a.endTime).getTime() : 0;
-    const timeB = b.endTime ? new Date(b.endTime).getTime() : 0;
-    return timeB - timeA;
-  });
-  const limitedTraces = limit ? completedTraces.slice(0, limit) : completedTraces;
   return {
-    capabilityId,
-    totalTraces: limitedTraces.length,
-    traces: limitedTraces.map((builder) => ({
+    page: 1,
+    pageSize: completedCalls.length,
+    totalCalls: completedCalls.length,
+    totalPages: 1,
+    calls: completedCalls.map((builder) => ({
       traceId: builder.traceId,
-      capabilityId: builder.capabilityId,
-      pluginKey: builder.pluginKey,
-      action: builder.action,
+      method: builder.method,
+      path: builder.path,
       startTime: builder.startTime,
       endTime: builder.endTime,
+      statusCode: builder.statusCode,
       durationMs: builder.durationMs,
-      status: builder.status || "failed",
-      input: builder.input,
-      output: builder.output,
-      error: builder.error
+      entries: builder.entries.slice().reverse()
     }))
   };
 }
-__name(readCapabilityTraceList, "readCapabilityTraceList");
+__name(readTriggerList, "readTriggerList");
+async function readTriggerDetail(filePath, path8, 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(path8);
+    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") {
@@ -2623,7 +2498,7 @@ function handleError(res, error, message = "Failed to read log file") {
 }
 __name(handleError, "handleError");
 function createGetTraceEntriesHandler(logDir) {
-  const appLogPath = join4(logDir, "server.log");
+  const appLogPath = join3(logDir, "server.log");
   return async (req, res) => {
     const traceId = (req.params.traceId || "").trim();
     if (!traceId) {
@@ -2650,7 +2525,7 @@ function createGetTraceEntriesHandler(logDir) {
 }
 __name(createGetTraceEntriesHandler, "createGetTraceEntriesHandler");
 function createGetRecentTracesHandler(logDir) {
-  const traceLogPath = join4(logDir, "trace.log");
+  const traceLogPath = join3(logDir, "trace.log");
   return async (req, res) => {
     const page = parsePositiveInt(req.query.page, 1);
     const pageSize = parseLimit(req.query.pageSize, 10, 100);
@@ -2727,7 +2602,7 @@ function createGetServerLogsHandler(logDir) {
 }
 __name(createGetServerLogsHandler, "createGetServerLogsHandler");
 function createGetTriggerListHandler(logDir) {
-  const traceLogPath = join4(logDir, "trace.log");
+  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) {
@@ -2736,16 +2611,16 @@ function createGetTriggerListHandler(logDir) {
       });
     }
     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 path8 = 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);
+      const result = await readTriggerList(traceLogPath, trigger, path8, limit, triggerID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
       res.json({
         file: getRelativePath(traceLogPath),
-        path: path7,
+        path: path8,
         ...result
       });
     } catch (error) {
@@ -2755,7 +2630,7 @@ function createGetTriggerListHandler(logDir) {
 }
 __name(createGetTriggerListHandler, "createGetTriggerListHandler");
 function createGetTriggerDetailHandler(logDir) {
-  const traceLogPath = join4(logDir, "server.log");
+  const traceLogPath = join3(logDir, "server.log");
   return async (req, res) => {
     const instanceID = (req.params.instanceID || "").trim();
     if (!instanceID) {
@@ -2763,9 +2638,9 @@ function createGetTriggerDetailHandler(logDir) {
         message: "instanceID is required"
       });
     }
-    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path8 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     try {
-      const result = await readTriggerDetail(traceLogPath, path7, instanceID);
+      const result = await readTriggerDetail(traceLogPath, path8, instanceID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
@@ -2779,31 +2654,6 @@ function createGetTriggerDetailHandler(logDir) {
   };
 }
 __name(createGetTriggerDetailHandler, "createGetTriggerDetailHandler");
-function createGetCapabilityTraceListHandler(logDir) {
-  const serverLogPath = join4(logDir, "server.log");
-  return async (req, res) => {
-    const capabilityId = typeof req.query.capability_id === "string" ? req.query.capability_id.trim() : void 0;
-    if (!capabilityId) {
-      return res.status(400).json({
-        message: "capability_id is required"
-      });
-    }
-    const limit = parseLimit(req.query.limit, 10, 200);
-    try {
-      const result = await readCapabilityTraceList(serverLogPath, capabilityId, limit);
-      if (!result) {
-        return handleNotFound(res, serverLogPath);
-      }
-      res.json({
-        file: getRelativePath(serverLogPath),
-        ...result
-      });
-    } catch (error) {
-      handleError(res, error, "Failed to read server log");
-    }
-  };
-}
-__name(createGetCapabilityTraceListHandler, "createGetCapabilityTraceListHandler");
 
 // src/middlewares/dev-logs/health.controller.ts
 import http2 from "http";
@@ -2872,6 +2722,521 @@ function createHealthCheckHandler(options = {}) {
 }
 __name(createHealthCheckHandler, "createHealthCheckHandler");
 
+// src/middlewares/dev-logs/sse/log-watcher.ts
+import * as fs9 from "fs";
+import * as path6 from "path";
+function mapPinoLevelToServerLogLevel2(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(mapPinoLevelToServerLogLevel2, "mapPinoLevelToServerLogLevel");
+function extractLogLevel2(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(extractLogLevel2, "extractLogLevel");
+function generateUUID2() {
+  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(generateUUID2, "generateUUID");
+function parsePinoLog2(line, source) {
+  try {
+    const pinoLog = JSON.parse(line);
+    const id = generateUUID2();
+    return {
+      id,
+      level: mapPinoLevelToServerLogLevel2(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 {
+    return null;
+  }
+}
+__name(parsePinoLog2, "parsePinoLog");
+function parseStdLog2(line, source) {
+  const id = generateUUID2();
+  const match = line.match(/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[(server|client)\] (.*)$/);
+  if (!match) {
+    return {
+      id,
+      level: extractLogLevel2(line),
+      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 {
+    timestamp = Date.now();
+  }
+  return {
+    id,
+    level: extractLogLevel2(content),
+    timestamp,
+    message: content,
+    context: null,
+    traceId: null,
+    userId: null,
+    appId: null,
+    tenantId: null,
+    stack: null,
+    meta: null,
+    tags: [
+      source
+    ]
+  };
+}
+__name(parseStdLog2, "parseStdLog");
+var LogWatcher = class {
+  static {
+    __name(this, "LogWatcher");
+  }
+  logDir = "";
+  watchers = /* @__PURE__ */ new Map();
+  filePositions = /* @__PURE__ */ new Map();
+  subscribers = /* @__PURE__ */ new Set();
+  isRunning = false;
+  debug = false;
+  logFiles = [
+    {
+      fileName: "server.log",
+      source: "server",
+      parser: parsePinoLog2
+    },
+    {
+      fileName: "trace.log",
+      source: "trace",
+      parser: parsePinoLog2
+    },
+    {
+      fileName: "server.std.log",
+      source: "server-std",
+      parser: parseStdLog2
+    },
+    {
+      fileName: "client.std.log",
+      source: "client-std",
+      parser: parseStdLog2
+    }
+  ];
+  constructor(options = {}) {
+    this.debug = options.debug ?? false;
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[LogWatcher]", ...args);
+    }
+  }
+  /**
+  * Start watching log files
+  */
+  start(logDir) {
+    if (this.isRunning) {
+      this.log("Already running, ignoring start call");
+      return;
+    }
+    this.logDir = logDir;
+    this.isRunning = true;
+    this.log(`Starting to watch log files in: ${logDir}`);
+    for (const config of this.logFiles) {
+      this.watchFile(config);
+    }
+  }
+  /**
+  * Stop watching all files
+  */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.log("Stopping file watchers");
+    this.isRunning = false;
+    Array.from(this.watchers.entries()).forEach(([fileName, watcher]) => {
+      watcher.close();
+      this.log(`Closed watcher for: ${fileName}`);
+    });
+    this.watchers.clear();
+    this.filePositions.clear();
+  }
+  /**
+  * Subscribe to new log events
+  */
+  onLog(callback) {
+    this.subscribers.add(callback);
+    this.log(`Subscriber added, total: ${this.subscribers.size}`);
+    return () => {
+      this.subscribers.delete(callback);
+      this.log(`Subscriber removed, total: ${this.subscribers.size}`);
+    };
+  }
+  /**
+  * Get subscriber count
+  */
+  getSubscriberCount() {
+    return this.subscribers.size;
+  }
+  /**
+  * Watch a single log file
+  */
+  watchFile(config) {
+    const filePath = path6.join(this.logDir, config.fileName);
+    if (!fs9.existsSync(filePath)) {
+      this.log(`File not found, skipping: ${config.fileName}`);
+      return;
+    }
+    try {
+      const stats = fs9.statSync(filePath);
+      this.filePositions.set(config.fileName, stats.size);
+      this.log(`Initialized position for ${config.fileName}: ${stats.size} bytes`);
+    } catch (error) {
+      this.log(`Failed to get initial position for ${config.fileName}:`, error);
+      this.filePositions.set(config.fileName, 0);
+    }
+    try {
+      const watcher = fs9.watch(filePath, (eventType) => {
+        if (eventType === "change") {
+          this.handleFileChange(config);
+        }
+      });
+      watcher.on("error", (error) => {
+        this.log(`Watcher error for ${config.fileName}:`, error);
+        this.restartWatcher(config);
+      });
+      this.watchers.set(config.fileName, watcher);
+      this.log(`Started watching: ${config.fileName}`);
+    } catch (error) {
+      this.log(`Failed to start watcher for ${config.fileName}:`, error);
+    }
+  }
+  /**
+  * Restart a file watcher after error
+  */
+  restartWatcher(config) {
+    const existingWatcher = this.watchers.get(config.fileName);
+    if (existingWatcher) {
+      existingWatcher.close();
+      this.watchers.delete(config.fileName);
+    }
+    setTimeout(() => {
+      if (this.isRunning) {
+        this.log(`Restarting watcher for: ${config.fileName}`);
+        this.watchFile(config);
+      }
+    }, 1e3);
+  }
+  /**
+  * Handle file change event - read new content
+  */
+  handleFileChange(config) {
+    const filePath = path6.join(this.logDir, config.fileName);
+    const lastPosition = this.filePositions.get(config.fileName) || 0;
+    try {
+      const stats = fs9.statSync(filePath);
+      const currentSize = stats.size;
+      if (currentSize < lastPosition) {
+        this.log(`File ${config.fileName} was truncated, resetting position`);
+        this.filePositions.set(config.fileName, 0);
+        this.handleFileChange(config);
+        return;
+      }
+      if (currentSize === lastPosition) {
+        return;
+      }
+      const readSize = currentSize - lastPosition;
+      const buffer = Buffer.alloc(readSize);
+      const fd = fs9.openSync(filePath, "r");
+      try {
+        fs9.readSync(fd, buffer, 0, readSize, lastPosition);
+      } finally {
+        fs9.closeSync(fd);
+      }
+      this.filePositions.set(config.fileName, currentSize);
+      const content = buffer.toString("utf8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const log = config.parser(line, config.source);
+          if (log) {
+            this.notifySubscribers(log);
+          }
+        } catch {
+        }
+      }
+    } catch (error) {
+      this.log(`Error reading file ${config.fileName}:`, error);
+    }
+  }
+  /**
+  * Notify all subscribers of new log
+  */
+  notifySubscribers(log) {
+    Array.from(this.subscribers).forEach((subscriber) => {
+      try {
+        subscriber(log);
+      } catch (error) {
+        this.log("Subscriber error:", error);
+      }
+    });
+  }
+};
+
+// src/middlewares/dev-logs/sse/client-manager.ts
+var ClientManager = class {
+  static {
+    __name(this, "ClientManager");
+  }
+  clients = /* @__PURE__ */ new Map();
+  debug = false;
+  constructor(options = {}) {
+    this.debug = options.debug ?? false;
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[ClientManager]", ...args);
+    }
+  }
+  /**
+  * Generate a unique client ID
+  */
+  generateClientId() {
+    return `client_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+  * Add a new client connection
+  */
+  addClient(id, res) {
+    this.clients.set(id, {
+      id,
+      res,
+      connectedAt: Date.now()
+    });
+    this.log(`Client connected: ${id}, total clients: ${this.clients.size}`);
+  }
+  /**
+  * Remove a client connection
+  */
+  removeClient(id) {
+    if (this.clients.has(id)) {
+      this.clients.delete(id);
+      this.log(`Client disconnected: ${id}, total clients: ${this.clients.size}`);
+    }
+  }
+  /**
+  * Get current client count
+  */
+  getClientCount() {
+    return this.clients.size;
+  }
+  /**
+  * Check if a client exists
+  */
+  hasClient(id) {
+    return this.clients.has(id);
+  }
+  /**
+  * Send SSE event to a specific client
+  */
+  sendToClient(clientId, event, data) {
+    const client = this.clients.get(clientId);
+    if (!client) {
+      return false;
+    }
+    try {
+      const message = this.formatSSEMessage(event, data);
+      client.res.write(message);
+      return true;
+    } catch (error) {
+      this.log(`Failed to send to client ${clientId}:`, error);
+      this.removeClient(clientId);
+      return false;
+    }
+  }
+  /**
+  * Broadcast SSE event to all clients
+  */
+  broadcast(event, data) {
+    const message = this.formatSSEMessage(event, data);
+    const failedClients = [];
+    Array.from(this.clients.entries()).forEach(([id, client]) => {
+      try {
+        client.res.write(message);
+      } catch (error) {
+        this.log(`Broadcast failed for client ${id}:`, error);
+        failedClients.push(id);
+      }
+    });
+    failedClients.forEach((id) => {
+      this.removeClient(id);
+    });
+  }
+  /**
+  * Format SSE message
+  * SSE format: event: <event>\ndata: <json>\n\n
+  */
+  formatSSEMessage(event, data) {
+    const jsonData = JSON.stringify(data);
+    return `event: ${event}
+data: ${jsonData}
+
+`;
+  }
+  /**
+  * Get all client IDs
+  */
+  getClientIds() {
+    return Array.from(this.clients.keys());
+  }
+  /**
+  * Get client info
+  */
+  getClientInfo(id) {
+    const client = this.clients.get(id);
+    if (!client) {
+      return null;
+    }
+    return {
+      id: client.id,
+      connectedAt: client.connectedAt
+    };
+  }
+  /**
+  * Close all client connections
+  */
+  closeAll() {
+    this.log(`Closing all ${this.clients.size} clients`);
+    Array.from(this.clients.entries()).forEach(([id, client]) => {
+      try {
+        client.res.end();
+      } catch (error) {
+        this.log(`Error closing client ${id}:`, error);
+      }
+    });
+    this.clients.clear();
+  }
+};
+
+// src/middlewares/dev-logs/sse/sse.controller.ts
+function createSSEHandler(logDir, options = {}) {
+  const { debug = false, heartbeatInterval = 3e4 } = options;
+  const logWatcher = new LogWatcher({
+    debug
+  });
+  const clientManager = new ClientManager({
+    debug
+  });
+  const log = /* @__PURE__ */ __name((...args) => {
+    if (debug) {
+      console.log("[SSEHandler]", ...args);
+    }
+  }, "log");
+  return (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.setTimeout(0);
+    const clientId = clientManager.generateClientId();
+    clientManager.addClient(clientId, res);
+    log(`New SSE connection: ${clientId}`);
+    if (clientManager.getClientCount() === 1) {
+      log("First client connected, starting log watcher");
+      logWatcher.start(logDir);
+    }
+    const unsubscribe = logWatcher.onLog((logEntry) => {
+      clientManager.sendToClient(clientId, "log", logEntry);
+    });
+    clientManager.sendToClient(clientId, "connected", {
+      clientId,
+      timestamp: Date.now()
+    });
+    const heartbeat = setInterval(() => {
+      const success = clientManager.sendToClient(clientId, "heartbeat", {
+        timestamp: Date.now()
+      });
+      if (!success) {
+        clearInterval(heartbeat);
+      }
+    }, heartbeatInterval);
+    const cleanup = /* @__PURE__ */ __name(() => {
+      log(`Client disconnected: ${clientId}`);
+      clearInterval(heartbeat);
+      unsubscribe();
+      clientManager.removeClient(clientId);
+      if (clientManager.getClientCount() === 0) {
+        log("No more clients, stopping log watcher");
+        logWatcher.stop();
+      }
+    }, "cleanup");
+    req.on("close", cleanup);
+    req.on("error", (error) => {
+      log(`Client error ${clientId}:`, error);
+      cleanup();
+    });
+  };
+}
+__name(createSSEHandler, "createSSEHandler");
+
 // src/middlewares/dev-logs/router.ts
 function createDevLogRouter(options = {}) {
   const logDir = resolveLogDir(options.logDir);
@@ -2880,9 +3245,9 @@ function createDevLogRouter(options = {}) {
   router.get("/trace/recent", createGetRecentTracesHandler(logDir));
   router.get("/files/:fileName", createGetLogFileHandler(logDir));
   router.get("/server-logs", createGetServerLogsHandler(logDir));
+  router.get("/server-logs/stream", createSSEHandler(logDir));
   router.get("/trace/trigger/list", createGetTriggerListHandler(logDir));
   router.get("/trace/trigger/:instanceID", createGetTriggerDetailHandler(logDir));
-  router.get("/trace/capability/list", createGetCapabilityTraceListHandler(logDir));
   router.get("/health", createHealthCheckHandler());
   return router;
 }
@@ -2942,11 +3307,11 @@ import express3 from "express";
 
 // src/middlewares/collect-logs/controller.ts
 import { join as join6 } from "path";
-import fs10 from "fs";
+import fs11 from "fs";
 
 // src/middlewares/collect-logs/utils.ts
 import { isAbsolute as isAbsolute2, join as join5 } from "path";
-import fs9 from "fs";
+import fs10 from "fs";
 function resolveLogDir2(provided) {
   if (!provided) {
     return join5(process.cwd(), "logs");
@@ -2955,8 +3320,8 @@ function resolveLogDir2(provided) {
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, {
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, {
       recursive: true
     });
   }
@@ -2988,7 +3353,7 @@ function collectLogsHandler(logDir, fileName) {
         ...logContent,
         server_time: (/* @__PURE__ */ new Date()).toISOString()
       }) + "\n";
-      await fs10.promises.appendFile(filePath, logLine);
+      await fs11.promises.appendFile(filePath, logLine);
       res.json({
         success: true
       });
@@ -3016,7 +3381,7 @@ function collectLogsBatchHandler(logDir, fileName) {
           server_time: (/* @__PURE__ */ new Date()).toISOString()
         }) + "\n");
       }
-      await fs10.promises.appendFile(filePath, logLines.join(""));
+      await fs11.promises.appendFile(filePath, logLines.join(""));
       res.json({
         success: true
       });
@@ -3079,7 +3444,7 @@ function isGlobalMiddleware(middleware) {
 }
 __name(isGlobalMiddleware, "isGlobalMiddleware");
 function computeMountPath(basePath, mountPath) {
-  const routePath = path6.posix.join(basePath, mountPath);
+  const routePath = path7.posix.join(basePath, mountPath);
   return routePath.startsWith("/") ? routePath : `/${routePath}`;
 }
 __name(computeMountPath, "computeMountPath");
@@ -3087,7 +3452,7 @@ function logMiddlewareRegistration(middleware, fullMountPath) {
   if (middleware.routes && middleware.routes.length > 0) {
     console.log(`[Middleware] Registered: ${middleware.name} at ${fullMountPath}`);
     middleware.routes.forEach((route) => {
-      const routePath = route.path === "/" ? fullMountPath : path6.posix.join(fullMountPath, route.path);
+      const routePath = route.path === "/" ? fullMountPath : path7.posix.join(fullMountPath, route.path);
       console.log(`  ${route.method} ${routePath} - ${route.description}`);
     });
   } else {