@lark-apaas/devtool-kits 1.2.12 → 1.2.13

package/dist/index.js

@@ -1908,10 +1908,194 @@ function serializeError(error) {
 __name(serializeError, "serializeError");
 
 // src/middlewares/dev-logs/controller.ts
-import { join as join3 } from "path";
+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.ts
-import { createReadStream, promises as fs8 } from "fs";
+// 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");
+
+// src/middlewares/dev-logs/services/trace.service.ts
+import { createReadStream } from "fs";
 import { createInterface } from "readline";
 async function readLogEntriesByTrace(filePath, traceId, limit) {
   const exists = await fileExists(filePath);
@@ -2010,62 +2194,6 @@ 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;
@@ -2121,6 +2249,11 @@ 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;
@@ -2163,20 +2296,19 @@ 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 = join7(logDir, "server.log");
+    filePath = join3(logDir, "server.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "server"), "parser");
   } else if (source === "trace") {
-    filePath = join7(logDir, "trace.log");
+    filePath = join3(logDir, "trace.log");
     parser = /* @__PURE__ */ __name((line) => parsePinoLog(line, "trace"), "parser");
   } else if (source === "server-std") {
-    filePath = join7(logDir, "server.std.log");
+    filePath = join3(logDir, "server.std.log");
     parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "server-std"), "parser");
   } else if (source === "client-std") {
-    filePath = join7(logDir, "client.std.log");
+    filePath = join3(logDir, "client.std.log");
     parser = /* @__PURE__ */ __name((line) => parseStdLog(line, "client-std"), "parser");
   } else {
     console.warn(`[readLogsBySource] Unknown source: ${source}`);
@@ -2190,10 +2322,10 @@ async function readLogsBySource(logDir, source) {
   let stream = null;
   let rl = null;
   try {
-    stream = createReadStream(filePath, {
+    stream = createReadStream2(filePath, {
       encoding: "utf8"
     });
-    rl = createInterface({
+    rl = createInterface2({
       input: stream,
       crlfDelay: Infinity
     });
@@ -2221,129 +2353,10 @@ async function readLogsBySource(logDir, source) {
   return logs;
 }
 __name(readLogsBySource, "readLogsBySource");
-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");
+
+// 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) {
   if (!await fileExists(filePath)) {
     return void 0;
@@ -2459,10 +2472,10 @@ async function readTriggerDetail(filePath, path8, instanceID) {
     return void 0;
   }
   const matches = [];
-  const stream = createReadStream(filePath, {
+  const stream = createReadStream3(filePath, {
     encoding: "utf8"
   });
-  const rl = createInterface({
+  const rl = createInterface3({
     input: stream,
     crlfDelay: Infinity
   });
@@ -2483,6 +2496,118 @@ async function readTriggerDetail(filePath, path8, instanceID) {
 }
 __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);
+    }
+    updateBuilderMetadata(builder, entry);
+  }, "processLogEntry");
+  const processLine = /* @__PURE__ */ __name((line) => {
+    const entry = parseLogLine2(line);
+    if (entry?.capability_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) => ({
+      traceId: builder.traceId,
+      capabilityId: builder.capabilityId,
+      pluginKey: builder.pluginKey,
+      action: builder.action,
+      startTime: builder.startTime,
+      endTime: builder.endTime,
+      durationMs: builder.durationMs,
+      status: builder.status || "failed",
+      input: builder.input,
+      output: builder.output,
+      error: builder.error
+    }))
+  };
+}
+__name(readCapabilityTraceList, "readCapabilityTraceList");
+
 // src/middlewares/dev-logs/controller.ts
 function handleNotFound(res, filePath, message = "Log file not found") {
   res.status(404).json({
@@ -2498,7 +2623,7 @@ function handleError(res, error, message = "Failed to read log file") {
 }
 __name(handleError, "handleError");
 function createGetTraceEntriesHandler(logDir) {
-  const appLogPath = join3(logDir, "server.log");
+  const appLogPath = join4(logDir, "server.log");
   return async (req, res) => {
     const traceId = (req.params.traceId || "").trim();
     if (!traceId) {
@@ -2525,7 +2650,7 @@ function createGetTraceEntriesHandler(logDir) {
 }
 __name(createGetTraceEntriesHandler, "createGetTraceEntriesHandler");
 function createGetRecentTracesHandler(logDir) {
-  const traceLogPath = join3(logDir, "trace.log");
+  const traceLogPath = join4(logDir, "trace.log");
   return async (req, res) => {
     const page = parsePositiveInt(req.query.page, 1);
     const pageSize = parseLimit(req.query.pageSize, 10, 100);
@@ -2602,7 +2727,7 @@ function createGetServerLogsHandler(logDir) {
 }
 __name(createGetServerLogsHandler, "createGetServerLogsHandler");
 function createGetTriggerListHandler(logDir) {
-  const traceLogPath = join3(logDir, "trace.log");
+  const traceLogPath = join4(logDir, "trace.log");
   return async (req, res) => {
     const trigger = typeof req.query.trigger === "string" ? req.query.trigger.trim() : void 0;
     if (!trigger) {
@@ -2630,7 +2755,7 @@ function createGetTriggerListHandler(logDir) {
 }
 __name(createGetTriggerListHandler, "createGetTriggerListHandler");
 function createGetTriggerDetailHandler(logDir) {
-  const traceLogPath = join3(logDir, "server.log");
+  const traceLogPath = join4(logDir, "server.log");
   return async (req, res) => {
     const instanceID = (req.params.instanceID || "").trim();
     if (!instanceID) {
@@ -2654,6 +2779,31 @@ 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";
@@ -3248,6 +3398,7 @@ function createDevLogRouter(options = {}) {
   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;
 }
@@ -3306,17 +3457,17 @@ __name(createDevLogsMiddleware, "createDevLogsMiddleware");
 import express3 from "express";
 
 // src/middlewares/collect-logs/controller.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import fs11 from "fs";
 
 // src/middlewares/collect-logs/utils.ts
-import { isAbsolute as isAbsolute2, join as join5 } from "path";
+import { isAbsolute as isAbsolute2, join as join6 } from "path";
 import fs10 from "fs";
 function resolveLogDir2(provided) {
   if (!provided) {
-    return join5(process.cwd(), "logs");
+    return join6(process.cwd(), "logs");
   }
-  return isAbsolute2(provided) ? provided : join5(process.cwd(), provided);
+  return isAbsolute2(provided) ? provided : join6(process.cwd(), provided);
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
@@ -3339,7 +3490,7 @@ __name(serializeError2, "serializeError");
 
 // src/middlewares/collect-logs/controller.ts
 function collectLogsHandler(logDir, fileName) {
-  const filePath = join6(logDir, fileName);
+  const filePath = join7(logDir, fileName);
   ensureDir(logDir);
   return async (req, res) => {
     try {
@@ -3364,7 +3515,7 @@ function collectLogsHandler(logDir, fileName) {
 }
 __name(collectLogsHandler, "collectLogsHandler");
 function collectLogsBatchHandler(logDir, fileName) {
-  const filePath = join6(logDir, fileName);
+  const filePath = join7(logDir, fileName);
   ensureDir(logDir);
   return async (req, res) => {
     try {