@lark-apaas/fullstack-cli 1.1.68-alpha.20261019123412 → 1.1.68-alpha.20261020071132

package/dist/index.js

@@ -7786,8 +7786,142 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   return { lines: collected.reverse(), totalLinesCount };
 }
 
+// src/commands/read-logs/std-level.ts
+var STD_LEVEL_SCAN_LINES = 2e3;
+var ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+var TIMESTAMP_PREFIX_PATTERN = /^\[(?:\d{4}-\d{2}-\d{2}[ T][^\]]*|\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:\s*(?:AM|PM))?)\]\s?/i;
+var TRANSIENT_CONNECTION_ERROR_PATTERN = /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|socket hang up|proxy error(?!.*ENOTFOUND)|\[Proxy\] (?:Error:\s*$|Error during|Connection error|Non-connection error|Headers already sent|Service (?:recovered|did not recover))/i;
+var ERROR_PATTERNS = [
+  /compiled with errors/i,
+  /failed to compile/i,
+  /\[vite\].*(?:internal server error|pre-transform error)/i,
+  /\berror:\s*\S+/i,
+  /\b(?:uncaught|unhandled|fatal|exception)\b/i,
+  /\beaddrinuse\b/i,
+  /\b(?:cannot find module|module not found)\b/i,
+  /\bts\d{3,5}:/i,
+  /\b(?:syntax|type|reference|range)error\b/i,
+  /\bENOTFOUND\b/i,
+  /\berror\b/i
+];
+var WARN_PATTERNS = [
+  /compiled with warnings/i,
+  /(?:^|[\s)])[\w$.-]*Warning\s*:/i,
+  /\bWARN(?:ING)?S?\b(?:\s|:|\])/,
+  /\[vite\].*\bwarn(?:ing)?s?\b/i,
+  /\bdeprecated\b/i,
+  /\bdeprecation\b/i
+];
+var IGNORE_PATTERNS = [/\b0\s+errors?\b/i, /Server Error \d{3}/i];
+function comparableText(line) {
+  return line.replace(ANSI_PATTERN, "");
+}
+function contentWithoutTimestamp(line) {
+  return comparableText(line).replace(TIMESTAMP_PREFIX_PATTERN, "");
+}
+function isTransientStdLine(line) {
+  return TRANSIENT_CONNECTION_ERROR_PATTERN.test(comparableText(line));
+}
+function classifyStdLine(line) {
+  const comparable = comparableText(line);
+  const text = contentWithoutTimestamp(comparable).trim();
+  if (!text || isTransientStdLine(comparable) || IGNORE_PATTERNS.some((pattern) => pattern.test(text))) {
+    return void 0;
+  }
+  if (WARN_PATTERNS.some((pattern) => pattern.test(text))) return "warn";
+  if (ERROR_PATTERNS.some((pattern) => pattern.test(text))) return "error";
+  return void 0;
+}
+function isDiagnosticContinuation(line) {
+  const content = contentWithoutTimestamp(line);
+  if (!content.trim()) return true;
+  return /^\s+/.test(content) || /^\s*(?:Plugin|File|Location|Caused by):/i.test(content) || /^\s*(?:at\s+|\.\.\.\s+\d+\s+more)/.test(content) || /^\s*(?:>?\s*\d+\s*\||\||\^|~)/.test(content) || /^\s*(?:Error|AggregateError)\s*\{?$/i.test(content);
+}
+function summarizeStack(lines) {
+  const result = [];
+  let stackLines = 0;
+  for (const line of lines) {
+    const content = contentWithoutTimestamp(line);
+    const isStack = /^\s*at\s+/.test(content);
+    if (isStack) {
+      if (stackLines >= 3) continue;
+      stackLines += 1;
+    }
+    result.push(line);
+  }
+  return result;
+}
+function normalizeRequestedStdLevels(levels) {
+  if (!levels?.length) return void 0;
+  const normalized = new Set(
+    levels.map((level) => level.trim().toLowerCase()).filter(Boolean)
+  );
+  if (normalized.has("info")) return void 0;
+  const supported = /* @__PURE__ */ new Set();
+  if (normalized.has("error")) supported.add("error");
+  if (normalized.has("warn") || normalized.has("warning"))
+    supported.add("warn");
+  return supported;
+}
+function extractStdDiagnosticBlocks(lines, requestedLevels) {
+  const blocks = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const level = classifyStdLine(line);
+    if (!level || !requestedLevels.has(level)) continue;
+    const blockLines = [line];
+    let next = index + 1;
+    while (next < lines.length) {
+      const candidate = lines[next] ?? "";
+      if (isDiagnosticContinuation(candidate)) {
+        blockLines.push(candidate);
+        next += 1;
+        continue;
+      }
+      const candidateLevel = classifyStdLine(candidate);
+      if (candidateLevel) break;
+      break;
+    }
+    while (blockLines.length > 1 && !contentWithoutTimestamp(blockLines[blockLines.length - 1] ?? "").trim()) {
+      blockLines.pop();
+    }
+    blocks.push({ level, lines: summarizeStack(blockLines) });
+    index = next - 1;
+  }
+  return blocks;
+}
+function paginateStdDiagnosticBlocks(blocks, maxLines, offset) {
+  let skippedLines = 0;
+  let selectedLines = 0;
+  const selected = [];
+  for (let index = blocks.length - 1; index >= 0; index -= 1) {
+    const block = blocks[index];
+    if (!block) continue;
+    if (skippedLines < offset) {
+      skippedLines += block.lines.length;
+      continue;
+    }
+    if (selectedLines >= maxLines) break;
+    selected.unshift(block);
+    selectedLines += block.lines.length;
+  }
+  return selected.flatMap((block) => block.lines);
+}
+function hasErrorInStdLines(lines) {
+  return lines.some((line) => classifyStdLine(line) === "error");
+}
+
 // src/commands/read-logs/index.ts
