@windsland52/maa-log-tools 1.2.1 → 1.3.0

package/dist/nodeInput.js

@@ -1,6 +1,9 @@
-import { readFile, readdir, stat } from 'node:fs/promises';
+import { lstat, opendir, realpath } from 'node:fs/promises';
 import path from 'node:path';
-import { unzipSync } from 'fflate';
+import { addArchiveDirectoryEntry, addSelectedEntry, ArchiveLimitError, assertArchiveInputsWithinLimits, createStoredFileMetadata, EMPTY_ARCHIVE_DIRECTORY_BUDGET, EMPTY_EXTRACTION_BUDGET, extractZipEntriesWithinLimits, resolveArchiveLimits, } from './archiveLimits.js';
+import { getFileIdentity, InputFileError, readBoundedRegularFile, sameFileIdentity, } from './boundedFileReader.js';
+export { ArchiveFormatError, ArchiveLimitError, DEFAULT_ARCHIVE_LIMITS, resolveArchiveLimits, } from './archiveLimits.js';
+export { InputFileError } from './boundedFileReader.js';
 const MAIN_LOG_NAMES = ['maa.log', 'maafw.log'];
 const BAK_LOG_NAMES = ['maa.bak.log', 'maafw.bak.log'];
 const SEARCH_TEXT_EXTENSIONS = ['.log', '.txt', '.jsonl'];
@@ -214,10 +217,92 @@ const sortLogPaths = (paths) => {
         return left.localeCompare(right);
     });
 };
