@lark-apaas/fullstack-cli 1.1.9 → 1.1.10

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

@@ -1,25 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

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

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

@@ -1,47 +0,0 @@
-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,16 +0,0 @@
-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,153 +0,0 @@
-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}`);
-    }
-    if (options.type === 'server-std') {
-        return readServerStdSegment(filePath, maxLines);
-    }
-    if (options.type === 'client-std') {
-        return readClientStdSegment(filePath, maxLines);
-    }
-    const traceId = typeof options.traceId === 'string' ? options.traceId.trim() : '';
-    if (traceId) {
-        return readJsonLinesByTraceId(filePath, traceId, maxLines);
-    }
-    let lines = readFileTailLines(filePath, maxLines * 5);
-    if (options.type === 'server' || options.type === 'trace') {
-        lines = readJsonLinesLastPid(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') {
-        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');
-    }
-    throw new Error(`Unsupported log type: ${type}`);
-}
-export async function run(options) {
-    try {
-        const result = await readLogsJsonResult(options);
-        process.stdout.write(JSON.stringify(result) + '\n');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const result = { hasError: true, message };
-        process.stdout.write(JSON.stringify(result) + '\n');
-        process.exitCode = 1;
-    }
-}

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

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

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

@@ -1,199 +0,0 @@
-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, 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');
-}
-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 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',
-            '[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' }),
-        ]);
-    });
-    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/dist/commands/sync.d.ts

@@ -1,6 +0,0 @@
-/**
- * 同步模板文件到用户项目
- */
-export declare function run(options: {
-    disableGenOpenapi?: boolean;
-}): Promise<void>;