@lark-apaas/fullstack-cli 1.1.8 → 1.1.9-alpha.0

package/dist/commands/gen-db-schema.js

@@ -73,16 +73,16 @@ export async function run(options = {}) {
             console.error('[gen-db-schema] schema.ts not generated');
             throw new Error('drizzle-kit introspect failed to generate schema.ts');
         }
-        fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
-        fs.copyFileSync(generatedSchema, SCHEMA_FILE);
-        console.log(`[gen-db-schema] ✓ Copied to ${outputPath}`);
         // 后处理 schema（使用 CommonJS require 方式加载）
         const { postprocessDrizzleSchema } = require('@lark-apaas/devtool-kits');
-        const stats = postprocessDrizzleSchema(SCHEMA_FILE);
+        const stats = postprocessDrizzleSchema(generatedSchema);
         if (stats?.unmatchedUnknown?.length) {
             console.warn('[gen-db-schema] Unmatched custom types detected:', stats.unmatchedUnknown);
         }
         console.log('[gen-db-schema] ✓ Postprocessed schema');
+        fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
+        fs.copyFileSync(generatedSchema, SCHEMA_FILE);
+        console.log(`[gen-db-schema] ✓ Copied to ${outputPath}`);
         try {
             if (options.enableNestModuleGenerate) {
                 const { parseAndGenerateNestResourceTemplate } = require('@lark-apaas/devtool-kits');

package/dist/commands/read-logs/client-std.d.ts

@@ -0,0 +1,2 @@
+export declare function readClientStdSegment(filePath: string, maxLines: number): string[];
+export declare function extractClientStdSegment(lines: string[], maxLines: number): string[];

package/dist/commands/read-logs/client-std.js

@@ -0,0 +1,98 @@
+import { readFileTailLines } from './tail.js';
+import { stripPrefixFromStdLine } from './std-utils.js';
+export function readClientStdSegment(filePath, maxLines) {
+    const lines = readFileTailLines(filePath, Math.max(maxLines * 5, 2000));
+    return extractClientStdSegment(lines, maxLines);
+}
+export function extractClientStdSegment(lines, maxLines) {
+    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 [];
+    }
+    if (segment.length <= maxLines) {
+        return segment;
+    }
+    return segment.slice(segment.length - maxLines);
+}

package/dist/commands/read-logs/json-lines.d.ts

@@ -0,0 +1,3 @@
+export declare function readJsonLinesLastPid(filePath: string, maxLines: number): string[];
+export declare function readJsonLinesByTraceId(filePath: string, traceId: string, maxLines: number): string[];
+export declare function readJsonLinesTail(lines: string[], maxLines: number): string[];

package/dist/commands/read-logs/json-lines.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+function normalizePid(value) {
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    return 'unknown';
+}
+export function readJsonLinesLastPid(filePath, maxLines) {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return [];
+    }
+    const fd = fs.openSync(filePath, 'r');
+    const chunkSize = 64 * 1024;
+    let position = stat.size;
+    let remainder = '';
+    let targetPid = null;
+    let finished = false;
+    const collected = [];
+    try {
+        while (position > 0 && !finished) {
+            const length = Math.min(chunkSize, position);
+            position -= length;
+            const buffer = Buffer.alloc(length);
+            fs.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;
+                }
+                collected.push(line);
+                if (collected.length >= maxLines * 5) {
+                    finished = true;
+                    break;
+                }
+            }
+        }
+        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) {
+                        collected.push(line);
+                    }
+                }
+                catch {
+                    return [];
+                }
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const reversed = collected.reverse();
+    if (reversed.length <= maxLines) {
+        return reversed;
+    }
+    return reversed.slice(reversed.length - maxLines);
+}
+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;
+}
+export function readJsonLinesByTraceId(filePath, traceId, maxLines) {
+    const wanted = traceId.trim();
+    if (!wanted)
+        return [];
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return [];
+    }
+    const fd = fs.openSync(filePath, 'r');
+    const chunkSize = 64 * 1024;
+    let position = stat.size;
+    let remainder = '';
+    let processedNonEmpty = 0;
+    let finished = false;
+    const collected = [];
+    const maxProcessed = Math.max(maxLines * 200, 5000);
+    try {
+        while (position > 0 && !finished) {
+            const length = Math.min(chunkSize, position);
+            position -= length;
+            const buffer = Buffer.alloc(length);
+            fs.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;
+                processedNonEmpty += 1;
+                try {
+                    const parsed = JSON.parse(line);
+                    const lineTraceId = extractTraceId(parsed);
+                    if (lineTraceId === wanted) {
+                        collected.push(line);
+                        if (collected.length >= maxLines) {
+                            finished = true;
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+                if (processedNonEmpty >= maxProcessed && collected.length > 0) {
+                    finished = true;
+                    break;
+                }
+            }
+        }
+        if (!finished && remainder) {
+            const line = remainder.trim();
+            if (line) {
+                try {
+                    const parsed = JSON.parse(line);
+                    const lineTraceId = extractTraceId(parsed);
+                    if (lineTraceId === wanted) {
+                        collected.push(line);
+                    }
+                }
+                catch {
+                    return [];
+                }
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return collected.reverse();
+}
+export function readJsonLinesTail(lines, maxLines) {
+    const result = [];
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        result.push(line);
+        if (result.length >= maxLines) {
+            break;
+        }
+    }
+    return result.reverse();
+}

package/dist/commands/read-logs/server-std.d.ts

@@ -0,0 +1 @@
+export declare function readServerStdSegment(filePath: string, maxLines: number): string[];

package/dist/commands/read-logs/server-std.js

@@ -0,0 +1,25 @@
+import { readFileTailLines } from './tail.js';
+import { readStdLinesTailFromLastMarker, stripPrefixFromStdLine } from './std-utils.js';
+export function readServerStdSegment(filePath, maxLines) {
+    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 = readStdLinesTailFromLastMarker(filePath, maxLines, marker);
+    if (segment.markerFound) {
+        return segment.lines;
+    }
+    const lines = readFileTailLines(filePath, maxLines);
+    return lines.map(stripPrefixFromStdLine);
+}

package/dist/commands/read-logs/std-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function stripPrefixFromStdLine(line: string): string;
+export declare function readStdLinesTailFromLastMarker(filePath: string, maxLines: number, isMarker: (line: string) => boolean): {
+    lines: string[];
+    markerFound: boolean;
+};

package/dist/commands/read-logs/std-utils.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+export 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;
+    }
+    return match[4] || '';
+}
+export function readStdLinesTailFromLastMarker(filePath, maxLines, isMarker) {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return { lines: [], markerFound: false };
+    }
+    const fd = fs.openSync(filePath, 'r');
+    const chunkSize = 64 * 1024;
+    let position = stat.size;
+    let remainder = '';
+    let markerFound = false;
+    let finished = false;
+    const collected = [];
+    try {
+        while (position > 0 && !finished) {
+            const length = Math.min(chunkSize, position);
+            position -= length;
+            const buffer = Buffer.alloc(length);
+            fs.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 (collected.length < maxLines) {
+                    collected.push(line);
+                }
+                if (isMarker(line)) {
+                    markerFound = true;
+                    finished = true;
+                    break;
+                }
+            }
+        }
+        if (!finished && remainder) {
+            const line = stripPrefixFromStdLine(remainder);
+            if (collected.length < maxLines) {
+                collected.push(line);
+            }
+            if (isMarker(line)) {
+                markerFound = true;
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return { lines: collected.reverse(), markerFound };
+}

package/dist/commands/read-logs/tail.d.ts

@@ -0,0 +1,2 @@
+export declare function fileExists(filePath: string): boolean;
+export declare function readFileTailLines(filePath: string, maxLines: number): string[];

package/dist/commands/read-logs/tail.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+export function fileExists(filePath) {
+    try {
+        fs.accessSync(filePath, fs.constants.F_OK | fs.constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readFileTailLines(filePath, maxLines) {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return [];
+    }
+    const fd = fs.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);
+            fs.readSync(fd, buffer, 0, length, position);
+            chunks.unshift(buffer.toString('utf8'));
+            const chunkLines = buffer.toString('utf8').split('\n').length - 1;
+            collectedLines += chunkLines;
+        }
+    }
+    finally {
+        fs.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);
+}

package/dist/commands/read-logs.d.ts

@@ -1,9 +1,16 @@
-type LogType = 'server' | 'trace' | 'server-std' | 'client-std' | 'browser' | 'client';
+type LogType = 'server' | 'trace' | 'server-std' | 'client-std' | 'browser';
+export interface ReadLogsJsonResult {
+    hasError: boolean;
+    message: string;
+    logs?: unknown[];
+}
 interface ReadLogsOptions {
     logDir: string;
     type: LogType;
     maxLines?: number;
+    traceId?: string;
 }
 export declare function readLatestLogLines(options: ReadLogsOptions): Promise<string[]>;
+export declare function readLogsJsonResult(options: ReadLogsOptions): Promise<ReadLogsJsonResult>;
 export declare function run(options: ReadLogsOptions): Promise<void>;
 export {};

package/dist/commands/read-logs.js

@@ -1,26 +1,125 @@
-import fs from 'node:fs';
 import path from 'node:path';
+import { readServerStdSegment } from './read-logs/server-std.js';
+import { readClientStdSegment } from './read-logs/client-std.js';
+import { readJsonLinesByTraceId, readJsonLinesLastPid, readJsonLinesTail } from './read-logs/json-lines.js';
+import { fileExists, readFileTailLines } from './read-logs/tail.js';
+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 level = typeof obj.level === 'string' ? obj.level.toLowerCase() : '';
+    if (level === 'error' || level === 'fatal')
+        return true;
+    if (level === 'err')
+        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;
+}
 export async function readLatestLogLines(options) {
     const maxLines = options.maxLines ?? 200;
     const filePath = resolveLogFilePath(options.logDir, options.type);
     if (!fileExists(filePath)) {
         throw new Error(`Log file not found: ${filePath}`);
     }
-    let lines = readFileTailLines(filePath, maxLines * 5);
     if (options.type === 'server-std') {
-        lines = extractServerStdSegment(lines, maxLines);
+        return readServerStdSegment(filePath, maxLines);
+    }
+    if (options.type === 'client-std') {
+        return readClientStdSegment(filePath, maxLines);
     }
-    else if (options.type === 'client-std') {
-        lines = extractClientStdSegment(lines, maxLines);
+    const traceId = typeof options.traceId === 'string' ? options.traceId.trim() : '';
+    if (traceId) {
+        return readJsonLinesByTraceId(filePath, traceId, maxLines);
     }
-    else if (options.type === 'server' || options.type === 'trace') {
+    let lines = readFileTailLines(filePath, maxLines * 5);
+    if (options.type === 'server' || options.type === 'trace') {
         lines = readJsonLinesLastPid(filePath, maxLines);
     }
-    else if (options.type === 'browser' || options.type === 'client') {
-        lines = readJsonLinesTail(filePath, maxLines);
+    else if (options.type === 'browser') {
+        lines = readJsonLinesTail(lines, maxLines);
     }
     return lines;
 }
+export async function readLogsJsonResult(options) {
+    const lines = await readLatestLogLines(options);
+    if (options.type === 'server-std' || options.type === 'client-std') {
+        return {
+            hasError: hasErrorInStdLines(lines),
+            message: lines.join('\n'),
+        };
+    }
+    const logs = [];
+    let hasError = false;
+    for (const line of lines) {
+        if (!hasError && hasErrorInStdLines([line])) {
+            hasError = true;
+        }
+        try {
+            const parsed = JSON.parse(line);
+            logs.push(parsed);
+            if (!hasError && hasErrorInLogObject(parsed)) {
+                hasError = true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        hasError,
+        message: '',
+        logs,
+    };
+}
 function resolveLogFilePath(logDir, type) {
     const base = path.isAbsolute(logDir) ? logDir : path.join(process.cwd(), logDir);
     if (type === 'server') {
@@ -38,331 +137,17 @@ function resolveLogFilePath(logDir, type) {
     if (type === 'browser') {
         return path.join(base, 'browser.log');
     }
-    return path.join(base, 'client.log');
-}
-function fileExists(filePath) {
-    try {
-        fs.accessSync(filePath, fs.constants.F_OK | fs.constants.R_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function readFileTailLines(filePath, maxLines) {
-    const stat = fs.statSync(filePath);
-    if (stat.size === 0) {
-        return [];
-    }
-    const fd = fs.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);
-            const buffer = Buffer.alloc(length);
-            position -= length;
-            fs.readSync(fd, buffer, 0, length, position);
-            chunks.unshift(buffer.toString('utf8'));
-            const chunkLines = buffer.toString('utf8').split('\n').length - 1;
-            collectedLines += chunkLines;
-        }
-    }
-    finally {
-        fs.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 stripPrefixFromStdLine(line) {
-    const match = line.match(/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[(server|client)\] (.*)$/);
-    if (!match) {
-        return line;
-    }
-    return match[3] || '';
-}
-function findLastSegmentByMarkers(lines, markers) {
-    let startIndex = -1;
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-        const line = lines[i];
-        if (markers.start(line)) {
-            startIndex = i;
-            break;
-        }
-    }
-    if (startIndex === -1) {
-        return lines;
-    }
-    let endIndex = lines.length;
-    if (markers.reset) {
-        for (let i = startIndex + 1; i < lines.length; i += 1) {
-            if (markers.reset(lines[i])) {
-                endIndex = i;
-                break;
-            }
-        }
-    }
-    return lines.slice(startIndex, endIndex);
-}
-function extractServerStdSegment(lines, maxLines) {
-    const bodyLines = lines.map(stripPrefixFromStdLine);
-    let startIndex = -1;
-    for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
-        const line = bodyLines[i];
-        if (!line)
-            continue;
-        if (/\bdev:server\b/.test(line)) {
-            startIndex = i;
-            break;
-        }
-    }
-    if (startIndex !== -1) {
-        const segment = bodyLines.slice(startIndex);
-        if (segment.length <= maxLines) {
-            return segment;
-        }
-        return segment.slice(segment.length - maxLines);
-    }
-    const markers = {
-        start: (line) => {
-            if (!line)
-                return false;
-            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 = findLastSegmentByMarkers(bodyLines, markers);
-    if (segment.length === 0) {
-        return [];
-    }
-    if (segment.length <= maxLines) {
-        return segment;
-    }
-    return segment.slice(segment.length - maxLines);
-}
-function extractClientStdSegment(lines, maxLines) {
-    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 [];
-    }
-    if (segment.length <= maxLines) {
-        return segment;
-    }
-    return segment.slice(segment.length - maxLines);
-}
-function normalizePid(value) {
-    if (typeof value === 'number') {
-        return String(value);
-    }
-    if (typeof value === 'string' && value.length > 0) {
-        return value;
-    }
-    return 'unknown';
-}
-function readJsonLinesLastPid(filePath, maxLines) {
-    const stat = fs.statSync(filePath);
-    if (stat.size === 0) {
-        return [];
-    }
-    const fd = fs.openSync(filePath, 'r');
-    const chunkSize = 64 * 1024;
-    let position = stat.size;
-    let remainder = '';
-    let targetPid = null;
-    let finished = false;
-    const collected = [];
-    try {
-        while (position > 0 && !finished) {
-            const length = Math.min(chunkSize, position);
-            position -= length;
-            const buffer = Buffer.alloc(length);
-            fs.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;
-                }
-                collected.push(line);
-                if (collected.length >= maxLines * 5) {
-                    finished = true;
-                    break;
-                }
-            }
-        }
-        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) {
-                        collected.push(line);
-                    }
-                }
-                catch {
-                    return [];
-                }
-            }
-        }
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-    const reversed = collected.reverse();
-    if (reversed.length <= maxLines) {
-        return reversed;
-    }
-    return reversed.slice(reversed.length - maxLines);
-}
-function readJsonLinesTail(filePath, maxLines) {
-    const lines = readFileTailLines(filePath, maxLines);
-    const result = [];
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-        const line = lines[i].trim();
-        if (!line)
-            continue;
-        result.push(line);
-        if (result.length >= maxLines) {
-            break;
-        }
-    }
-    return result.reverse();
+    throw new Error(`Unsupported log type: ${type}`);
 }
 export async function run(options) {
     try {
-        const lines = await readLatestLogLines(options);
-        for (const line of lines) {
-            process.stdout.write(line + '\n');
-        }
+        const result = await readLogsJsonResult(options);
+        process.stdout.write(JSON.stringify(result) + '\n');
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.error(`[read-logs] ${message}`);
+        const result = { hasError: true, message };
+        process.stdout.write(JSON.stringify(result) + '\n');
         process.exitCode = 1;
     }
 }

package/dist/commands/read-logs.test.js

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { readLatestLogLines } from './read-logs';
+import { readLatestLogLines, readLogsJsonResult } from './read-logs';
 async function writeFile(dir, fileName, content) {
     await fs.promises.mkdir(dir, { recursive: true });
     await fs.promises.writeFile(path.join(dir, fileName), content, 'utf8');
@@ -31,6 +31,31 @@ describe('readLatestLogLines', () => {
         });
         expect(lines).toEqual(['> app@1.0.0 dev:server', 'started', 'ready']);
     });
+    it('returns only the last server-std segment by latest marker', async () => {
+        const content = [
+            '[2026-01-05 10:00:00] [server] > app@1.0.0 dev:server',
+            '[2026-01-05 10:00:01] [server] [10:00:01] Starting compilation in watch mode...',
+            '[2026-01-05 10:00:02] [server] other',
+            '[2026-01-05 10:00:03] [server] [10:00:03] File change detected. Starting incremental compilation...',
+            '[2026-01-05 10:00:04] [server] other2',
+            '[2026-01-05 10:00:05] [server] [Nest] 1  - 2026/01/05 10:00:05     LOG [NestFactory] Starting Nest application...',
+            '[2026-01-05 10:00:06] [server] after-old',
+            '[2026-01-05 10:01:00] [server] [10:01:00] File change detected. Starting incremental compilation...',
+            '[2026-01-05 10:01:01] [server] tail-1',
+            '[2026-01-05 10:01:02] [server] tail-2',
+        ].join('\n');
+        await writeFile(tmpDir, 'server.std.log', content);
+        const lines = await readLatestLogLines({
+            logDir: tmpDir,
+            type: 'server-std',
+            maxLines: 200,
+        });
+        expect(lines).toEqual([
+            '[10:01:00] File change detected. Starting incremental compilation...',
+            'tail-1',
+            'tail-2',
+        ]);
+    });
     it('returns only the last client-std segment by hot reload markers', async () => {
         const content = [
             '[2026-01-05 10:00:00] [client] > app@1.0.0 dev:client',
@@ -66,4 +91,109 @@ describe('readLatestLogLines', () => {
             JSON.stringify({ pid: 200, time: '2026-01-05T11:00:01.000Z', level: 'INFO', message: 'new2' }),
         ]);
     });
+    it('filters server.log by traceId when provided', async () => {
+        const content = [
+            JSON.stringify({ pid: 200, trace_id: 't1', level: 'INFO', message: 'a' }),
+            JSON.stringify({ pid: 200, trace_id: 't2', level: 'INFO', message: 'b' }),
+            JSON.stringify({ pid: 200, trace_id: 't2', level: 'INFO', message: 'c' }),
+            JSON.stringify({ pid: 200, trace_id: 't3', level: 'INFO', message: 'd' }),
+        ].join('\n');
+        await writeFile(tmpDir, 'server.log', content);
+        const result = await readLogsJsonResult({
+            logDir: tmpDir,
+            type: 'server',
+            maxLines: 200,
+            traceId: 't2',
+        });
+        expect(result).toEqual({
+            hasError: false,
+            message: '',
+            logs: [
+                { pid: 200, trace_id: 't2', level: 'INFO', message: 'b' },
+                { pid: 200, trace_id: 't2', level: 'INFO', message: 'c' },
+            ],
+        });
+    });
+    it('filters browser.log by traceId when provided', async () => {
+        const content = [
+            JSON.stringify({ level: 'info', message: 'x', trace_id: 't1' }),
+            JSON.stringify({ level: 'info', message: 'y', trace_id: 't2' }),
+            JSON.stringify({ level: 'info', message: 'z', trace_id: 't2' }),
+        ].join('\n');
+        await writeFile(tmpDir, 'browser.log', content);
+        const result = await readLogsJsonResult({
+            logDir: tmpDir,
+            type: 'browser',
+            maxLines: 200,
+            traceId: 't2',
+        });
+        expect(result).toEqual({
+            hasError: false,
+            message: '',
+            logs: [
+                { level: 'info', message: 'y', trace_id: 't2' },
+                { level: 'info', message: 'z', trace_id: 't2' },
+            ],
+        });
+    });
+    it('returns JSON result for server-std as message', async () => {
+        const content = [
+            '[2026-01-05 10:00:00] [server] > app@1.0.0 dev:server',
+            '[2026-01-05 10:00:01] [server] booting',
+        ].join('\n');
+        await writeFile(tmpDir, 'server.std.log', content);
+        const result = await readLogsJsonResult({
+            logDir: tmpDir,
+            type: 'server-std',
+            maxLines: 200,
+        });
+        expect(result).toEqual({
+            hasError: false,
+            message: '> app@1.0.0 dev:server\nbooting',
+        });
+    });
+    it('returns JSON result for server as logs', async () => {
+        const content = [
+            JSON.stringify({ pid: 100, message: 'old' }),
+            JSON.stringify({ pid: 200, message: 'new' }),
+            JSON.stringify({ pid: 200, message: 'new2' }),
+        ].join('\n');
+        await writeFile(tmpDir, 'server.log', content);
+        const result = await readLogsJsonResult({
+            logDir: tmpDir,
+            type: 'server',
+            maxLines: 200,
+        });
+        expect(result).toEqual({
+            hasError: false,
+            message: '',
+            logs: [{ pid: 200, message: 'new' }, { pid: 200, message: 'new2' }],
+        });
+    });
+    it('sets hasError=true for server-std error keywords', async () => {
+        const content = [
+            '[2026-01-05 10:00:00] [server] > app@1.0.0 dev:server',
+            '[2026-01-05 10:00:01] [server] ERROR something bad happened',
+        ].join('\n');
+        await writeFile(tmpDir, 'server.std.log', content);
+        const result = await readLogsJsonResult({
+            logDir: tmpDir,
+            type: 'server-std',
+            maxLines: 200,
+        });
+        expect(result.hasError).toBe(true);
+    });
+    it('sets hasError=true for server JSON logs with error level', async () => {
+        const content = [
+            JSON.stringify({ pid: 200, level: 'INFO', message: 'ok' }),
+            JSON.stringify({ pid: 200, level: 'ERROR', message: 'failed' }),
+        ].join('\n');
+        await writeFile(tmpDir, 'server.log', content);
+        const result = await readLogsJsonResult({
+            logDir: tmpDir,
+            type: 'server',
+            maxLines: 200,
+        });
+        expect(result.hasError).toBe(true);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.8",
+  "version": "1.1.9-alpha.0",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",