@lark-apaas/fullstack-cli 1.1.7 → 1.1.8

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

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

package/dist/commands/read-logs.js

@@ -0,0 +1,368 @@
+import fs from 'node:fs';
+import path from 'node:path';
+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);
+    }
+    else if (options.type === 'client-std') {
+        lines = extractClientStdSegment(lines, maxLines);
+    }
+    else if (options.type === 'server' || options.type === 'trace') {
+        lines = readJsonLinesLastPid(filePath, maxLines);
+    }
+    else if (options.type === 'browser' || options.type === 'client') {
+        lines = readJsonLinesTail(filePath, maxLines);
+    }
+    return lines;
+}
+function resolveLogFilePath(logDir, type) {
+    const base = path.isAbsolute(logDir) ? logDir : path.join(process.cwd(), logDir);
+    if (type === 'server') {
+        return path.join(base, 'server.log');
+    }
+    if (type === 'trace') {
+        return path.join(base, 'trace.log');
+    }
+    if (type === 'server-std') {
+        return path.join(base, 'server.std.log');
+    }
+    if (type === 'client-std') {
+        return path.join(base, 'client.std.log');
+    }
+    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();
+}
+export async function run(options) {
+    try {
+        const lines = await readLatestLogLines(options);
+        for (const line of lines) {
+            process.stdout.write(line + '\n');
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[read-logs] ${message}`);
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,69 @@
+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';
+async function writeFile(dir, fileName, content) {
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(path.join(dir, fileName), content, 'utf8');
+}
+describe('readLatestLogLines', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'fullstack-cli-logs-'));
+    });
+    afterEach(async () => {
+        await fs.promises.rm(tmpDir, { recursive: true, force: true });
+    });
+    it('returns only the last server-std segment', async () => {
+        const content = [
+            '[2026-01-05 10:00:00] [server] > app@1.0.0 dev:server',
+            '[2026-01-05 10:00:01] [server] booting',
+            '[2026-01-05 10:01:00] [server] > app@1.0.0 dev:server',
+            '[2026-01-05 10:01:01] [server] started',
+            '[2026-01-05 10:01:02] [server] ready',
+        ].join('\n');
+        await writeFile(tmpDir, 'server.std.log', content);
+        const lines = await readLatestLogLines({
+            logDir: tmpDir,
+            type: 'server-std',
+            maxLines: 200,
+        });
+        expect(lines).toEqual(['> app@1.0.0 dev:server', 'started', 'ready']);
+    });
+    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',
+            '[2026-01-05 10:00:05] [client] compiled successfully',
+            '[2026-01-05 10:00:06] [client] initial done',
+            '[2026-01-05 10:02:00] [client] compiled successfully',
+            '[2026-01-05 10:02:01] [client] hmr update',
+            '[2026-01-05 10:02:02] [client] updated',
+        ].join('\n');
+        await writeFile(tmpDir, 'client.std.log', content);
+        const lines = await readLatestLogLines({
+            logDir: tmpDir,
+            type: 'client-std',
+            maxLines: 200,
+        });
+        expect(lines).toEqual(['compiled successfully', 'hmr update', 'updated']);
+    });
+    it('returns only the last server pid segment for server.log', async () => {
+        const content = [
+            JSON.stringify({ pid: 100, time: '2026-01-05T10:00:00.000Z', level: 'INFO', message: 'old' }),
+            JSON.stringify({ pid: 100, time: '2026-01-05T10:00:01.000Z', level: 'INFO', message: 'old2' }),
+            JSON.stringify({ pid: 200, time: '2026-01-05T11:00:00.000Z', level: 'INFO', message: 'new' }),
+            JSON.stringify({ pid: 200, time: '2026-01-05T11:00:01.000Z', level: 'INFO', message: 'new2' }),
+        ].join('\n');
+        await writeFile(tmpDir, 'server.log', content);
+        const lines = await readLatestLogLines({
+            logDir: tmpDir,
+            type: 'server',
+            maxLines: 200,
+        });
+        expect(lines).toEqual([
+            JSON.stringify({ pid: 200, time: '2026-01-05T11:00:00.000Z', level: 'INFO', message: 'new' }),
+            JSON.stringify({ pid: 200, time: '2026-01-05T11:00:01.000Z', level: 'INFO', message: 'new2' }),
+        ]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "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.10",
+    "@lark-apaas/devtool-kits": "^1.2.11",
     "@vercel/nft": "^0.30.3",
     "cac": "^6.7.14",
     "dotenv": "^16.0.0",