@windsland52/maa-log-tools 1.2.2 → 1.3.1

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.js

@@ -64,6 +64,39 @@ const imagesFor = (node) => {
         vision: attempts.map(item => item.vision_image).filter((item) => Boolean(item)),
     };
 };
+const ownedRecognitionItems = (items) => ((items ?? []).flatMap(item => {
+    if (item.type === 'task' || item.type === 'pipeline_node')
+        return [];
+    return [
+        ...(item.type === 'recognition' || item.type === 'recognition_node' ? [item] : []),
+        ...ownedRecognitionItems(item.children),
+    ];
+}));
+const imagesForFlowItem = (item) => {
+    const attempts = ownedRecognitionItems(item.children);
+    return {
+        error: [item.error_image, ...attempts.map(attempt => attempt.error_image)]
+            .filter((image) => Boolean(image)),
+        vision: [item.vision_image, ...attempts.map(attempt => attempt.vision_image)]
+            .filter((image) => Boolean(image)),
+    };
+};
+const hasFailedOwnedAction = (items) => ((items ?? []).some(item => {
+    if (item.type === 'task' || item.type === 'pipeline_node')
+        return false;
+    if ((item.type === 'action' || item.type === 'action_node')
+        && (item.status === 'failed' || item.action_details?.success === false))
+        return true;
+    return hasFailedOwnedAction(item.children);
+}));
+const hasFailedNestedTask = (items) => ((items ?? []).some(item => (item.type === 'task' ? item.status === 'failed' : hasFailedNestedTask(item.children))));
+const nestedPipelineFailureKind = (item) => {
+    if (item.status !== 'failed')
+        return null;
+    if (item.action_details?.success === false || hasFailedOwnedAction(item.children))
+        return 'action_failed';
+    return hasFailedNestedTask(item.children) ? null : 'next_list_timeout';
+};
 const scopeFor = (task, sessionId, executionId) => ({
     sessionId,
     executionId,
@@ -215,7 +248,99 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
         const recognitionOccurrences = [];
         const evidenceIndex = buildEvidenceIndex(task);
         const timeline = buildNodeExecutionTimeline(task.nodes, { rootTaskId: task.task_id });
+        const seenNestedTasks = new Set();
+        const seenNestedPipelines = new Set();
+        const inspectNestedTask = (taskItem) => {
+            if (seenNestedTasks.has(taskItem.id))
+                return;
+            seenNestedTasks.add(taskItem.id);
+            const taskId = taskItem.task_details?.task_id ?? taskItem.task_id;
+            if (taskId == null) {
+                inspectNestedTasks(taskItem.children);
+                return;
+            }
+            const nestedScope = {
+                sessionId,
+                executionId,
+                taskId,
+                taskName: taskItem.task_details?.entry ?? taskItem.name,
+            };
+            const nestedDirectFailureIds = [];
+            const inspectOwnedItems = (items) => {
+                for (const child of items ?? []) {
+                    if (child.type === 'task') {
+                        inspectNestedTask(child);
+                        continue;
+                    }
+                    if (child.type !== 'pipeline_node') {
+                        inspectOwnedItems(child.children);
+                        continue;
+                    }
+                    if (seenNestedPipelines.has(child.id))
+                        continue;
+                    seenNestedPipelines.add(child.id);
+                    inspectOwnedItems(child.children);
+                    const failureKind = nestedPipelineFailureKind(child);
+                    let nodeFailureId = null;
+                    if (failureKind && child.node_id != null) {
+                        nodeFailureId = `failure-${failures.length + 1}`;
+                        const images = imagesForFlowItem(child);
+                        failures.push({
+                            ...nestedScope,
+                            failureId: nodeFailureId,
+                            kind: failureKind,
+                            nodeId: child.node_id,
+                            nodeName: child.name,
+                            startedAt: child.ts,
+                            endedAt: child.end_ts ?? null,
+                            errorImages: [...new Set(images.error)],
+                            visionImages: [...new Set(images.vision)],
+                            evidence: evidenceAt(evidenceIndex, child.end_ts ?? child.ts),
+                        });
+                        nestedDirectFailureIds.push(nodeFailureId);
+                    }
+                    if (child.status !== 'success') {
+                        const outcomeId = `outcome-${outcomes.length + 1}`;
+                        outcomes.push({
+                            ...nestedScope,
+                            outcomeId,
+                            kind: 'pipeline_node',
+                            status: child.status,
+                            nodeId: child.node_id ?? null,
+                            nodeName: child.name,
+                            directFailureIds: nodeFailureId ? [nodeFailureId] : [],
+                            evidence: evidenceAt(evidenceIndex, child.end_ts ?? child.ts),
+                        });
+                        outcomeIds.push(outcomeId);
+                    }
+                }
+            };
+            inspectOwnedItems(taskItem.children);
+            if (taskItem.status !== 'success') {
+                const outcomeId = `outcome-${outcomes.length + 1}`;
+                outcomes.push({
+                    ...nestedScope,
+                    outcomeId,
+                    kind: 'task',
+                    status: taskItem.status,
+                    nodeId: null,
+                    nodeName: null,
+                    directFailureIds: nestedDirectFailureIds,
+                    evidence: evidenceAt(evidenceIndex, taskItem.end_ts ?? taskItem.ts),
+                });
+                outcomeIds.push(outcomeId);
+            }
+        };
+        const inspectNestedTasks = (items) => {
+            for (const item of items ?? []) {
+                if (item.type === 'task')
+                    inspectNestedTask(item);
+                else
+                    inspectNestedTasks(item.children);
+            }
+        };
         for (const item of timeline) {
+            inspectNestedTasks(item.nodeInfo.node_flow);
             const failureKind = item.navStatus === 'action-failed'
                 ? 'action_failed'
                 : item.navStatus === 'timeout' && item.nodeInfo.next_list.length > 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windsland52/maa-log-tools",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "type": "module",
   "private": false,
   "bin": {
@@ -42,13 +42,13 @@
   },
   "dependencies": {
     "fflate": "^0.8.2",
-    "@windsland52/maa-log-adapter": "1.0.1",
-    "@windsland52/maa-log-runtime": "1.0.1",
-    "@windsland52/maa-log-kernel": "1.0.1",
-    "@windsland52/maa-log-parser": "1.0.1"
+    "@windsland52/maa-log-parser": "1.1.0",
+    "@windsland52/maa-log-kernel": "1.0.2",
+    "@windsland52/maa-log-adapter": "1.1.0",
+    "@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 })\""
   }
 }