@lark-apaas/devtool-kits 1.2.15-beta.0 → 1.2.16-beta.0

package/dist/index.cjs

@@ -1261,11 +1261,8 @@ async function parseAndGenerateNestResourceTemplate(options) {
 __name(parseAndGenerateNestResourceTemplate, "parseAndGenerateNestResourceTemplate");
 
 // src/helpers/proxy-error/index.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_node_http = __toESM(require("http"), 1);
-var import_node_https = __toESM(require("https"), 1);
-var errorHtmlTemplate = null;
+var http = __toESM(require("http"), 1);
+var https = __toESM(require("https"), 1);
 function isConnectionError(err) {
   const code = err.code;
   const connectionErrorCodes = [
@@ -1278,12 +1275,12 @@ function isConnectionError(err) {
   return connectionErrorCodes.includes(code || "");
 }
 __name(isConnectionError, "isConnectionError");
-function checkServiceAvailable(targetUrl, timeout = 1e3) {
+function checkServiceAvailable(targetUrl, timeout = 2e3) {
   return new Promise((resolve) => {
     try {
       const url = new URL(targetUrl);
       const isHttps = url.protocol === "https:";
-      const httpModule = isHttps ? import_node_https.default : import_node_http.default;
+      const httpModule = isHttps ? https : http;
       const req = httpModule.request({
         hostname: url.hostname,
         port: url.port || (isHttps ? 443 : 80),
@@ -1291,8 +1288,7 @@ function checkServiceAvailable(targetUrl, timeout = 1e3) {
         method: "HEAD",
         timeout
       }, (res) => {
-        const available = res.statusCode !== 502 && !res.headers["x-proxy-error-page"];
-        resolve(available);
+        resolve(res.statusCode !== 502);
       });
       req.on("timeout", () => {
         req.destroy();
@@ -1302,7 +1298,7 @@ function checkServiceAvailable(targetUrl, timeout = 1e3) {
         resolve(false);
       });
       req.end();
-    } catch (e) {
+    } catch {
       resolve(false);
     }
   });
@@ -1320,194 +1316,61 @@ async function waitForServiceRecovery(targetUrl, timeout, interval) {
   return false;
 }
 __name(waitForServiceRecovery, "waitForServiceRecovery");
-function getDirname() {
-  return __dirname;
-}
-__name(getDirname, "getDirname");
-function getErrorHtmlTemplate() {
-  if (!errorHtmlTemplate) {
-    const dirname = getDirname();
-    const htmlPath = import_node_path3.default.join(dirname, "error.html");
-    errorHtmlTemplate = import_node_fs3.default.readFileSync(htmlPath, "utf-8");
-  }
-  return errorHtmlTemplate;
-}
-__name(getErrorHtmlTemplate, "getErrorHtmlTemplate");
-function parseLogLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed) return null;
-  const match = trimmed.match(/^\[\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\]\s+\[server\]\s+(.*)$/);
-  if (match) {
-    const content = match[1].trim();
-    return content || null;
-  }
-  return null;
-}
-__name(parseLogLine, "parseLogLine");
-async function readRecentErrorLogs(logDir, maxLogs, fileName) {
-  const logFilePath = import_node_path3.default.join(logDir, fileName);
-  let fileStats;
-  try {
-    fileStats = await import_node_fs3.default.promises.stat(logFilePath);
-  } catch {
-    return {
-      logs: [],
-      hasCompileError: false
-    };
-  }
-  const fileSize = fileStats.size;
-  const maxReadSize = 1024 * 1024;
-  const readSize = Math.min(fileSize, maxReadSize);
-  const startPosition = Math.max(0, fileSize - readSize);
-  const buffer = Buffer.allocUnsafe(readSize);
-  let fileHandle;
-  try {
-    fileHandle = await import_node_fs3.default.promises.open(logFilePath, "r");
-    await fileHandle.read(buffer, 0, readSize, startPosition);
-  } catch (error) {
-    console.error("[Proxy Error]: Failed to read log file:", error);
-    return {
-      logs: [],
-      hasCompileError: false
-    };
-  } finally {
-    if (fileHandle) {
-      await fileHandle.close();
-    }
-  }
-  const content = buffer.toString("utf8");
-  const lines = content.split("\n");
-  if (startPosition > 0 && lines.length > 0) {
-    lines.shift();
-  }
-  const allLines = [];
-  for (const line of lines) {
-    const parsed = parseLogLine(line);
-    if (parsed !== null) {
-      allLines.push(parsed);
-    }
-  }
-  let startIndex = -1;
-  for (let i = allLines.length - 1; i >= 0; i--) {
-    const line = allLines[i];
-    if (line.includes("Starting compilation in watch mode") || line.includes("File change detected. Starting incremental compilation")) {
-      startIndex = i;
-      break;
-    }
-  }
-  if (startIndex === -1) {
-    console.log("[Proxy Error]: No compilation start marker found, returning last logs");
-    const fallbackLogs = allLines.slice(-maxLogs);
-    const hasCompileError2 = checkForErrors(fallbackLogs);
-    return {
-      logs: fallbackLogs,
-      hasCompileError: hasCompileError2
-    };
-  }
-  let endIndex = allLines.length;
-  for (let i = startIndex + 1; i < allLines.length; i++) {
-    const line = allLines[i];
-    if (line.includes("Starting compilation in watch mode") || line.includes("File change detected. Starting incremental compilation")) {
-      endIndex = i;
-      break;
-    }
-  }
-  const errorSection = allLines.slice(startIndex, endIndex);
-  const hasCompileError = checkForErrors(errorSection);
-  const logs = errorSection.length > maxLogs ? errorSection.slice(-maxLogs) : errorSection;
-  return {
-    logs,
-    hasCompileError
-  };
-}
-__name(readRecentErrorLogs, "readRecentErrorLogs");
-function checkForErrors(logs) {
-  for (const line of logs) {
-    const compileErrorMatch = line.match(/Found (\d+) errors?\. Watching for file changes/);
-    if (compileErrorMatch) {
-      const errorCount = parseInt(compileErrorMatch[1], 10);
-      if (errorCount > 0) {
-        console.log(`[Proxy Error]: Found ${errorCount} compilation error(s)`);
-        return true;
-      }
-    }
-  }
-  return false;
+function send502Json(res) {
+  if (res.headersSent) return;
+  res.writeHead(502, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-cache, no-store, must-revalidate"
+  });
+  res.end(JSON.stringify({
+    error: "Bad Gateway",
+    message: "Backend service is temporarily unavailable"
+  }));
 }
-__name(checkForErrors, "checkForErrors");
-function injectTemplateData(template, clientBasePath, parentOrigin) {
-  return template.replace("{{.clientBasePath}}", clientBasePath).replace("{{.parentOrigin}}", parentOrigin);
+__name(send502Json, "send502Json");
+function sendRedirect(req, res) {
+  if (res.headersSent) return;
+  const originalUrl = req.url || "/";
+  console.log("[Proxy] Service recovered, redirecting to", originalUrl);
+  res.writeHead(302, {
+    "Location": originalUrl,
+    "Cache-Control": "no-cache, no-store, must-revalidate"
+  });
+  res.end();
 }
-__name(injectTemplateData, "injectTemplateData");
+__name(sendRedirect, "sendRedirect");
 function handleDevProxyError(err, req, res, options) {
-  const { logDir = import_node_path3.default.join(process.cwd(), "logs"), maxErrorLogs = 100, logFileName = "server.log", retryTimeout = 5e3, retryInterval = 500, target = `http://localhost:${process.env.SERVER_PORT || 3e3}`, clientBasePath = process.env.CLIENT_BASE_PATH || "/" } = options || {};
-  const clientBasePathWithoutSlash = normalizeBasePath(clientBasePath);
-  console.error("[Proxy Error]:", err.message, clientBasePathWithoutSlash);
+  const { retryTimeout = 5e3, retryInterval = 500, target = `http://localhost:${process.env.SERVER_PORT || 3e3}` } = options || {};
+  console.error("[Proxy] Error:", err.message);
   if (res.headersSent) {
-    console.error("[Proxy Error]: Headers already sent, cannot send error page");
+    console.error("[Proxy] Headers already sent, cannot handle error");
+    return;
+  }
+  if (!isConnectionError(err)) {
+    console.log("[Proxy] Non-connection error, returning 502");
+    send502Json(res);
     return;
   }
+  console.log("[Proxy] Connection error, waiting for service recovery...");
   (async () => {
     try {
-      const isConnError = isConnectionError(err);
-      const { hasCompileError } = await readRecentErrorLogs(logDir, maxErrorLogs, logFileName);
-      if (isConnError && !hasCompileError) {
-        console.log("[Proxy Error]: Connection error without compile errors, possibly server restarting...");
-        try {
-          new URL(target);
-        } catch (e) {
-          console.error("[Proxy Error]: Invalid target URL:", target);
-          console.log("[Proxy Error]: Showing error page due to invalid target");
-        }
-        console.log(`[Proxy Error]: Waiting for service recovery at ${target} (timeout: ${retryTimeout}ms)...`);
-        const recovered = await waitForServiceRecovery(target, retryTimeout, retryInterval);
-        if (recovered) {
-          console.log("[Proxy Error]: Service recovered within timeout, sending 302 redirect");
-          sendSimpleRedirect(req, res);
-          return;
-        }
-        console.log("[Proxy Error]: Service did not recover within timeout, showing error page with probe");
-      }
-      if (isConnError && !hasCompileError) {
-        console.log("[Proxy Error]: Showing error page with auto-refresh probe");
+      const recovered = await waitForServiceRecovery(target, retryTimeout, retryInterval);
+      if (recovered) {
+        sendRedirect(req, res);
       } else {
-        console.log("[Proxy Error]: Compile error or non-connection error, showing error page");
+        console.log("[Proxy] Service did not recover within timeout, returning 502");
+        send502Json(res);
       }
-      const template = getErrorHtmlTemplate();
-      const parentOrigin = process.env.FORCE_FRAMEWORK_DOMAIN_MAIN || "";
-      const html = injectTemplateData(template, clientBasePathWithoutSlash, parentOrigin);
-      res.writeHead(200, {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "no-cache, no-store, must-revalidate",
-        "X-Proxy-Error-Page": "true"
-      });
-      res.end(html);
     } catch (error) {
-      console.error("[Proxy Error]: Failed to handle error:", error);
-      if (!res.headersSent) {
-        res.writeHead(502, {
-          "Content-Type": "text/plain; charset=utf-8"
-        });
-        res.end(`Node \u670D\u52A1\u542F\u52A8\u5F02\u5E38\uFF0C\u8BF7\u6839\u636E\u65E5\u5FD7\u4FEE\u590D\u76F8\u5173\u95EE\u9898`);
-      }
+      console.error("[Proxy] Error during recovery wait:", error);
+      send502Json(res);
     }
   })();
 }
 __name(handleDevProxyError, "handleDevProxyError");
-function sendSimpleRedirect(req, res) {
-  if (res.headersSent) return;
-  const originalUrl = req.url || "/";
-  console.log("[Proxy Error]: Sending 302 redirect to", originalUrl);
-  res.writeHead(302, {
-    "Location": originalUrl,
-    "Cache-Control": "no-cache, no-store, must-revalidate"
-  });
-  res.end();
-}
-__name(sendSimpleRedirect, "sendSimpleRedirect");
 
 // src/middlewares/index.ts
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 
 // src/middlewares/openapi/router.ts
 var import_express = __toESM(require("express"), 1);
@@ -1517,21 +1380,21 @@ var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_crypto = __toESM(require("crypto"), 1);
 
 // src/middlewares/openapi/services.ts
-var import_node_fs5 = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs4 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
 var import_typescript = __toESM(require("typescript"), 1);
 
 // src/middlewares/openapi/utils.ts
-var import_node_path4 = __toESM(require("path"), 1);
-var import_node_fs4 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_fs3 = require("fs");
 async function findControllerFiles(dir) {
   const files = [];
   async function scan(currentDir) {
-    const entries = await import_node_fs4.promises.readdir(currentDir, {
+    const entries = await import_node_fs3.promises.readdir(currentDir, {
       withFileTypes: true
     });
     for (const entry of entries) {
-      const fullPath = import_node_path4.default.join(currentDir, entry.name);
+      const fullPath = import_node_path3.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         await scan(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".controller.ts")) {
@@ -1623,21 +1486,21 @@ __name(transformOpenapiPaths, "transformOpenapiPaths");
 // src/middlewares/openapi/services.ts
 async function enhanceOpenApiWithSourceInfo(options = {}) {
   const startTime = Date.now();
-  const openapiPath = options.openapiPath || import_node_path5.default.resolve(__dirname, "../client/src/api/gen/openapi.json");
-  const serverDir = options.serverDir || import_node_path5.default.resolve(__dirname, "../server");
+  const openapiPath = options.openapiPath || import_node_path4.default.resolve(__dirname, "../client/src/api/gen/openapi.json");
+  const serverDir = options.serverDir || import_node_path4.default.resolve(__dirname, "../server");
   const writeFile2 = options.writeFile !== false;
   let openapi;
   if (options.openapiData) {
     openapi = JSON.parse(JSON.stringify(options.openapiData));
   } else {
-    const openapiContent = await import_node_fs5.promises.readFile(openapiPath, "utf-8");
+    const openapiContent = await import_node_fs4.promises.readFile(openapiPath, "utf-8");
     openapi = JSON.parse(openapiContent);
   }
   const controllerFiles = await findControllerFiles(serverDir);
   const sourceMap = await buildSourceMap(controllerFiles, processControllerFile);
   const enhanced = enhanceOpenApiPaths(openapi, sourceMap);
   if (writeFile2) {
-    await import_node_fs5.promises.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
+    await import_node_fs4.promises.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
   }
   const duration = Date.now() - startTime;
   return {
@@ -1652,8 +1515,8 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
 }
 __name(enhanceOpenApiWithSourceInfo, "enhanceOpenApiWithSourceInfo");
 async function processControllerFile(filePath) {
-  const relativePath = import_node_path5.default.relative(process.cwd(), filePath);
-  const content = await import_node_fs5.promises.readFile(filePath, "utf-8");
+  const relativePath = import_node_path4.default.relative(process.cwd(), filePath);
+  const content = await import_node_fs4.promises.readFile(filePath, "utf-8");
   const sourceFile = import_typescript.default.createSourceFile(filePath, content, import_typescript.default.ScriptTarget.Latest, true);
   return extractControllerMetadata(sourceFile, relativePath);
 }
@@ -1818,8 +1681,8 @@ __name(createOpenapiMiddleware, "createOpenapiMiddleware");
 var import_express2 = __toESM(require("express"), 1);
 
 // src/middlewares/dev-logs/utils.ts
-var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
 
 // src/middlewares/dev-logs/helper/path-matcher.ts
 function pathPatternToRegex(pattern) {
@@ -1851,33 +1714,33 @@ function hasSpecialPatterns(pattern) {
   return /[{*]/.test(pattern);
 }
 __name(hasSpecialPatterns, "hasSpecialPatterns");
-function normalizePathForMatching(path8) {
-  return path8.replace(/\/+/g, "/").replace(/\/+$/, "");
+function normalizePathForMatching(path7) {
+  return path7.replace(/\/+/g, "/").replace(/\/+$/, "");
 }
 __name(normalizePathForMatching, "normalizePathForMatching");
 
 // src/middlewares/dev-logs/utils.ts
 function resolveLogDir(provided) {
   if (!provided) {
-    return (0, import_node_path6.join)(process.cwd(), "logs");
+    return (0, import_node_path5.join)(process.cwd(), "logs");
   }
-  return (0, import_node_path6.isAbsolute)(provided) ? provided : (0, import_node_path6.join)(process.cwd(), provided);
+  return (0, import_node_path5.isAbsolute)(provided) ? provided : (0, import_node_path5.join)(process.cwd(), provided);
 }
 __name(resolveLogDir, "resolveLogDir");
 function getRelativePath(filePath) {
-  return (0, import_node_path6.relative)(process.cwd(), filePath);
+  return (0, import_node_path5.relative)(process.cwd(), filePath);
 }
 __name(getRelativePath, "getRelativePath");
 async function fileExists(filePath) {
   try {
-    await import_node_fs6.promises.access(filePath);
+    await import_node_fs5.promises.access(filePath);
     return true;
   } catch {
     return false;
   }
 }
 __name(fileExists, "fileExists");
-function parseLogLine2(line) {
+function parseLogLine(line) {
   const trimmed = line.trim();
   if (!trimmed) return void 0;
   try {
@@ -1886,7 +1749,7 @@ function parseLogLine2(line) {
     return void 0;
   }
 }
-__name(parseLogLine2, "parseLogLine");
+__name(parseLogLine, "parseLogLine");
 function extractNumber(message, pattern) {
   if (typeof message !== "string") return void 0;
   const match = message.match(pattern);
@@ -1920,8 +1783,8 @@ function resolveLogFilePath(baseDir, fileName) {
   if (segments.some((segment) => segment === "..")) {
     throw new Error("Invalid log file path");
   }
-  const resolved = (0, import_node_path6.join)(baseDir, segments.join("/"));
-  const rel = (0, import_node_path6.relative)(baseDir, resolved);
+  const resolved = (0, import_node_path5.join)(baseDir, segments.join("/"));
+  const rel = (0, import_node_path5.relative)(baseDir, resolved);
   if (rel.startsWith("..")) {
     throw new Error("Access to the specified log file is denied");
   }
@@ -1950,12 +1813,12 @@ function serializeError(error) {
 __name(serializeError, "serializeError");
 
 // src/middlewares/dev-logs/controller.ts
-var import_node_path8 = require("path");
+var import_node_path7 = require("path");
 
 // src/middlewares/dev-logs/services/file-reader.ts
-var import_node_fs7 = require("fs");
+var import_node_fs6 = require("fs");
 async function readFileReverse(filePath, chunkSize, processLine) {
-  const handle = await import_node_fs7.promises.open(filePath, "r");
+  const handle = await import_node_fs6.promises.open(filePath, "r");
   try {
     const stats = await handle.stat();
     let position = stats.size;
@@ -2137,7 +2000,7 @@ function parseStdLog(line, source) {
 __name(parseStdLog, "parseStdLog");
 
 // src/middlewares/dev-logs/services/trace.service.ts
-var import_node_fs8 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_readline = require("readline");
 async function readLogEntriesByTrace(filePath, traceId, limit) {
   const exists = await fileExists(filePath);
@@ -2145,7 +2008,7 @@ async function readLogEntriesByTrace(filePath, traceId, limit) {
     return void 0;
   }
   const matches = [];
-  const stream = (0, import_node_fs8.createReadStream)(filePath, {
+  const stream = (0, import_node_fs7.createReadStream)(filePath, {
     encoding: "utf8"
   });
   const rl = (0, import_node_readline.createInterface)({
@@ -2153,7 +2016,7 @@ async function readLogEntriesByTrace(filePath, traceId, limit) {
     crlfDelay: Infinity
   });
   for await (const line of rl) {
-    const entry = parseLogLine2(line);
+    const entry = parseLogLine(line);
     if (!entry) continue;
     if (entry.trace_id !== traceId) continue;
     matches.push(entry);
@@ -2227,7 +2090,7 @@ async function readRecentTraceCalls(filePath, page, pageSize, pathFilter, method
     }
   }, "processLogEntry");
   const processLine = /* @__PURE__ */ __name((line) => {
-    const entry = parseLogLine2(line);
+    const entry = parseLogLine(line);
     if (entry?.trace_id) {
       processLogEntry(entry);
     }
@@ -2243,7 +2106,7 @@ async function readLogFilePage(filePath, page, pageSize) {
   const capacity = page * pageSize;
   const buffer = [];
   let totalLines = 0;
-  const stream = (0, import_node_fs8.createReadStream)(filePath, {
+  const stream = (0, import_node_fs7.createReadStream)(filePath, {
     encoding: "utf8"
   });
   const rl = (0, import_node_readline.createInterface)({
@@ -2293,9 +2156,9 @@ async function readLogFilePage(filePath, page, pageSize) {
 __name(readLogFilePage, "readLogFilePage");
 
 // src/middlewares/dev-logs/services/server-log.service.ts
-var import_node_fs9 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_readline2 = require("readline");
-var import_node_path7 = require("path");
+var import_node_path6 = require("path");
 async function readServerLogs(logDir, options = {}) {
   const limit = options.limit || 100;
   const offset = options.offset || 0;
@@ -2341,16 +2204,16 @@ async function readLogsBySource(logDir, source) {
   let filePath;
   let parser;
   if (source === "server") {
-    filePath = (0, import_node_path7.join)(logDir, "server.log");
+    filePath = (0, import_node_path6.join)(logDir, "server.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "server"), "parser");
   } else if (source === "trace") {
-    filePath = (0, import_node_path7.join)(logDir, "trace.log");
+    filePath = (0, import_node_path6.join)(logDir, "trace.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "trace"), "parser");
   } else if (source === "server-std") {
-    filePath = (0, import_node_path7.join)(logDir, "server.std.log");
+    filePath = (0, import_node_path6.join)(logDir, "server.std.log");
     parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "server-std"), "parser");
   } else if (source === "client-std") {
-    filePath = (0, import_node_path7.join)(logDir, "client.std.log");
+    filePath = (0, import_node_path6.join)(logDir, "client.std.log");
     parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "client-std"), "parser");
   } else {
     console.warn(`[readLogsBySource] Unknown source: ${source}`);
@@ -2364,7 +2227,7 @@ async function readLogsBySource(logDir, source) {
   let stream = null;
   let rl = null;
   try {
-    stream = (0, import_node_fs9.createReadStream)(filePath, {
+    stream = (0, import_node_fs8.createReadStream)(filePath, {
       encoding: "utf8"
     });
     rl = (0, import_node_readline2.createInterface)({
@@ -2397,9 +2260,9 @@ async function readLogsBySource(logDir, source) {
 __name(readLogsBySource, "readLogsBySource");
 
 // src/middlewares/dev-logs/services/trigger.service.ts
-var import_node_fs10 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_readline3 = require("readline");
-async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
+async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
   if (!await fileExists(filePath)) {
     return void 0;
   }
@@ -2425,7 +2288,7 @@ async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
     if (alreadyAdded) {
       return false;
     }
-    const isAutomationTrigger = builder.path?.endsWith(path8);
+    const isAutomationTrigger = builder.path?.endsWith(path7);
     if (!isAutomationTrigger) {
       return false;
     }
@@ -2484,7 +2347,7 @@ async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
     }
   }, "processLogEntry");
   const processLine = /* @__PURE__ */ __name((line) => {
-    const entry = parseLogLine2(line);
+    const entry = parseLogLine(line);
     if (entry?.trace_id) {
       processLogEntry(entry);
     }
@@ -2508,13 +2371,13 @@ async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
   };
 }
 __name(readTriggerList, "readTriggerList");
-async function readTriggerDetail(filePath, path8, instanceID) {
+async function readTriggerDetail(filePath, path7, instanceID) {
   const exists = await fileExists(filePath);
   if (!exists) {
     return void 0;
   }
   const matches = [];
-  const stream = (0, import_node_fs10.createReadStream)(filePath, {
+  const stream = (0, import_node_fs9.createReadStream)(filePath, {
     encoding: "utf8"
   });
   const rl = (0, import_node_readline3.createInterface)({
@@ -2522,9 +2385,9 @@ async function readTriggerDetail(filePath, path8, instanceID) {
     crlfDelay: Infinity
   });
   for await (const line of rl) {
-    const entry = parseLogLine2(line);
+    const entry = parseLogLine(line);
     if (!entry) continue;
-    const isAutomationTrigger = entry.path?.endsWith(path8);
+    const isAutomationTrigger = entry.path?.endsWith(path7);
     const hasInstanceID = entry.instance_id === instanceID && entry.trigger;
     if (!isAutomationTrigger || !hasInstanceID) continue;
     matches.push(entry);
@@ -2618,7 +2481,7 @@ async function readCapabilityTraceList(filePath, capabilityId, limit) {
     updateBuilderMetadata(builder, entry);
   }, "processLogEntry");
   const processLine = /* @__PURE__ */ __name((line) => {
-    const entry = parseLogLine2(line);
+    const entry = parseLogLine(line);
     if (entry?.capability_id) {
       processLogEntry(entry);
     }
@@ -2665,7 +2528,7 @@ function handleError(res, error, message = "Failed to read log file") {
 }
 __name(handleError, "handleError");
 function createGetTraceEntriesHandler(logDir) {
-  const appLogPath = (0, import_node_path8.join)(logDir, "server.log");
+  const appLogPath = (0, import_node_path7.join)(logDir, "server.log");
   return async (req, res) => {
     const traceId = (req.params.traceId || "").trim();
     if (!traceId) {
@@ -2692,7 +2555,7 @@ function createGetTraceEntriesHandler(logDir) {
 }
 __name(createGetTraceEntriesHandler, "createGetTraceEntriesHandler");
 function createGetRecentTracesHandler(logDir) {
-  const traceLogPath = (0, import_node_path8.join)(logDir, "trace.log");
+  const traceLogPath = (0, import_node_path7.join)(logDir, "trace.log");
   return async (req, res) => {
     const page = parsePositiveInt(req.query.page, 1);
     const pageSize = parseLimit(req.query.pageSize, 10, 100);
@@ -2769,7 +2632,7 @@ function createGetServerLogsHandler(logDir) {
 }
 __name(createGetServerLogsHandler, "createGetServerLogsHandler");
 function createGetTriggerListHandler(logDir) {
-  const traceLogPath = (0, import_node_path8.join)(logDir, "trace.log");
+  const traceLogPath = (0, import_node_path7.join)(logDir, "trace.log");
   return async (req, res) => {
     const trigger = typeof req.query.trigger === "string" ? req.query.trigger.trim() : void 0;
     if (!trigger) {
@@ -2778,16 +2641,16 @@ function createGetTriggerListHandler(logDir) {
       });
     }
     const triggerID = typeof req.query.triggerID === "string" ? req.query.triggerID.trim() : void 0;
-    const path8 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    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, path8, limit, triggerID);
+      const result = await readTriggerList(traceLogPath, trigger, path7, limit, triggerID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
       res.json({
         file: getRelativePath(traceLogPath),
-        path: path8,
+        path: path7,
         ...result
       });
     } catch (error) {
@@ -2797,7 +2660,7 @@ function createGetTriggerListHandler(logDir) {
 }
 __name(createGetTriggerListHandler, "createGetTriggerListHandler");
 function createGetTriggerDetailHandler(logDir) {
-  const traceLogPath = (0, import_node_path8.join)(logDir, "server.log");
+  const traceLogPath = (0, import_node_path7.join)(logDir, "server.log");
   return async (req, res) => {
     const instanceID = (req.params.instanceID || "").trim();
     if (!instanceID) {
@@ -2805,9 +2668,9 @@ function createGetTriggerDetailHandler(logDir) {
         message: "instanceID is required"
       });
     }
-    const path8 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     try {
-      const result = await readTriggerDetail(traceLogPath, path8, instanceID);
+      const result = await readTriggerDetail(traceLogPath, path7, instanceID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
@@ -2822,7 +2685,7 @@ function createGetTriggerDetailHandler(logDir) {
 }
 __name(createGetTriggerDetailHandler, "createGetTriggerDetailHandler");
 function createGetCapabilityTraceListHandler(logDir) {
-  const serverLogPath = (0, import_node_path8.join)(logDir, "server.log");
+  const serverLogPath = (0, import_node_path7.join)(logDir, "server.log");
   return async (req, res) => {
     const capabilityId = typeof req.query.capability_id === "string" ? req.query.capability_id.trim() : void 0;
     if (!capabilityId) {
@@ -2848,11 +2711,11 @@ function createGetCapabilityTraceListHandler(logDir) {
 __name(createGetCapabilityTraceListHandler, "createGetCapabilityTraceListHandler");
 
 // src/middlewares/dev-logs/health.controller.ts
-var import_node_http2 = __toESM(require("http"), 1);
+var import_node_http = __toESM(require("http"), 1);
 function checkServiceHealth(host, port, timeout) {
   return new Promise((resolve) => {
     const startTime = Date.now();
-    const req = import_node_http2.default.request({
+    const req = import_node_http.default.request({
       hostname: host,
       port,
       path: "/",
@@ -2915,8 +2778,8 @@ 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);
+var fs8 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
 function mapPinoLevelToServerLogLevel2(pinoLevel) {
   if (typeof pinoLevel === "string") {
     const lower = pinoLevel.toLowerCase();
@@ -3131,13 +2994,13 @@ var LogWatcher = class {
   * Watch a single log file
   */
   watchFile(config) {
-    const filePath = path6.join(this.logDir, config.fileName);
-    if (!fs9.existsSync(filePath)) {
+    const filePath = path5.join(this.logDir, config.fileName);
+    if (!fs8.existsSync(filePath)) {
       this.log(`File not found, skipping: ${config.fileName}`);
       return;
     }
     try {
-      const stats = fs9.statSync(filePath);
+      const stats = fs8.statSync(filePath);
       this.filePositions.set(config.fileName, stats.size);
       this.log(`Initialized position for ${config.fileName}: ${stats.size} bytes`);
     } catch (error) {
@@ -3145,7 +3008,7 @@ var LogWatcher = class {
       this.filePositions.set(config.fileName, 0);
     }
     try {
-      const watcher = fs9.watch(filePath, (eventType) => {
+      const watcher = fs8.watch(filePath, (eventType) => {
         if (eventType === "change") {
           this.handleFileChange(config);
         }
@@ -3180,10 +3043,10 @@ var LogWatcher = class {
   * Handle file change event - read new content
   */
   handleFileChange(config) {
-    const filePath = path6.join(this.logDir, config.fileName);
+    const filePath = path5.join(this.logDir, config.fileName);
     const lastPosition = this.filePositions.get(config.fileName) || 0;
     try {
-      const stats = fs9.statSync(filePath);
+      const stats = fs8.statSync(filePath);
       const currentSize = stats.size;
       if (currentSize < lastPosition) {
         this.log(`File ${config.fileName} was truncated, resetting position`);
@@ -3196,11 +3059,11 @@ var LogWatcher = class {
       }
       const readSize = currentSize - lastPosition;
       const buffer = Buffer.alloc(readSize);
-      const fd = fs9.openSync(filePath, "r");
+      const fd = fs8.openSync(filePath, "r");
       try {
-        fs9.readSync(fd, buffer, 0, readSize, lastPosition);
+        fs8.readSync(fd, buffer, 0, readSize, lastPosition);
       } finally {
-        fs9.closeSync(fd);
+        fs8.closeSync(fd);
       }
       this.filePositions.set(config.fileName, currentSize);
       const content = buffer.toString("utf8");
@@ -3503,18 +3366,18 @@ var import_path2 = require("path");
 var import_fs2 = __toESM(require("fs"), 1);
 
 // src/middlewares/collect-logs/utils.ts
-var import_node_path9 = require("path");
-var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path8 = require("path");
+var import_node_fs10 = __toESM(require("fs"), 1);
 function resolveLogDir2(provided) {
   if (!provided) {
-    return (0, import_node_path9.join)(process.cwd(), "logs");
+    return (0, import_node_path8.join)(process.cwd(), "logs");
   }
-  return (0, import_node_path9.isAbsolute)(provided) ? provided : (0, import_node_path9.join)(process.cwd(), provided);
+  return (0, import_node_path8.isAbsolute)(provided) ? provided : (0, import_node_path8.join)(process.cwd(), provided);
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
-  if (!import_node_fs11.default.existsSync(dir)) {
-    import_node_fs11.default.mkdirSync(dir, {
+  if (!import_node_fs10.default.existsSync(dir)) {
+    import_node_fs10.default.mkdirSync(dir, {
       recursive: true
     });
   }
@@ -3637,7 +3500,7 @@ function isGlobalMiddleware(middleware) {
 }
 __name(isGlobalMiddleware, "isGlobalMiddleware");
 function computeMountPath(basePath, mountPath) {
-  const routePath = import_node_path10.default.posix.join(basePath, mountPath);
+  const routePath = import_node_path9.default.posix.join(basePath, mountPath);
   return routePath.startsWith("/") ? routePath : `/${routePath}`;
 }
 __name(computeMountPath, "computeMountPath");
@@ -3645,7 +3508,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 : import_node_path10.default.posix.join(fullMountPath, route.path);
+      const routePath = route.path === "/" ? fullMountPath : import_node_path9.default.posix.join(fullMountPath, route.path);
       console.log(`  ${route.method} ${routePath} - ${route.description}`);
     });
   } else {