-var LOG_TYPES = ["server", "trace", "server-std", "client-std", "dev", "dev-std", "install-dep-std", "browser"];
+var LOG_TYPES = [
+  "server",
+  "trace",
+  "server-std",
+  "client-std",
+  "dev",
+  "dev-std",
+  "install-dep-std",
+  "browser"
+];
 function normalizeObjectKey(key) {
   return key.toLowerCase().replace(/_/g, "");
 }
@@ -7810,7 +7944,9 @@ function formatIsoWithLocalOffset(date, includeMilliseconds) {
   return `${year}-${month}-${day}T${hour}:${minute}:${second}${msPart}${sign}${offsetHH}:${offsetMM}`;
 }
 function formatLocalDateTimeStringWithOffset(input) {
-  const match = input.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+  const match = input.match(
+    /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/
+  );
   if (!match) return input;
   const year = Number(match[1]);
   const month = Number(match[2]);
@@ -7886,35 +8022,6 @@ function sanitizeStructuredLog(value) {
   }
   return sanitized;
 }
-var TRANSIENT_CONNECTION_ERROR_PATTERN = /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|socket hang up|proxy error|\[Proxy\] (?:Error:\s*$|Error during|Connection error|Non-connection error|Headers already sent|Service (?:recovered|did not recover))/i;
-function hasErrorInStdLines(lines) {
-  const filtered = lines.filter((line) => !TRANSIENT_CONNECTION_ERROR_PATTERN.test(line));
-  const combined = filtered.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 filtered.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;
@@ -7924,8 +8031,10 @@ function hasErrorInLogObject(value) {
   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 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;
@@ -7952,10 +8061,35 @@ async function readLatestLogLinesMeta(options) {
     throw new Error(`Log file not found: ${filePath}`);
   }
   if (options.type === "server-std") {
-    return readServerStdSegment(filePath, maxLines, offset);
+    const requestedLevels = normalizeRequestedStdLevels(levels);
+    if (!requestedLevels)
+      return readServerStdSegment(filePath, maxLines, offset);
+    const segment = readServerStdSegment(filePath, STD_LEVEL_SCAN_LINES, 0);
+    const blocks = extractStdDiagnosticBlocks(segment.lines, requestedLevels);
+    return {
+      lines: paginateStdDiagnosticBlocks(blocks, maxLines, offset),
+      totalLinesCount: blocks.reduce(
+        (sum, block) => sum + block.lines.length,
+        0
+      ),
+      allLines: blocks.flatMap((block) => block.lines)
+    };
   }
   if (options.type === "client-std") {
-    return readClientStdSegment(filePath, maxLines, offset);
+    const requestedLevels = normalizeRequestedStdLevels(levels);
+    if (!requestedLevels)
+      return readClientStdSegment(filePath, maxLines, offset);
+    const segment = readClientStdSegment(filePath, STD_LEVEL_SCAN_LINES, 0);
+    const scanLines = segment.allLines.slice(-STD_LEVEL_SCAN_LINES);
+    const blocks = extractStdDiagnosticBlocks(scanLines, requestedLevels);
+    return {
+      lines: paginateStdDiagnosticBlocks(blocks, maxLines, offset),
+      totalLinesCount: blocks.reduce(
+        (sum, block) => sum + block.lines.length,
+        0
+      ),
+      allLines: blocks.flatMap((block) => block.lines)
+    };
   }
   if (options.type === "dev") {
     return readDevSegment(filePath, maxLines, offset);
@@ -7987,15 +8121,16 @@ async function readLogsJsonResult(options) {
     const linesForErrorCheck = allLines ?? lines;
     const stackTracePattern = /\bat\s+\S+\s+\([^)]+:\d+:\d+\)/;
     const linesToFilter = allLines ?? lines;
-    const filteredLines = linesToFilter.filter((line) => !stackTracePattern.test(line));
+    const stdLevelFilteringActive = (options.type === "server-std" || options.type === "client-std") && Boolean(normalizeRequestedStdLevels(options.levels));
+    const filteredLines = stdLevelFilteringActive ? linesToFilter : linesToFilter.filter((line) => !stackTracePattern.test(line));
     const maxLines = options.maxLines ?? 30;
     const offset = options.offset ?? 0;
     const endExclusive = Math.max(0, filteredLines.length - offset);
     const start = Math.max(0, endExclusive - maxLines);
-    const paginatedLogs = filteredLines.slice(start, endExclusive);
+    const paginatedLogs = stdLevelFilteringActive ? lines : filteredLines.slice(start, endExclusive);
     return {
       hasError: hasErrorInStdLines(linesForErrorCheck),
-      totalLinesCount: filteredLines.length,
+      totalLinesCount: stdLevelFilteringActive ? totalLinesCount : filteredLines.length,
       logs: paginatedLogs
     };
   }
@@ -8059,19 +8194,25 @@ function parseLogType(input) {
   if (LOG_TYPES.includes(value)) {
     return value;
   }
-  throw new Error(`Invalid --type: ${String(input)}. Expected one of: ${LOG_TYPES.join(", ")}`);
+  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.`);
+    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.`);
+    throw new Error(
+      `Invalid ${flagName}: ${String(input)}. Expected a non-negative integer.`
+    );
   }
   return value;
 }
@@ -8084,7 +8225,10 @@ 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", "/tmp").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) => {
+    program.command(this.name).description(this.description).option("--dir <path>", "Logs directory", "/tmp").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 or std diagnostic blocks by level (comma-separated)"
+    ).action(async (rawOptions) => {
       try {
         const logDir = typeof rawOptions.dir === "string" ? rawOptions.dir : "/tmp";
         const type = parseLogType(rawOptions.type);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.68-alpha.20261019123412",
+  "version": "1.1.68-alpha.20261020071132",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@lark-apaas/http-client": "0.1.8-alpha.20261019123410",
+    "@lark-apaas/http-client": "^0.1.7",
     "@lydell/node-pty": "1.1.0",
     "@vercel/nft": "^0.30.3",
     "commander": "^13.0.0",