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

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.1",
   "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.11",
+    "@lark-apaas/devtool-kits": "1.2.12-alpha.0",
     "@vercel/nft": "^0.30.3",
     "cac": "^6.7.14",
     "dotenv": "^16.0.0",