dsh-flakefinder 0.3.4 → 0.4.0

package/lib/store.js

@@ -5,31 +5,67 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import lockfile from 'proper-lockfile';
 const HISTORY_FILE = 'history.json';
 const HISTORY_LIMIT = 200;
 export function createStore(dataDir, quarantineFile) {
     const historyPath = path.join(dataDir, HISTORY_FILE);
+    async function readJson(file) {
+        try {
+            const info = await fs.lstat(file);
+            if (!info.isFile() || info.isSymbolicLink() || info.size > 8 * 1024 * 1024)
+                throw new Error('文件不是普通 JSON 文件或超过 8 MiB');
+            return JSON.parse(await fs.readFile(file, 'utf8'));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw new Error('记录无法读取，原文件已保留：' + file + '。' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async function locked(file, update) {
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        const unlock = await lockfile.lock(file, { realpath: false, retries: { retries: 30, minTimeout: 25, maxTimeout: 100 } });
+        try {
+            return await update();
+        }
+        finally {
+            await unlock();
+        }
+    }
+    async function atomicWrite(file, value) {
+        const bytes = JSON.stringify(value, null, 2) + '\n';
+        if (Buffer.byteLength(bytes) > 8 * 1024 * 1024)
+            throw new Error('记录超过 8 MiB，本次没有保存。');
+        const temp = file + '.tmp-' + randomUUID();
+        try {
+            await fs.writeFile(temp, bytes, { flag: 'wx', mode: 0o600 });
+            await fs.rename(temp, file);
+        }
+        finally {
+            await fs.unlink(temp).catch(() => { });
+        }
+    }
     async function ensureDir() {
         await fs.mkdir(dataDir, { recursive: true });
     }
     async function readHistory() {
-        try {
-            const text = await fs.readFile(historyPath, 'utf8');
-            const parsed = JSON.parse(text);
-            return Array.isArray(parsed) ? parsed : [];
-        }
-        catch {
+        const parsed = await readJson(historyPath);
+        if (parsed === undefined)
             return [];
-        }
+        if (!Array.isArray(parsed) || parsed.some(entry => !entry || typeof entry.target !== 'string' || typeof entry.timestamp !== 'string' || !Array.isArray(entry.flakyTests)))
+            throw new Error('历史记录格式无效，原文件已保留：' + historyPath);
+        return parsed;
     }
     async function appendHistory(entry) {
         await ensureDir();
-        const list = await readHistory();
-        list.unshift(entry);
-        const trimmed = list.slice(0, HISTORY_LIMIT);
-        const tmp = historyPath + '.tmp-' + process.pid;
-        await fs.writeFile(tmp, JSON.stringify(trimmed, null, 2), 'utf8');
-        await fs.rename(tmp, historyPath);
+        return locked(historyPath, async () => {
+            const list = await readHistory();
+            list.unshift(entry);
+            const trimmed = list.slice(0, HISTORY_LIMIT);
+            await atomicWrite(historyPath, trimmed);
+        });
     }
     async function listHistory(target, limit) {
         const list = await readHistory();
@@ -37,55 +73,52 @@ export function createStore(dataDir, quarantineFile) {
         return filtered.slice(0, limit);
     }
     async function readQuarantine() {
-        try {
-            const text = await fs.readFile(quarantineFile, 'utf8');
-            const parsed = JSON.parse(text);
-            const obj = (parsed ?? {});
-            return {
-                version: 1,
-                quarantined: Array.isArray(obj.quarantined) ? obj.quarantined : [],
-            };
-        }
-        catch {
+        const parsed = await readJson(quarantineFile);
+        if (parsed === undefined)
             return { version: 1, quarantined: [] };
-        }
+        const obj = parsed;
+        if (!obj || obj.version !== 1 || !Array.isArray(obj.quarantined) || obj.quarantined.some(entry => !entry || typeof entry.file !== 'string' || !entry.file || entry.name !== null && typeof entry.name !== 'string' || typeof entry.reason !== 'string' || typeof entry.since !== 'string'))
+            throw new Error('隔离清单格式无效，原文件已保留：' + quarantineFile);
+        return obj;
     }
     async function writeQuarantine(doc) {
         await fs.mkdir(path.dirname(quarantineFile), { recursive: true });
-        const tmp = quarantineFile + '.tmp-' + process.pid;
-        await fs.writeFile(tmp, JSON.stringify(doc, null, 2) + '\n', 'utf8');
-        await fs.rename(tmp, quarantineFile);
+        await atomicWrite(quarantineFile, doc);
     }
     async function addQuarantine(refs, reason) {
-        const doc = await readQuarantine();
-        const now = new Date().toISOString();
-        const added = [];
-        for (const ref of refs) {
-            const existing = doc.quarantined.find(item => sameRef(item, ref));
-            if (existing !== undefined) {
-                existing.reason = reason;
-                existing.since = now;
-                continue;
+        return locked(quarantineFile, async () => {
+            const doc = await readQuarantine();
+            const now = new Date().toISOString();
+            const added = [];
+            for (const ref of refs) {
+                const existing = doc.quarantined.find(item => sameRef(item, ref));
+                if (existing !== undefined) {
+                    existing.reason = reason;
+                    existing.since = now;
+                    continue;
+                }
+                const entry = { file: ref.file, name: ref.name, reason, since: now };
+                doc.quarantined.push(entry);
+                added.push(entry);
             }
-            const entry = { file: ref.file, name: ref.name, reason, since: now };
-            doc.quarantined.push(entry);
-            added.push(entry);
-        }
-        doc.quarantined.sort((a, b) => a.file.localeCompare(b.file) || (a.name ?? '').localeCompare(b.name ?? ''));
-        await writeQuarantine(doc);
-        return { added, file: quarantineFile };
+            doc.quarantined.sort((a, b) => a.file.localeCompare(b.file) || (a.name ?? '').localeCompare(b.name ?? ''));
+            await writeQuarantine(doc);
+            return { added, file: quarantineFile };
+        });
     }
     async function removeQuarantine(refs) {
-        const doc = await readQuarantine();
-        const removed = [];
-        doc.quarantined = doc.quarantined.filter(item => {
-            const hit = refs.some(ref => sameRef(item, ref));
-            if (hit)
-                removed.push(item);
-            return !hit;
+        return locked(quarantineFile, async () => {
+            const doc = await readQuarantine();
+            const removed = [];
+            doc.quarantined = doc.quarantined.filter(item => {
+                const hit = refs.some(ref => sameRef(item, ref));
+                if (hit)
+                    removed.push(item);
+                return !hit;
+            });
+            await writeQuarantine(doc);
+            return { removed, file: quarantineFile };
         });
-        await writeQuarantine(doc);
-        return { removed, file: quarantineFile };
     }
     return {
         appendHistory,

package/lib/tools.js

@@ -8,7 +8,8 @@ import { buildPlan, readFramework } from './args.js';
 import { aggregate, flakyTests } from './classify.js';
 import { assertTarget, optionalInteger, optionalString, requiredString, resolveRuns, } from './config.js';
 import { executePlan } from './runner.js';
-import { formatRef, parseRef } from './store.js';
+import { createStore, formatRef, parseRef } from './store.js';
+import { resolve } from 'node:path';
 function compileParameters(spec) {
     const properties = {};
     const required = [];
@@ -98,6 +99,18 @@ const detectSchema = {
 };
 /** 构建五个工具定义。 */
 export function buildFlakeTools(cfg, runner, store) {
+    return buildWorkspaceTools(cfg, runner, store).map(tool => ({ ...tool, async execute(args, exec) {
+            const context = exec;
+            const signal = context?.signal;
+            signal?.throwIfAborted();
+            const cwd = context?.agent?.session?.header?.cwd || process.cwd();
+            const scopedStore = context?.agent?.session?.header?.cwd && cfg.quarantineFileRelative ? createStore(cfg.dataDir, resolve(cwd, cfg.quarantineFileRelative)) : store;
+            const scopedRunner = { run: (argv, options) => runner.run(argv, { ...options, cwd, signal }) };
+            const selected = buildWorkspaceTools(cfg, scopedRunner, scopedStore, cwd, signal).find(row => row.name === tool.name);
+            return selected.execute(args, exec);
+        } }));
+}
+function buildWorkspaceTools(cfg, runner, store, cwd = process.cwd(), signal) {
     const detect = {
         name: 'flaky_detect',
         description: '重复运行测试多次并判定稳定性：stable-pass（全过）/ stable-fail（全挂）/ flaky（时好时坏）。支持 vitest / jest / pytest / node:test，自动探测本地框架。结果写入历史供 flaky_report 分析。',
@@ -119,11 +132,12 @@ export function buildFlakeTools(cfg, runner, store) {
             const target = assertTarget(requiredString(args, 'target', '测试目标'));
             const requested = readFramework(args.framework);
             const runs = resolveRuns(args.runs, cfg);
-            const plans = Array.from({ length: runs }, (_, index) => buildPlan(process.cwd(), target, requested, index, cfg.pythonPath));
+            const plans = Array.from({ length: runs }, (_, index) => buildPlan(cwd, target, requested, index, cfg.pythonPath));
             const framework = plans[0]?.framework ?? 'node';
             const executed = [];
             for (let index = 0; index < plans.length; index += 1) {
-                executed.push(await executePlan(runner, plans[index], index + 1, cfg.timeoutMs));
+                signal?.throwIfAborted();
+                executed.push(await executePlan(runner, plans[index], index + 1, cfg.timeoutMs, cwd, signal));
             }
             const result = aggregate(executed.map(item => ({ index: item.index, report: item.report, durationMs: item.durationMs, error: item.error })));
             const flaky = flakyTests(result);
@@ -140,6 +154,7 @@ export function buildFlakeTools(cfg, runner, store) {
                 skippedCount: result.skippedCount,
                 flakyTests: flaky,
             };
+            signal?.throwIfAborted();
             await store.appendHistory(entry);
             return {
                 target,