@lark-apaas/fullstack-cli 1.1.6-alpha.13 → 1.1.6-alpha.14

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs18 from "fs";
+import path16 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -3024,22 +3024,859 @@ var migrationCommand = {
   }
 };
 
+// src/commands/read-logs/index.ts
+import path15 from "path";
+
+// src/commands/read-logs/std-utils.ts
+import fs15 from "fs";
+function formatStdPrefixTime(localTime) {
+  const match = localTime.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+  if (!match) return localTime;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  const date = new Date(year, month - 1, day, hour, minute, second, 0);
+  if (Number.isNaN(date.getTime())) return localTime;
+  const pad2 = (n) => String(n).padStart(2, "0");
+  const tzOffsetMinutes = -date.getTimezoneOffset();
+  const sign = tzOffsetMinutes >= 0 ? "+" : "-";
+  const abs = Math.abs(tzOffsetMinutes);
+  const offsetHH = pad2(Math.floor(abs / 60));
+  const offsetMM = pad2(abs % 60);
+  return `${localTime.replace(" ", "T")}${sign}${offsetHH}:${offsetMM}`;
+}
+function stripPrefixFromStdLine(line) {
+  const match = line.match(/^(\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[(server|client)\] )(.*)$/);
+  if (!match) {
+    return line;
+  }
+  const time = formatStdPrefixTime(match[2] || "");
+  const content = match[4] || "";
+  return `[${time}] ${content}`;
+}
+function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
+  const stat = fs15.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], markerFound: false, totalLinesCount: 0 };
+  }
+  const fd = fs15.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let markerFound = false;
+  let finished = false;
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  try {
+    while (position > 0 && !finished) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs15.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const rawLine = parts[i];
+        const line = stripPrefixFromStdLine(rawLine);
+        if (totalLinesCount === 0 && line === "") {
+          continue;
+        }
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+        if (isMarker(line)) {
+          markerFound = true;
+          finished = true;
+          break;
+        }
+      }
+    }
+    if (!finished && remainder) {
+      const line = stripPrefixFromStdLine(remainder);
+      if (!(totalLinesCount === 0 && line === "")) {
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+      }
+      if (isMarker(line)) {
+        markerFound = true;
+      }
+    }
+  } finally {
+    fs15.closeSync(fd);
+  }
+  return { lines: collected.reverse(), markerFound, totalLinesCount };
+}
+
+// src/commands/read-logs/server-std.ts
+function readServerStdSegment(filePath, maxLines, offset) {
+  const marker = (line) => {
+    if (!line) return false;
+    if (/\bdev:server\b/.test(line)) return true;
+    if (line.includes("Starting compilation in watch mode")) return true;
+    if (line.includes("File change detected. Starting incremental compilation")) return true;
+    if (line.includes("Starting Nest application")) return true;
+    if (line.includes("Nest application successfully started")) return true;
+    return false;
+  };
+  const segment = readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, marker);
+  return { lines: segment.lines, totalLinesCount: segment.totalLinesCount };
+}
+
+// src/commands/read-logs/tail.ts
+import fs16 from "fs";
+function fileExists(filePath) {
+  try {
+    fs16.accessSync(filePath, fs16.constants.F_OK | fs16.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readFileTailLines(filePath, maxLines) {
+  const stat = fs16.statSync(filePath);
+  if (stat.size === 0) {
+    return [];
+  }
+  const fd = fs16.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  const chunks = [];
+  let position = stat.size;
+  let collectedLines = 0;
+  try {
+    while (position > 0 && collectedLines <= maxLines) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs16.readSync(fd, buffer, 0, length, position);
+      chunks.unshift(buffer.toString("utf8"));
+      const chunkLines = buffer.toString("utf8").split("\n").length - 1;
+      collectedLines += chunkLines;
+    }
+  } finally {
+    fs16.closeSync(fd);
+  }
+  const content = chunks.join("");
+  const allLines = content.split("\n");
+  if (allLines.length === 0) {
+    return [];
+  }
+  if (allLines[allLines.length - 1] === "") {
+    allLines.pop();
+  }
+  if (allLines.length <= maxLines) {
+    return allLines;
+  }
+  return allLines.slice(allLines.length - maxLines);
+}
+function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
+  const stat = fs16.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs16.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  try {
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs16.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+      }
+    }
+    if (remainder) {
+      const line = remainder.trim();
+      if (line) {
+        totalLinesCount += 1;
+        if (skipped < offset) {
+          skipped += 1;
+        } else if (collected.length < maxLines) {
+          collected.push(line);
+        }
+      }
+    }
+  } finally {
+    fs16.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+
+// src/commands/read-logs/client-std.ts
+function readClientStdSegment(filePath, maxLines, offset) {
+  const lines = readFileTailLines(filePath, Math.max((maxLines + offset) * 5, 2e3));
+  return extractClientStdSegment(lines, maxLines, offset);
+}
+function extractClientStdSegment(lines, maxLines, offset) {
+  const bodyLines = lines.map(stripPrefixFromStdLine);
+  const hotStartMarkers = [
+    /file change detected\..*incremental compilation/i,
+    /starting incremental compilation/i,
+    /starting compilation/i,
+    /\bcompiling\b/i,
+    /\brecompil/i
+  ];
+  const hotEndMarkers = [
+    /file change detected\..*incremental compilation/i,
+    /\bwebpack compiled\b/i,
+    /compiled successfully/i,
+    /compiled with warnings/i,
+    /compiled with errors/i,
+    /failed to compile/i,
+    /fast refresh/i,
+    /\bhmr\b/i,
+    /hot update/i,
+    /\bhot reload\b/i,
+    /\bhmr update\b/i
+  ];
+  const compiledMarkers = [
+    /\bwebpack compiled\b/i,
+    /compiled successfully/i,
+    /compiled with warnings/i,
+    /compiled with errors/i,
+    /failed to compile/i
+  ];
+  let startIndex = -1;
+  for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+    const line = bodyLines[i];
+    if (!line) continue;
+    if (hotStartMarkers.some((re) => re.test(line))) {
+      startIndex = i;
+      break;
+    }
+  }
+  if (startIndex === -1) {
+    let pivotIndex = -1;
+    for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+      const line = bodyLines[i];
+      if (!line) continue;
+      if (hotEndMarkers.some((re) => re.test(line))) {
+        pivotIndex = i;
+        break;
+      }
+    }
+    if (pivotIndex !== -1) {
+      if (compiledMarkers.some((re) => re.test(bodyLines[pivotIndex] ?? ""))) {
+        startIndex = pivotIndex;
+      } else {
+        const searchLimit = 80;
+        const from = Math.max(0, pivotIndex - searchLimit);
+        for (let i = pivotIndex; i >= from; i -= 1) {
+          const line = bodyLines[i];
+          if (!line) continue;
+          if (compiledMarkers.some((re) => re.test(line))) {
+            startIndex = i;
+            break;
+          }
+        }
+        if (startIndex === -1) {
+          startIndex = pivotIndex;
+        }
+      }
+    }
+  }
+  if (startIndex === -1) {
+    for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+      const line = bodyLines[i];
+      if (!line) continue;
+      if (/\bdev:client\b/.test(line)) {
+        startIndex = i;
+        break;
+      }
+    }
+  }
+  const segment = startIndex === -1 ? bodyLines : bodyLines.slice(startIndex);
+  if (segment.length === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const totalLinesCount = segment.length;
+  const endExclusive = Math.max(0, segment.length - offset);
+  const start = Math.max(0, endExclusive - maxLines);
+  return {
+    lines: segment.slice(start, endExclusive),
+    totalLinesCount
+  };
+}
+
+// src/commands/read-logs/json-lines.ts
+import fs17 from "fs";
+function normalizePid(value) {
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return "unknown";
+}
+function normalizeLevelName(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed) return null;
+    if (trimmed === "warning") return "warn";
+    if (trimmed === "err") return "error";
+    const allowed = ["trace", "debug", "info", "warn", "error", "fatal"];
+    return allowed.includes(trimmed) ? trimmed : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const num = Math.floor(value);
+    if (num <= 10) return "trace";
+    if (num <= 20) return "debug";
+    if (num <= 30) return "info";
+    if (num <= 40) return "warn";
+    if (num <= 50) return "error";
+    return "fatal";
+  }
+  return null;
+}
+function extractLevelName(obj) {
+  if (!obj || typeof obj !== "object") return null;
+  const record = obj;
+  const direct = normalizeLevelName(record["level"]);
+  if (direct) return direct;
+  const meta = record["meta"];
+  if (meta && typeof meta === "object") {
+    return normalizeLevelName(meta["level"]);
+  }
+  return null;
+}
+function buildWantedLevelSet(levels) {
+  if (!levels || levels.length === 0) return null;
+  const set = /* @__PURE__ */ new Set();
+  for (const raw of levels) {
+    const norm = normalizeLevelName(raw);
+    if (norm) set.add(norm);
+  }
+  return set.size > 0 ? set : null;
+}
+function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
+  const stat = fs17.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs17.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let targetPid = null;
+  let finished = false;
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  const wantedLevelSet = buildWantedLevelSet(levels);
+  try {
+    while (position > 0 && !finished) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs17.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        let parsed = null;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const pid = normalizePid(parsed?.pid);
+        if (targetPid === null) {
+          targetPid = pid;
+        }
+        if (pid !== targetPid) {
+          finished = true;
+          break;
+        }
+        const levelName = extractLevelName(parsed);
+        if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+          totalLinesCount += 1;
+          if (skipped < offset) {
+            skipped += 1;
+          } else if (collected.length < maxLines) {
+            collected.push(line);
+          }
+        }
+      }
+    }
+    if (!finished && remainder) {
+      const line = remainder.trim();
+      if (line) {
+        try {
+          const parsed = JSON.parse(line);
+          const pid = normalizePid(parsed?.pid);
+          if (targetPid === null) {
+            targetPid = pid;
+          }
+          if (pid === targetPid) {
+            const levelName = extractLevelName(parsed);
+            if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+              totalLinesCount += 1;
+              if (skipped < offset) {
+                skipped += 1;
+              } else if (collected.length < maxLines) {
+                collected.push(line);
+              }
+            }
+          }
+        } catch {
+          return { lines: [], totalLinesCount: 0 };
+        }
+      }
+    }
+  } finally {
+    fs17.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+function normalizeTraceId(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return null;
+}
+function extractTraceId(obj) {
+  if (!obj || typeof obj !== "object") return null;
+  const record = obj;
+  const directKeys = ["trace_id", "traceId", "traceID", "traceid"];
+  for (const key of directKeys) {
+    const value = normalizeTraceId(record[key]);
+    if (value) return value;
+  }
+  const meta = record["meta"];
+  if (meta && typeof meta === "object") {
+    const metaRecord = meta;
+    for (const key of directKeys) {
+      const value = normalizeTraceId(metaRecord[key]);
+      if (value) return value;
+    }
+  }
+  const attributes = record["attributes"];
+  if (attributes && typeof attributes === "object") {
+    const attrRecord = attributes;
+    for (const key of ["traceID", "trace_id", "traceId", "traceid"]) {
+      const value = normalizeTraceId(attrRecord[key]);
+      if (value) return value;
+    }
+  }
+  return null;
+}
+function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
+  const wanted = traceId.trim();
+  if (!wanted) return { lines: [], totalLinesCount: 0 };
+  const stat = fs17.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs17.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  const wantedLevelSet = buildWantedLevelSet(levels);
+  try {
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs17.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const lineTraceId = extractTraceId(parsed);
+          if (lineTraceId === wanted) {
+            const levelName = extractLevelName(parsed);
+            if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+              totalLinesCount += 1;
+              if (skipped < offset) {
+                skipped += 1;
+              } else if (collected.length < maxLines) {
+                collected.push(line);
+              }
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (remainder) {
+      const line = remainder.trim();
+      if (line) {
+        try {
+          const parsed = JSON.parse(line);
+          const lineTraceId = extractTraceId(parsed);
+          if (lineTraceId === wanted) {
+            const levelName = extractLevelName(parsed);
+            if (!wantedLevelSet || levelName && wantedLevelSet.has(levelName)) {
+              totalLinesCount += 1;
+              if (skipped < offset) {
+                skipped += 1;
+              } else if (collected.length < maxLines) {
+                collected.push(line);
+              }
+            }
+          }
+        } catch {
+          return { lines: [], totalLinesCount: 0 };
+        }
+      }
+    }
+  } finally {
+    fs17.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
+  const wantedLevelSet = buildWantedLevelSet(levels);
+  if (!wantedLevelSet) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const stat = fs17.statSync(filePath);
+  if (stat.size === 0) {
+    return { lines: [], totalLinesCount: 0 };
+  }
+  const fd = fs17.openSync(filePath, "r");
+  const chunkSize = 64 * 1024;
+  let position = stat.size;
+  let remainder = "";
+  let totalLinesCount = 0;
+  let skipped = 0;
+  const collected = [];
+  try {
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      fs17.readSync(fd, buffer, 0, length, position);
+      let chunk = buffer.toString("utf8");
+      if (remainder) {
+        chunk += remainder;
+        remainder = "";
+      }
+      const parts = chunk.split("\n");
+      remainder = parts.shift() ?? "";
+      for (let i = parts.length - 1; i >= 0; i -= 1) {
+        const line = parts[i].trim();
+        if (!line) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const levelName = extractLevelName(parsed);
+          if (levelName && wantedLevelSet.has(levelName)) {
+            totalLinesCount += 1;
+            if (skipped < offset) {
+              skipped += 1;
+            } else if (collected.length < maxLines) {
+              collected.push(line);
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (remainder) {
+      const line = remainder.trim();
+      if (line) {
+        try {
+          const parsed = JSON.parse(line);
+          const levelName = extractLevelName(parsed);
+          if (levelName && wantedLevelSet.has(levelName)) {
+            totalLinesCount += 1;
+            if (skipped < offset) {
+              skipped += 1;
+            } else if (collected.length < maxLines) {
+              collected.push(line);
+            }
+          }
+        } catch {
+          return { lines: [], totalLinesCount: 0 };
+        }
+      }
+    }
+  } finally {
+    fs17.closeSync(fd);
+  }
+  return { lines: collected.reverse(), totalLinesCount };
+}
+
+// src/commands/read-logs/index.ts
+var LOG_TYPES = ["server", "trace", "server-std", "client-std", "browser"];
+function sanitizeStructuredLog(value) {
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value;
+  const obj = value;
+  const sanitized = { ...obj };
+  delete sanitized.tenant_id;
+  delete sanitized.app_id;
+  delete sanitized.pid;
+  return sanitized;
+}
+function hasErrorInStdLines(lines) {
+  const combined = lines.join("\n");
+  if (!combined) return false;
+  const strong = [
+    /compiled with errors/i,
+    /failed to compile/i,
+    /error: \w+/i,
+    /uncaught/i,
+    /unhandled/i,
+    /eaddrinuse/i,
+    /cannot find module/i,
+    /module not found/i,
+    /ts\d{3,5}:/i
+  ];
+  if (strong.some((re) => re.test(combined))) return true;
+  const weakLine = /\b(error|fatal|exception)\b/i;
+  const ignorePatterns = [
+    /\b0\s+errors?\b/i,
+    /Server Error \d{3}/i
+  ];
+  return lines.some((line) => {
+    const text = line.trim();
+    if (!text) return false;
+    if (ignorePatterns.some((re) => re.test(text))) return false;
+    return weakLine.test(text);
+  });
+}
+function hasErrorInLogObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  const rawLevel = obj.level;
+  const level = typeof rawLevel === "string" ? rawLevel.toLowerCase() : "";
+  if (level === "error" || level === "fatal") return true;
+  if (level === "err") return true;
+  if (typeof rawLevel === "number" && Number.isFinite(rawLevel) && rawLevel >= 50) return true;
+  if (level === "warn" && typeof obj.stack === "string" && obj.stack.length > 0) return true;
+  if (typeof obj.stack === "string" && obj.stack.length > 0) return true;
+  const statusCode = obj.statusCode;
+  const status_code = obj.status_code;
+  const meta = obj.meta;
+  const metaObj = meta && typeof meta === "object" ? meta : null;
+  const metaStatusCode = metaObj?.statusCode;
+  const metaStatus_code = metaObj?.status_code;
+  const candidates = [statusCode, status_code, metaStatusCode, metaStatus_code];
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 400) {
+      return true;
+    }
+  }
+  const message = typeof obj.message === "string" ? obj.message : "";
+  if (message && hasErrorInStdLines([message])) return true;
+  return false;
+}
+async function readLatestLogLinesMeta(options) {
+  const maxLines = options.maxLines ?? 30;
+  const offset = options.offset ?? 0;
+  const filePath = resolveLogFilePath(options.logDir, options.type);
+  const levels = Array.isArray(options.levels) ? options.levels : void 0;
+  if (!fileExists(filePath)) {
+    throw new Error(`Log file not found: ${filePath}`);
+  }
+  if (options.type === "server-std") {
+    return readServerStdSegment(filePath, maxLines, offset);
+  }
+  if (options.type === "client-std") {
+    return readClientStdSegment(filePath, maxLines, offset);
+  }
+  const traceId = typeof options.traceId === "string" ? options.traceId.trim() : "";
+  if (traceId) {
+    return readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels);
+  }
+  if (options.type === "server" || options.type === "trace") {
+    return readJsonLinesLastPid(filePath, maxLines, offset, levels);
+  }
+  if (options.type === "browser") {
+    if (levels && levels.length > 0) {
+      return readJsonLinesTailByLevel(filePath, maxLines, offset, levels);
+    }
+    return readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset);
+  }
+  return { lines: [], totalLinesCount: 0 };
+}
+async function readLogsJsonResult(options) {
+  const { lines, totalLinesCount } = await readLatestLogLinesMeta(options);
+  if (options.type === "server-std" || options.type === "client-std") {
+    return {
+      hasError: hasErrorInStdLines(lines),
+      totalLinesCount,
+      logs: lines
+    };
+  }
+  const logs = [];
+  let hasError = false;
+  for (const line of lines) {
+    if (!hasError && hasErrorInStdLines([line])) {
+      hasError = true;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      logs.push(sanitizeStructuredLog(parsed));
+      if (!hasError && hasErrorInLogObject(parsed)) {
+        hasError = true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return {
+    hasError,
+    totalLinesCount,
+    logs
+  };
+}
+function resolveLogFilePath(logDir, type) {
+  const base = path15.isAbsolute(logDir) ? logDir : path15.join(process.cwd(), logDir);
+  if (type === "server") {
+    return path15.join(base, "server.log");
+  }
+  if (type === "trace") {
+    return path15.join(base, "trace.log");
+  }
+  if (type === "server-std") {
+    return path15.join(base, "server.std.log");
+  }
+  if (type === "client-std") {
+    return path15.join(base, "client.std.log");
+  }
+  if (type === "browser") {
+    return path15.join(base, "browser.log");
+  }
+  throw new Error(`Unsupported log type: ${type}`);
+}
+async function run4(options) {
+  try {
+    const result = await readLogsJsonResult(options);
+    process.stdout.write(JSON.stringify(result) + "\n");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const result = { hasError: true, totalLinesCount: 0, logs: [message] };
+    process.stdout.write(JSON.stringify(result) + "\n");
+    process.exitCode = 1;
+  }
+}
+function parseLogType(input) {
+  const value = typeof input === "string" ? input.trim() : "";
+  if (LOG_TYPES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid --type: ${String(input)}. Expected one of: ${LOG_TYPES.join(", ")}`);
+}
+function parsePositiveInt(input, flagName) {
+  const value = typeof input === "number" ? input : Number.parseInt(String(input), 10);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`Invalid ${flagName}: ${String(input)}. Expected a positive integer.`);
+  }
+  return value;
+}
+function parseNonNegativeInt(input, flagName) {
+  const value = typeof input === "number" ? input : Number.parseInt(String(input), 10);
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`Invalid ${flagName}: ${String(input)}. Expected a non-negative integer.`);
+  }
+  return value;
+}
+function parseCommaSeparatedList(input) {
+  const value = typeof input === "string" ? input : "";
+  const items = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+var readLogsCommand = {
+  name: "read-logs",
+  description: "Read latest logs from log files",
+  register(program) {
+    program.command(this.name).description(this.description).option("--dir <path>", "Logs directory", "logs").option("--type <type>", `Log type: ${LOG_TYPES.join("|")}`, "server-std").option("--max-lines <lines>", "Max lines to return", "30").option("--offset <lines>", "Skip latest N lines for pagination", "0").option("--trace-id <id>", "Filter structured logs by trace id").option("--level <levels>", "Filter structured logs by level (comma-separated)").action(async (rawOptions) => {
+      try {
+        const logDir = typeof rawOptions.dir === "string" ? rawOptions.dir : "logs";
+        const type = parseLogType(rawOptions.type);
+        const maxLines = parsePositiveInt(rawOptions.maxLines, "--max-lines");
+        const offset = parseNonNegativeInt(rawOptions.offset, "--offset");
+        const traceId = typeof rawOptions.traceId === "string" ? rawOptions.traceId : void 0;
+        const levels = parseCommaSeparatedList(rawOptions.level);
+        await run4({ logDir, type, maxLines, offset, traceId, levels });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const result = { hasError: true, totalLinesCount: 0, logs: [message] };
+        process.stdout.write(JSON.stringify(result) + "\n");
+        process.exitCode = 1;
+      }
+    });
+  }
+};
+
 // src/commands/index.ts
 var commands = [
   genDbSchemaCommand,
   syncCommand,
   actionPluginCommandGroup,
   capabilityCommandGroup,
-  migrationCommand
+  migrationCommand,
+  readLogsCommand
 ];
 
 // src/index.ts
-var envPath = path15.join(process.cwd(), ".env");
-if (fs15.existsSync(envPath)) {
+var envPath = path16.join(process.cwd(), ".env");
+if (fs18.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path15.dirname(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(fs15.readFileSync(path15.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path16.dirname(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(fs18.readFileSync(path16.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.6-alpha.13",
+  "version": "1.1.6-alpha.14",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@lark-apaas/devtool-kits": "^1.2.12",
+    "@lark-apaas/devtool-kits": "1.2.11-alpha.3",
     "@lark-apaas/http-client": "0.1.2",
     "@vercel/nft": "^0.30.3",
     "commander": "^13.0.0",