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

package/dist/index.cjs

@@ -1850,8 +1850,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");
 
@@ -2204,20 +2204,20 @@ async function readServerLogs(logDir, options = {}) {
 }
 __name(readServerLogs, "readServerLogs");
 async function readLogsBySource(logDir, source) {
-  const { join: join6 } = await import("path");
+  const { join: join7 } = await import("path");
   let filePath;
   let parser;
   if (source === "server") {
-    filePath = join6(logDir, "server.log");
+    filePath = join7(logDir, "server.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "server"), "parser");
   } else if (source === "trace") {
-    filePath = join6(logDir, "trace.log");
+    filePath = join7(logDir, "trace.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "trace"), "parser");
   } else if (source === "server-std") {
-    filePath = join6(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 = join6(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}`);
@@ -2385,7 +2385,7 @@ function generateUUID() {
   });
 }
 __name(generateUUID, "generateUUID");
-async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
+async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
   if (!await fileExists(filePath)) {
     return void 0;
   }
@@ -2411,7 +2411,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;
     }
@@ -2494,7 +2494,7 @@ async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
   };
 }
 __name(readTriggerList, "readTriggerList");
-async function readTriggerDetail(filePath, path7, instanceID) {
+async function readTriggerDetail(filePath, path8, instanceID) {
   const exists = await fileExists(filePath);
   if (!exists) {
     return void 0;
@@ -2510,7 +2510,7 @@ async function readTriggerDetail(filePath, path7, instanceID) {
   for await (const line of rl) {
     const entry = parseLogLine2(line);
     if (!entry) continue;
-    const isAutomationTrigger = entry.path?.endsWith(path7);
+    const isAutomationTrigger = entry.path?.endsWith(path8);
     const hasInstanceID = entry.instance_id === instanceID && entry.trigger;
     if (!isAutomationTrigger || !hasInstanceID) continue;
     matches.push(entry);
@@ -2652,16 +2652,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) {
@@ -2679,9 +2679,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);
       }
@@ -2763,6 +2763,521 @@ function createHealthCheckHandler(options = {}) {
 }
 __name(createHealthCheckHandler, "createHealthCheckHandler");
 
+// src/middlewares/dev-logs/sse/log-watcher.ts
+var fs9 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+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);
@@ -2771,6 +3286,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, {
+    debug: true
+  }));
   router.get("/trace/trigger/list", createGetTriggerListHandler(logDir));
   router.get("/trace/trigger/:instanceID", createGetTriggerDetailHandler(logDir));
   router.get("/health", createHealthCheckHandler());