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

package/dist/index.js

@@ -1220,11 +1220,8 @@ async function parseAndGenerateNestResourceTemplate(options) {
 __name(parseAndGenerateNestResourceTemplate, "parseAndGenerateNestResourceTemplate");
 
 // src/helpers/proxy-error/index.ts
-import fs3 from "fs";
-import path3 from "path";
-import http from "http";
-import https from "https";
-var errorHtmlTemplate = null;
+import * as http from "http";
+import * as https from "https";
 function isConnectionError(err) {
   const code = err.code;
   const connectionErrorCodes = [
@@ -1237,7 +1234,7 @@ 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);
@@ -1250,8 +1247,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();
@@ -1261,7 +1257,7 @@ function checkServiceAvailable(targetUrl, timeout = 1e3) {
         resolve(false);
       });
       req.end();
-    } catch (e) {
+    } catch {
       resolve(false);
     }
   });
@@ -1279,218 +1275,85 @@ 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 = path3.join(dirname, "error.html");
-    errorHtmlTemplate = fs3.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 = path3.join(logDir, fileName);
-  let fileStats;
-  try {
-    fileStats = await fs3.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 fs3.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 = path3.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
-import path7 from "path";
+import path6 from "path";
 
 // src/middlewares/openapi/router.ts
 import express from "express";
 
 // src/middlewares/openapi/controller.ts
-import fs6 from "fs/promises";
+import fs5 from "fs/promises";
 import crypto from "crypto";
 
 // src/middlewares/openapi/services.ts
-import { promises as fs5 } from "fs";
-import path5 from "path";
+import { promises as fs4 } from "fs";
+import path4 from "path";
 import ts from "typescript";
 
 // src/middlewares/openapi/utils.ts
-import path4 from "path";
-import { promises as fs4 } from "fs";
+import path3 from "path";
+import { promises as fs3 } from "fs";
 async function findControllerFiles(dir) {
   const files = [];
   async function scan(currentDir) {
-    const entries = await fs4.readdir(currentDir, {
+    const entries = await fs3.readdir(currentDir, {
       withFileTypes: true
     });
     for (const entry of entries) {
-      const fullPath = path4.join(currentDir, entry.name);
+      const fullPath = path3.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         await scan(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".controller.ts")) {
@@ -1582,21 +1445,21 @@ __name(transformOpenapiPaths, "transformOpenapiPaths");
 // src/middlewares/openapi/services.ts
 async function enhanceOpenApiWithSourceInfo(options = {}) {
   const startTime = Date.now();
-  const openapiPath = options.openapiPath || path5.resolve(__dirname, "../client/src/api/gen/openapi.json");
-  const serverDir = options.serverDir || path5.resolve(__dirname, "../server");
+  const openapiPath = options.openapiPath || path4.resolve(__dirname, "../client/src/api/gen/openapi.json");
+  const serverDir = options.serverDir || path4.resolve(__dirname, "../server");
   const writeFile2 = options.writeFile !== false;
   let openapi;
   if (options.openapiData) {
     openapi = JSON.parse(JSON.stringify(options.openapiData));
   } else {
-    const openapiContent = await fs5.readFile(openapiPath, "utf-8");
+    const openapiContent = await fs4.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 fs5.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
+    await fs4.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
   }
   const duration = Date.now() - startTime;
   return {
@@ -1611,8 +1474,8 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
 }
 __name(enhanceOpenApiWithSourceInfo, "enhanceOpenApiWithSourceInfo");
 async function processControllerFile(filePath) {
-  const relativePath = path5.relative(process.cwd(), filePath);
-  const content = await fs5.readFile(filePath, "utf-8");
+  const relativePath = path4.relative(process.cwd(), filePath);
+  const content = await fs4.readFile(filePath, "utf-8");
   const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
   return extractControllerMetadata(sourceFile, relativePath);
 }
@@ -1705,7 +1568,7 @@ function createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir) {
   let cache = null;
   return async (_req, res, context) => {
     try {
-      const fileBuffer = await fs6.readFile(openapiFilePath, "utf-8");
+      const fileBuffer = await fs5.readFile(openapiFilePath, "utf-8");
       const currentHash = crypto.createHash("md5").update(fileBuffer).digest("hex");
       if (cache && cache.fileHash === currentHash) {
         return res.json(cache.data);
@@ -1777,7 +1640,7 @@ __name(createOpenapiMiddleware, "createOpenapiMiddleware");
 import express2 from "express";
 
 // src/middlewares/dev-logs/utils.ts
-import { promises as fs7 } from "fs";
+import { promises as fs6 } from "fs";
 import { isAbsolute, join as join2, relative } from "path";
 
 // src/middlewares/dev-logs/helper/path-matcher.ts
@@ -1810,8 +1673,8 @@ 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");
 
@@ -1829,14 +1692,14 @@ function getRelativePath(filePath) {
 __name(getRelativePath, "getRelativePath");
 async function fileExists(filePath) {
   try {
-    await fs7.access(filePath);
+    await fs6.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 {
@@ -1845,7 +1708,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);
@@ -1912,9 +1775,9 @@ __name(serializeError, "serializeError");
 import { join as join4 } from "path";
 
 // src/middlewares/dev-logs/services/file-reader.ts
-import { promises as fs8 } from "fs";
+import { promises as fs7 } from "fs";
 async function readFileReverse(filePath, chunkSize, processLine) {
-  const handle = await fs8.open(filePath, "r");
+  const handle = await fs7.open(filePath, "r");
   try {
     const stats = await handle.stat();
     let position = stats.size;
@@ -2112,7 +1975,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);
@@ -2186,7 +2049,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);
     }
@@ -2358,7 +2221,7 @@ __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, path8, limit, triggerID) {
+async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
   if (!await fileExists(filePath)) {
     return void 0;
   }
@@ -2384,7 +2247,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;
     }
@@ -2443,7 +2306,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);
     }
@@ -2467,7 +2330,7 @@ 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;
@@ -2481,9 +2344,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);
@@ -2577,7 +2440,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);
     }
@@ -2737,16 +2600,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) {
@@ -2764,9 +2627,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);
       }
@@ -2874,8 +2737,8 @@ function createHealthCheckHandler(options = {}) {
 __name(createHealthCheckHandler, "createHealthCheckHandler");
 
 // src/middlewares/dev-logs/sse/log-watcher.ts
-import * as fs9 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path5 from "path";
 function mapPinoLevelToServerLogLevel2(pinoLevel) {
   if (typeof pinoLevel === "string") {
     const lower = pinoLevel.toLowerCase();
@@ -3090,13 +2953,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) {
@@ -3104,7 +2967,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);
         }
@@ -3139,10 +3002,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`);
@@ -3155,11 +3018,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");
@@ -3459,11 +3322,11 @@ import express3 from "express";
 
 // src/middlewares/collect-logs/controller.ts
 import { join as join7 } from "path";
-import fs11 from "fs";
+import fs10 from "fs";
 
 // src/middlewares/collect-logs/utils.ts
 import { isAbsolute as isAbsolute2, join as join6 } from "path";
-import fs10 from "fs";
+import fs9 from "fs";
 function resolveLogDir2(provided) {
   if (!provided) {
     return join6(process.cwd(), "logs");
@@ -3472,8 +3335,8 @@ function resolveLogDir2(provided) {
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, {
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, {
       recursive: true
     });
   }
@@ -3505,7 +3368,7 @@ function collectLogsHandler(logDir, fileName) {
         ...logContent,
         server_time: (/* @__PURE__ */ new Date()).toISOString()
       }) + "\n";
-      await fs11.promises.appendFile(filePath, logLine);
+      await fs10.promises.appendFile(filePath, logLine);
       res.json({
         success: true
       });
@@ -3533,7 +3396,7 @@ function collectLogsBatchHandler(logDir, fileName) {
           server_time: (/* @__PURE__ */ new Date()).toISOString()
         }) + "\n");
       }
-      await fs11.promises.appendFile(filePath, logLines.join(""));
+      await fs10.promises.appendFile(filePath, logLines.join(""));
       res.json({
         success: true
       });
@@ -3596,7 +3459,7 @@ function isGlobalMiddleware(middleware) {
 }
 __name(isGlobalMiddleware, "isGlobalMiddleware");
 function computeMountPath(basePath, mountPath) {
-  const routePath = path7.posix.join(basePath, mountPath);
+  const routePath = path6.posix.join(basePath, mountPath);
   return routePath.startsWith("/") ? routePath : `/${routePath}`;
 }
 __name(computeMountPath, "computeMountPath");
@@ -3604,7 +3467,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 : path7.posix.join(fullMountPath, route.path);
+      const routePath = route.path === "/" ? fullMountPath : path6.posix.join(fullMountPath, route.path);
       console.log(`  ${route.method} ${routePath} - ${route.description}`);
     });
   } else {