-const collectFocusedFileContents = async (logPaths, focus) => {
+const pathKey = (value) => {
+    const resolved = path.resolve(value);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+};
+const isPathInside = (rootPath, candidatePath) => {
+    const relativePath = path.relative(rootPath, candidatePath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+};
+const assertPathInsideContext = async (context, fullPath) => {
+    const absolutePath = path.resolve(fullPath);
+    if (!isPathInside(context.rootPath, absolutePath)) {
+        throw new InputFileError('path-escape', fullPath, `Input path escapes the selected root: ${fullPath}`);
+    }
+    const physicalPath = await realpath(absolutePath);
+    if (!isPathInside(context.rootRealPath, physicalPath)) {
+        throw new InputFileError('path-escape', fullPath, `Input path resolves outside the selected root: ${fullPath}`);
+    }
+};
+export const createNodeInputBudgetContext = async (rootPath, limits, requireDirectoryRoot = true) => {
+    const absoluteRoot = path.resolve(rootPath);
+    const rootStats = await lstat(absoluteRoot);
+    if (rootStats.isSymbolicLink()) {
+        throw new InputFileError('symlink', absoluteRoot, `Symbolic-link roots are not allowed: ${absoluteRoot}`);
+    }
+    if (requireDirectoryRoot && !rootStats.isDirectory()) {
+        throw new InputFileError('not-directory', absoluteRoot, `Expected a directory root: ${absoluteRoot}`);
+    }
+    const physicalRoot = await realpath(absoluteRoot);
+    return {
+        limits,
+        rootPath: absoluteRoot,
+        rootRealPath: physicalRoot,
+        directory: EMPTY_ARCHIVE_DIRECTORY_BUDGET,
+        extraction: EMPTY_EXTRACTION_BUDGET,
+        chargedPaths: new Set(),
+        discoveredIdentities: new Map(),
+    };
+};
+const chargePath = (context, fullPath) => {
+    const key = pathKey(fullPath);
+    if (context.chargedPaths.has(key))
+        return;
+    const relativePath = toPosixPath(path.relative(context.rootPath, path.resolve(fullPath)));
+    context.directory = addArchiveDirectoryEntry(context.directory, {
+        name: relativePath,
+        size: 0,
+        originalSize: 0,
+        compression: 0,
+    }, context.limits);
+    context.chargedPaths.add(key);
+};
+const recordDiscoveredIdentity = (context, fullPath, stats) => {
+    const key = pathKey(fullPath);
+    const identity = getFileIdentity(stats);
+    const previous = context.discoveredIdentities.get(key);
+    if (previous && !sameFileIdentity(previous, identity)) {
+        throw new InputFileError('identity-changed', fullPath, `Input identity changed during directory analysis: ${fullPath}`);
+    }
+    context.discoveredIdentities.set(key, identity);
+};
+const inspectDirectoryEntry = async (context, fullPath) => {
+    const stats = await lstat(fullPath);
+    chargePath(context, fullPath);
+    if (stats.isSymbolicLink()) {
+        throw new InputFileError('symlink', fullPath, `Symbolic-link entries are not allowed: ${fullPath}`);
+    }
+    await assertPathInsideContext(context, fullPath);
+    recordDiscoveredIdentity(context, fullPath, stats);
+    return stats;
+};
+const readNodeTextFileWithinBudget = async (filePath, context) => {
+    chargePath(context, filePath);
+    await assertPathInsideContext(context, filePath);
+    const remainingBytes = context.limits.maxExtractedBytes - context.extraction.extractedBytes;
+    const maxBytes = Math.min(context.limits.maxFileBytes, remainingBytes);
+    const limitCode = context.limits.maxFileBytes <= remainingBytes ? 'file-size' : 'extracted-size';
+    const bytes = await readBoundedRegularFile(filePath, maxBytes, (actualBytes) => new ArchiveLimitError(limitCode, limitCode === 'extracted-size'
+        ? context.extraction.extractedBytes + actualBytes
+        : actualBytes, limitCode === 'extracted-size' ? context.limits.maxExtractedBytes : context.limits.maxFileBytes), { expectedIdentity: context.discoveredIdentities.get(pathKey(filePath)) });
+    context.extraction = addSelectedEntry(context.extraction, createStoredFileMetadata(toPosixPath(filePath), bytes.byteLength), context.limits, false);
+    return decodeNodeBytes(bytes);
+};
+const collectFocusedFileContents = async (logPaths, focus, context) => {
     const chunks = [];
     for (const logPath of sortLogPaths(logPaths)) {
-        const content = await readNodeTextFileContent(logPath);
+        const content = await readNodeTextFileWithinBudget(logPath, context);
         if (!contentMatchesFocus(content, focus))
             continue;
         chunks.push({
@@ -282,14 +367,26 @@ const buildDefaultZipContent = (entries, paths, basePath, sourceRef) => {
     }
     return joinMergedWithSources(chunks);
 };
-export const readNodeTextFileContent = async (filePath) => {
-    const bytes = await readFile(filePath);
-    return decodeNodeBytes(new Uint8Array(bytes));
+export const readNodeTextFileContent = async (filePath, options = {}) => {
+    const limits = resolveArchiveLimits(options.archiveLimits);
+    const context = options.budgetContext ?? await createNodeInputBudgetContext(path.dirname(path.resolve(filePath)), limits);
+    return readNodeTextFileWithinBudget(filePath, context);
+};
+export const readNodeTextFilesContent = async (filePaths, options = {}) => {
+    const limits = resolveArchiveLimits(options.archiveLimits);
+    const commonRoot = filePaths.length > 0
+        ? path.dirname(path.resolve(filePaths[0]))
+        : process.cwd();
+    const context = options.budgetContext ?? await createNodeInputBudgetContext(commonRoot, limits);
+    const contents = [];
+    for (const filePath of filePaths) {
+        contents.push(await readNodeTextFileWithinBudget(filePath, context));
+    }
+    return contents;
 };
 export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip', options = {}) => {
-    const files = unzipSync(zipData, {
-        filter: (entry) => isNeededZipEntry(entry.name),
-    });
+    const limits = resolveArchiveLimits(options.archiveLimits);
+    const { files } = extractZipEntriesWithinLimits(zipData, isNeededZipEntry, limits);
     const paths = Object.keys(files);
     const basePath = findBaseDirectory(paths);
     if (basePath == null)
@@ -343,71 +440,163 @@ export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip
     return { content: merged.content, sourceSegments: merged.segments, errorImages, visionImages, waitFreezesImages, textFiles };
 };
 export const extractZipContentFromNodeFile = async (zipFilePath, options = {}) => {
-    const bytes = await readFile(zipFilePath);
-    return extractZipContentFromNodeBuffer(new Uint8Array(bytes), zipFilePath, options);
+    const limits = resolveArchiveLimits(options.archiveLimits);
+    const bytes = await readNodeArchiveFileBytes(zipFilePath, limits);
+    return extractZipContentFromNodeBuffer(bytes, zipFilePath, {
+        ...options,
+        archiveLimits: limits,
+    });
 };
-const pathExists = async (targetPath) => {
+export const readNodeArchiveFileBytes = async (zipFilePath, limits) => {
+    assertArchiveInputsWithinLimits([{ size: 0 }], limits);
+    const context = await createNodeInputBudgetContext(path.dirname(path.resolve(zipFilePath)), limits);
+    chargePath(context, zipFilePath);
+    await assertPathInsideContext(context, zipFilePath);
+    const bytes = await readBoundedRegularFile(zipFilePath, limits.maxCompressedBytes, (actualBytes) => new ArchiveLimitError('compressed-size', actualBytes, limits.maxCompressedBytes));
+    assertArchiveInputsWithinLimits([{ size: bytes.byteLength }], limits);
+    return bytes;
+};
+const assertDirectoryIdentity = (directoryPath, expected, stats) => {
+    if (!stats.isDirectory() || stats.isSymbolicLink()) {
+        throw new InputFileError('not-directory', directoryPath, `Expected a stable directory: ${directoryPath}`);
+    }
+    if (!sameFileIdentity(expected, getFileIdentity(stats))) {
+        throw new InputFileError('identity-changed', directoryPath, `Directory identity changed during traversal: ${directoryPath}`);
+    }
+};
+const inspectDirectory = async (context, directoryPath) => {
+    if (pathKey(directoryPath) !== pathKey(context.rootPath))
+        chargePath(context, directoryPath);
+    const stats = await lstat(directoryPath);
+    if (stats.isSymbolicLink()) {
+        throw new InputFileError('symlink', directoryPath, `Symbolic-link directories are not allowed: ${directoryPath}`);
+    }
+    if (!stats.isDirectory()) {
+        throw new InputFileError('not-directory', directoryPath, `Expected a directory: ${directoryPath}`);
+    }
+    await assertPathInsideContext(context, directoryPath);
+    recordDiscoveredIdentity(context, directoryPath, stats);
+    return stats;
+};
+const withSafeDirectory = async (context, directoryPath, consume) => {
+    const beforeOpen = await inspectDirectory(context, directoryPath);
+    const expectedIdentity = getFileIdentity(beforeOpen);
+    const directory = await opendir(directoryPath);
+    const afterOpen = await lstat(directoryPath);
+    assertDirectoryIdentity(directoryPath, expectedIdentity, afterOpen);
     try {
-        await stat(targetPath);
+        return await consume(directory);
+    }
+    finally {
+        await directory.close().catch(() => undefined);
+        const afterRead = await lstat(directoryPath);
+        assertDirectoryIdentity(directoryPath, expectedIdentity, afterRead);
+    }
+};
+const tryInspectDirectory = async (context, directoryPath) => {
+    try {
+        await inspectDirectory(context, directoryPath);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
     }
 };
-const hasMainLogInDirectory = async (dirPath) => {
+export const hasNodeMainLogInDirectory = async (context, directoryPath) => {
+    if (!await tryInspectDirectory(context, directoryPath))
+        return false;
     for (const name of MAIN_LOG_NAMES) {
-        if (await pathExists(path.join(dirPath, name))) {
-            return true;
+        const candidatePath = path.join(directoryPath, name);
+        try {
+            const stats = await inspectDirectoryEntry(context, candidatePath);
+            if (stats.isFile())
+                return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
         }
     }
     return false;
 };
-const findDebugDirectoryRecursively = async (rootPath) => {
-    const entries = await readdir(rootPath, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const subDirPath = path.join(rootPath, entry.name);
-        if (await hasMainLogInDirectory(subDirPath)) {
-            return subDirPath;
+export const findExistingRegularNodeFile = async (context, directoryPath, names) => {
+    for (const name of names) {
+        const candidatePath = path.join(directoryPath, name);
+        try {
+            const stats = await inspectDirectoryEntry(context, candidatePath);
+            if (stats.isFile())
+                return candidatePath;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
         }
-        const nested = await findDebugDirectoryRecursively(subDirPath);
-        if (nested)
-            return nested;
     }
     return null;
 };
-const resolveDebugDirectory = async (inputPath) => {
-    if (await hasMainLogInDirectory(inputPath)) {
-        return inputPath;
+const findDebugDirectoryRecursively = async (rootPath, context) => {
+    const pending = [rootPath];
+    while (pending.length > 0) {
+        const currentPath = pending.pop();
+        if (!currentPath)
+            break;
+        const found = await withSafeDirectory(context, currentPath, async (directory) => {
+            for await (const entry of directory) {
+                const fullPath = path.join(currentPath, entry.name);
+                const stats = await inspectDirectoryEntry(context, fullPath);
+                if (!stats.isDirectory())
+                    continue;
+                if (await hasNodeMainLogInDirectory(context, fullPath))
+                    return fullPath;
+                pending.push(fullPath);
+            }
+            return null;
+        });
+        if (found)
+            return found;
     }
+    return null;
+};
+export const resolveNodeDebugDirectory = async (inputPath, context) => {
+    if (await hasNodeMainLogInDirectory(context, inputPath))
+        return inputPath;
     const directDebugPath = path.join(inputPath, 'debug');
-    if (await hasMainLogInDirectory(directDebugPath)) {
+    if (await hasNodeMainLogInDirectory(context, directDebugPath))
         return directDebugPath;
-    }
-    return findDebugDirectoryRecursively(inputPath);
+    return findDebugDirectoryRecursively(inputPath, context);
 };
-const collectFilesRecursively = async (rootPath) => {
+const collectFilesRecursively = async (rootPath, context) => {
     const collected = [];
-    const entries = await readdir(rootPath, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(rootPath, entry.name);
-        if (entry.isDirectory()) {
-            const nested = await collectFilesRecursively(fullPath);
-            collected.push(...nested);
-            continue;
-        }
-        collected.push(fullPath);
+    const pending = [rootPath];
+    while (pending.length > 0) {
+        const currentPath = pending.pop();
+        if (!currentPath)
+            break;
+        await withSafeDirectory(context, currentPath, async (directory) => {
+            for await (const entry of directory) {
+                const fullPath = path.join(currentPath, entry.name);
+                const stats = await inspectDirectoryEntry(context, fullPath);
+                if (stats.isDirectory()) {
+                    pending.push(fullPath);
+                }
+                else if (stats.isFile()) {
+                    collected.push(fullPath);
+                }
+            }
+        });
     }
     return collected;
 };
 const pickPrimaryLogPath = async (debugPath, allFiles, candidates) => {
     for (const name of candidates) {
         const directPath = path.join(debugPath, name);
-        if (await pathExists(directPath)) {
-            return directPath;
-        }
+        const directMatch = allFiles.find((filePath) => pathKey(filePath) === pathKey(directPath));
+        if (directMatch)
+            return directMatch;
     }
     const normalizedCandidates = new Set(candidates.map((name) => name.toLowerCase()));
     for (const filePath of allFiles) {
@@ -418,20 +607,20 @@ const pickPrimaryLogPath = async (debugPath, allFiles, candidates) => {
     }
     return null;
 };
-const buildDefaultDirectoryContent = async (debugPath, allFiles) => {
+const buildDefaultDirectoryContent = async (debugPath, allFiles, context) => {
     const bakLogPath = await pickPrimaryLogPath(debugPath, allFiles, BAK_LOG_NAMES);
     const mainLogPath = await pickPrimaryLogPath(debugPath, allFiles, MAIN_LOG_NAMES);
     const chunks = [];
     if (bakLogPath) {
         chunks.push({
-            content: await readNodeTextFileContent(bakLogPath),
+            content: await readNodeTextFileWithinBudget(bakLogPath, context),
             source: toFileReference(bakLogPath),
             path: toPosixPath(path.relative(debugPath, bakLogPath)),
         });
     }
     if (mainLogPath) {
         chunks.push({
-            content: await readNodeTextFileContent(mainLogPath),
+            content: await readNodeTextFileWithinBudget(mainLogPath, context),
             source: toFileReference(mainLogPath),
             path: toPosixPath(path.relative(debugPath, mainLogPath)),
         });
@@ -439,13 +628,15 @@ const buildDefaultDirectoryContent = async (debugPath, allFiles) => {
     return joinMergedWithSources(chunks);
 };
 export const loadNodeLogDirectory = async (inputDirectoryPath, options = {}) => {
-    const debugPath = await resolveDebugDirectory(inputDirectoryPath);
+    const limits = resolveArchiveLimits(options.archiveLimits);
+    const context = await createNodeInputBudgetContext(inputDirectoryPath, limits);
+    const debugPath = await resolveNodeDebugDirectory(inputDirectoryPath, context);
     if (!debugPath)
         return null;
-    const allFiles = await collectFilesRecursively(debugPath);
+    const allFiles = await collectFilesRecursively(debugPath, context);
     const merged = options.focus
-        ? await collectFocusedFileContents(allFiles.filter((filePath) => isCoreLogName(path.basename(filePath))), options.focus)
-        : await buildDefaultDirectoryContent(debugPath, allFiles);
+        ? await collectFocusedFileContents(allFiles.filter((filePath) => isCoreLogName(path.basename(filePath))), options.focus, context)
+        : await buildDefaultDirectoryContent(debugPath, allFiles, context);
     if (!merged.content)
         return null;
     const errorImages = new Map();
@@ -479,7 +670,7 @@ export const loadNodeLogDirectory = async (inputDirectoryPath, options = {}) =>
         textFiles.push({
             path: relativePath,
             name: fileName,
-            content: await readNodeTextFileContent(absolutePath),
+            content: await readNodeTextFileWithinBudget(absolutePath, context),
             reference: toFileReference(absolutePath),
         });
     }

package/dist/runtimeInspection.d.ts

@@ -61,6 +61,15 @@ export interface RecognitionOccurrenceSample {
         end: RuntimeEvidencePosition;
     };
 }
+export interface RepeatedNodeOccurrenceSample {
+    pattern: string[];
+    firstSeenAt: string;
+    lastSeenAt: string;
+    repeatCount: number;
+    durationMs: number;
+    termination: 'left_pattern' | 'task_ended' | 'still_repeating_at_log_end';
+    evidence: RuntimeEvidencePosition;
+}
 export interface RecognitionActivitySignal extends RuntimeScope {
     signalId: string;
     kind: 'recognition_activity';
@@ -116,24 +125,9 @@ export interface RepeatedNodeSequenceSignal extends RuntimeScope {
         stillRepeatingAtLogEnd: number;
     };
     representatives: {
-        first: {
-            firstSeenAt: string;
-            lastSeenAt: string;
-            repeatCount: number;
-            evidence: RuntimeEvidencePosition;
-        };
-        longest: {
-            firstSeenAt: string;
-            lastSeenAt: string;
-            repeatCount: number;
-            evidence: RuntimeEvidencePosition;
-        };
-        last: {
-            firstSeenAt: string;
-            lastSeenAt: string;
-            repeatCount: number;
-            evidence: RuntimeEvidencePosition;
-        };
+        first: RepeatedNodeOccurrenceSample;
+        longest: RepeatedNodeOccurrenceSample;
+        last: RepeatedNodeOccurrenceSample;
     };
     detector: {
         name: 'repeated-completed-node-sequence';

package/dist/runtimeInspection.js

@@ -395,21 +395,30 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             const last = completed[lastIndex];
             if (!first || !last)
                 continue;
-            const reachesEnd = lastIndex === completed.length - 1;
             const rawPattern = completed.slice(repeated.start, repeated.start + repeated.length).map(node => node.name);
             const pattern = repeated.length === 1 ? rawPattern : canonicalCycle(rawPattern);
             const kind = repeated.length === 1 ? 'repeated_node' : 'repeated_node_cycle';
             const key = JSON.stringify([kind, pattern]);
             const group = repetitionGroups.get(key) ?? [];
+            const timelineLastIndex = timeline.findIndex(item => item.nodeInfo === last);
+            const trailing = timelineLastIndex < 0 ? [] : timeline.slice(timelineLastIndex + 1);
+            const reachesCompletedEnd = lastIndex === completed.length - 1;
+            const continuesAtLogEnd = reachesCompletedEnd
+                && task.status === 'running'
+                && trailing.every((item, offset) => (item.nodeInfo.status === 'running'
+                    && item.nodeInfo.name === rawPattern[offset % rawPattern.length]));
+            const taskEndedAtPattern = reachesCompletedEnd
+                && timelineLastIndex === timeline.length - 1
+                && task.status !== 'running';
             group.push({
                 pattern,
                 repeatCount: repeated.count,
                 durationMs: elapsed(first.ts, last.end_ts ?? last.ts) ?? 0,
                 firstSeenAt: first.ts,
                 lastSeenAt: last.end_ts ?? last.ts,
-                termination: reachesEnd
-                    ? task.status === 'running' ? 'still_repeating_at_log_end' : 'task_ended'
-                    : 'left_pattern',
+                termination: continuesAtLogEnd
+                    ? 'still_repeating_at_log_end'
+                    : taskEndedAtPattern ? 'task_ended' : 'left_pattern',
                 evidence: evidenceAt(evidenceIndex, first.ts),
             });
             repetitionGroups.set(key, group);
@@ -429,8 +438,6 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             const totalRepeatCount = group.reduce((sum, item) => sum + item.repeatCount, 0);
             const maximumRepeatCount = Math.max(...group.map(item => item.repeatCount));
             const repetitionReasons = [];
-            if (terminations.leftPattern > 0)
-                repetitionReasons.push('incomplete_repetition');
             if (terminations.stillRepeatingAtLogEnd > 0)
                 repetitionReasons.push('still_repeating_at_log_end');
             if (maximumRepeatCount >= 10 || totalRepeatCount >= 20)
@@ -483,8 +490,9 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
         const visionImages = imageSets.flatMap(set => set.vision);
         const ownFailures = failures.filter(failure => directFailureIds.includes(failure.failureId));
         const ownSignals = signals.filter(signal => signalIds.includes(signal.signalId));
-        const recognitionActivity = ownSignals
-            .filter((signal) => (signal.kind === 'recognition_activity'))
+        const recognitionSignals = ownSignals
+            .filter((signal) => (signal.kind === 'recognition_activity'));
+        const recognitionActivity = [...recognitionSignals]
             .sort((left, right) => (right.unsuccessfulAttempts.maximum - left.unsuccessfulAttempts.maximum
             || right.occurrenceCount - left.occurrenceCount))
             .slice(0, 5)
@@ -519,7 +527,7 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                     const statuses = new Set(attempts.map(attempt => attempt.status));
                     return statuses.has('failed') && statuses.has('success');
                 }).length,
-                recognitionActivityGroups: recognitionActivity.length,
+                recognitionActivityGroups: recognitionSignals.length,
                 maximumRecognitionAttemptsPerNode: Math.max(0, ...attemptsByNode.map(attempts => attempts.length)),
                 maximumUnsuccessfulRecognitionAttemptsPerNode: Math.max(0, ...attemptsByNode.map(attempts => attempts.filter(attempt => attempt.status === 'failed').length)),
                 actionAttempts: timeline.filter(item => item.nodeInfo.action_details != null).length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windsland52/maa-log-tools",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "type": "module",
   "private": false,
   "bin": {
@@ -42,13 +42,13 @@
   },
   "dependencies": {
     "fflate": "^0.8.2",
-    "@windsland52/maa-log-adapter": "1.0.1",
-    "@windsland52/maa-log-kernel": "1.0.1",
-    "@windsland52/maa-log-parser": "1.0.1",
-    "@windsland52/maa-log-runtime": "1.0.1"
+    "@windsland52/maa-log-adapter": "1.1.0",
+    "@windsland52/maa-log-parser": "1.1.0",
+    "@windsland52/maa-log-kernel": "1.0.2",
+    "@windsland52/maa-log-runtime": "1.1.0"
   },
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=20.18.0"
   },
   "publishConfig": {
     "access": "public"
@@ -64,7 +64,7 @@
   },
   "scripts": {
     "typecheck": "tsc -p ./tsconfig.json",
-    "build": "pnpm run clean && tsc -p ./tsconfig.build.json && node ../../scripts/fix-esm-imports.mjs ./dist",
+    "build": "node -e \"require('node:fs').rmSync('dist',{ recursive: true, force: true })\" && tsc -p ./tsconfig.build.json && node ../../scripts/fix-esm-imports.mjs ./dist",
     "clean": "node -e \"require('node:fs').rmSync('dist',{ recursive: true, force: true })\""
   }
 }